entry_factory.rb in eco-helpers-2.0.19

- old
+ new

@@ -1,37 +1,52 @@
 module Eco
   module API
     module Common
       module People
+        # TODO: EntryFactory should suppport multiple schemas itself
+        # => currently, it's through session.entry_factory(schema: id), but this is wrong
+        # => This way, Entries and PersonEntry will be able to refer to attr_map and person_parser linked to schema_id
+        # => "schema_id" should be an optional column in the input file, or parsable via a custom parser to scope the schema
         # Helper factory class to generate entries (input entries).
         # @attr_reader schema [Ecoportal::API::V1::PersonSchema] person schema to be used in this entry factory
         class EntryFactory < Eco::API::Common::Session::BaseSession
 
           attr_reader :schema, :person_parser
 
           # @param e [Eco::API::Common::Session::Environment] requires a session environment, as any child of `Eco::API::Common::Session::BaseSession`
           # @param schema [Ecoportal::API::V1::PersonSchema] schema of person details that the parser will be based upon.
           # @param person_parser [nil, Eco::API::Common::People::PersonParser] set of attribute, type and format parsers/serializers.
           # @param attr_map [nil, Eco::Data::Mapper] attribute names mapper to translate external names into internal ones and _vice versa_.
-          def initialize(e, schema:, person_parser: nil, attr_map: nil)
+          def initialize(e, schema:, person_parser: nil, default_parser: nil, attr_map: nil)
             fatal "Constructor needs a PersonSchema. Given: #{schema}" if !schema.is_a?(Ecoportal::API::V1::PersonSchema)
             fatal "Expecting PersonParser. Given: #{person_parser}"    if person_parser && !person_parser.is_a?(Eco::API::Common::People::PersonParser)
             fatal "Expecting Mapper object. Given: #{fields_mapper}"   if attr_map && !attr_map.is_a?(Eco::Data::Mapper)
             super(e)
 
             @schema = Ecoportal::API::V1::PersonSchema.new(JSON.parse(schema.doc.to_json))
             @source_person_parser = person_parser
 
             # load default parser + custom parsers
-            base_parser = Eco::API::Common::People::DefaultParsers.new(schema: @schema).merge(@source_person_parser)
+            @default_parser = default_parser&.new(schema: @schema) || Eco::API::Common::People::DefaultParsers.new(schema: @schema)
+            base_parser = @default_parser.merge(@source_person_parser)
             # new parser with linked schema
             @person_parser = @source_person_parser.new(schema: @schema).merge(base_parser)
             @person_parser_patch_version = @source_person_parser.patch_version
-
             @attr_map = attr_map
           end
 
+          def newFactory(schema: nil)
+            self.class.new(
+              environment,
+              schema: schema,
+              person_parser: @source_person_parser,
+              default_parser: @default_parser,
+              attr_map: @attr_map
+            )
+          end
+
+
           # provides with a Eco::API::Common::People::PersonParser object (collection of attribute parsers)
           # @note if the custom person parser has changed, it updates the copy of this EntryFactory instance
           # @return [Eco::API::Common::People::PersonParser] set of attribute, type and format parsers/serializers.
           def person_parser
             if @person_parser_patch_version < @source_person_parser.patch_version
@@ -41,11 +56,11 @@
             @person_parser
           end
 
           # key method to generate objects of `PersonEntry` that share dependencies via this `EntryFactory` environment.
           # @note this method is necessary to make the factory object work as a if it was a class `PersonEntry` you can call `new` on.
-          # @param data [Array<Hash>] data to be parsed. The external hashed entry.
+          # @param data [Hash, Person] data to be parsed/serialized. Parsed: the external hashed entry. Serialized: a Person object.
           # @return [Eco::API::Common::People::PersonEntry]
           def new(data, dependencies: {})
             PersonEntry.new(
               data,
               person_parser: person_parser,
@@ -102,27 +117,29 @@
           # @param data [Eco::API::Organization::People] data to be parsed.
           # @param file [String] absolute or relative path to the ouput file.
           # @param format [Symbol] it specifies the format of the output `file:` (i.e. `:xml`, `:csv`). There must be a parser/serializer defined for it.
           # @param encoding [String] optional parameter to geneate `file:` content by unsing certain encoding.
           # @return [Void].
-          def export(data:, file: "export", format: :csv, encoding: "utf-8")
+          def export(data:, file: "export", format: :csv, encoding: "utf-8", internal_names: false)
             fatal("data: Expected Eco::API::Organization::People object. Given: #{data.class}") unless data.is_a?(Eco::API::Organization::People)
             fatal("A file should be specified.") unless !file.to_s.strip.empty?
             fatal("Format should be a Symbol. Given '#{format}'") if format && !format.is_a?(Symbol)
             fatal("There is no parser/serializer for format ':#{format.to_s}'") unless @person_parser.defined?(format)
 
             run = true
             if Eco::API::Common::Session::FileManager.file_exists?(file)
-              print "The file '#{file}' already exists. Do you want to overwrite it? (Y/n): "
-              res = STDIN.gets.strip
-              run = ["y", "Y", ""].include?(res)
+              prompt_user("The file '#{file}' already exists. Do you want to overwrite it? (Y/n):", default: "Y") do |response|
+                run = (response == "") || reponse.upcase.start_with?("Y")
+              end
             end
 
             if run
               deps = {"supervisor_id" => {people: data}}
 
               data_entries = data.map do |person|
-                self.new(person, dependencies: deps).external_entry
+                self.new(person, dependencies: deps).yield_self do |entry|
+                  internal_names ? entry.mapped_entry : entry.external_entry
+                end
               end
 
               File.open(file, "w", enconding: encoding) do |fd|
                 fd.write(person_parser.serialize(format, data_entries))
               end