Adds deposit date into cocina description.

closes #2368

app/services/cocina_generator/description/date_generator.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module CocinaGenerator
+  module Description
+    # Generator for Cocina dates encoded as EDTF
+    class DateGenerator
+      # @param [EDTF::*|ActiveSupport::TimeWithZone] date
+      # @param [type] type for date
+      # @param [boolean] primary - whether status is primary
+      # @return [Hash] the props for the date
+      def self.generate(date:, type: nil, primary: false)
+        new(date: date, type: type, primary: primary).generate
+      end
+
+      def initialize(date:, type:, primary:)
+        @date = date
+        @type = type
+        @primary = primary
+      end
+
+      def generate
+        {
+          encoding: { code: 'edtf' },
+          type: type,
+          status: primary ? 'primary' : nil
+        }.compact.merge(date_props)
+      end
+
+      private
+
+      attr_reader :date, :type, :primary
+
+      def date_props
+        case @date
+        when EDTF::Interval
+          interval_props(date)
+        when ActiveSupport::TimeWithZone
+          time_with_zone_props(date)
+        else
+          edtf_date_props(date)
+        end
+      end
+
+      def interval_props(interval_date)
+        {
+          structuredValue: interval_structured_values(interval_date)
+        }.tap do |props|
+          if interval_date.from&.uncertain? || interval_date.to&.uncertain?
+            props[:qualifier] = 'approximate'
+            props[:structuredValue].each { |struct_date_val| struct_date_val.delete(:qualifier) }
+          end
+        end.compact
+      end
+
+      def interval_structured_values(interval_date)
+        [].tap do |structured_values|
+          structured_values << edtf_date_props(interval_date.from, type: 'start') if interval_date.from
+          structured_values << edtf_date_props(interval_date.to, type: 'end') if interval_date.to
+        end
+      end
+
+      def edtf_date_props(edtf_date, type: nil)
+        {
+          qualifier: edtf_date.uncertain? ? 'approximate' : nil,
+          value: edtf_date.edtf.chomp('?'),
+          type: type
+        }.compact
+      end
+
+      def time_with_zone_props(zone_date)
+        {
+          value: zone_date.strftime('%Y-%m-%d')
+        }
+      end
+    end
+  end
+end

app/services/cocina_generator/description/events_generator.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module CocinaGenerator
+  module Description
+    # This generates Events for a work
+    class EventsGenerator
+      def self.generate(work_version:)
+        new(work_version: work_version).generate
+      end
+
+      def initialize(work_version:)
+        @work_version = work_version
+      end
+
+      def generate
+        events = deposit_events + Array(created_date_event)
+        events += publisher_events.presence || Array(published_date_event)
+        events
+      end
+
+      private
+
+      attr_reader :work_version
+
+      def publisher_events
+        @publisher_events ||= ContributorsGenerator.events_from_publisher_contributors(work_version: work_version,
+                                                                                       pub_date: published_date_event)
+      end
+
+      def published_date_event
+        event_for_date(date: work_version.published_edtf, event_type: 'publication', date_type: 'publication',
+                       primary: true)
+      end
+
+      def created_date_event
+        event_for_date(date: work_version.created_edtf, event_type: 'creation', date_type: 'creation')
+      end
+
+      def deposit_events
+        return [] if deposit_versions.blank?
+
+        Array(deposit_publication_event) + deposit_modification_events
+      end
+
+      def deposit_publication_event
+        event_for_work_version(work_version: deposit_publication_version, event_type: 'deposit',
+                               date_type: 'publication')
+      end
+
+      def deposit_modification_events
+        deposit_modification_versions.map do |deposit_version|
+          event_for_work_version(work_version: deposit_version, event_type: 'deposit', date_type: 'modification')
+        end
+      end
+
+      def deposit_versions
+        # Treating this version as a deposit version
+        @deposit_versions ||= work_version.work.work_versions.filter do |check_work_version|
+          check_work_version.deposited? || check_work_version == work_version
+        end
+      end
+
+      def deposit_publication_version
+        deposit_versions.first
+      end
+
+      def deposit_modification_versions
+        deposit_versions.slice(1..-1)
+      end
+
+      def event_for_date(date:, event_type:, date_type:, primary: false)
+        return unless date
+
+        Cocina::Models::Event.new({
+                                    type: event_type,
+                                    date: [DateGenerator.generate(date: date, type: date_type, primary: primary)]
+                                  })
+      end
+
+      def event_for_work_version(work_version:, event_type:, date_type:)
+        date = work_version.published_at || work_version.updated_at
+        event_for_date(date: date, event_type: event_type, date_type: date_type)
+      end
+    end
+  end
+end

app/services/cocina_generator/description/generator.rb

@@ -19,7 +19,7 @@ def generate
           contributor: ContributorsGenerator.generate(work_version: work_version).presence,
           subject: keywords.presence,
           note: [abstract, citation].compact.presence,
-          event: generate_events.presence,
+          event: EventsGenerator.generate(work_version: work_version).presence,
           relatedResource: related_resources.presence,
           form: TypesGenerator.generate(work_version: work_version).presence,
           access: access,
@@ -43,15 +43,6 @@ def title
         ]
       end
 
-      def generate_events
-        pub_events = ContributorsGenerator.events_from_publisher_contributors(work_version: work_version,
-                                                                              pub_date: published_date)
-        return [created_date] + pub_events if pub_events.present? && created_date
-        return pub_events if pub_events.present? # and no created_date
-
-        [created_date, published_date].compact # no pub_events
-      end
-
       def related_resources
         RelatedLinksGenerator.generate(object: work_version) + related_works
       end
@@ -91,57 +82,6 @@ def citation
         )
       end
 
-      def created_date
-        event_for(work_version.created_edtf, 'creation')
-      end
-
-      def published_date
-        event_for(work_version.published_edtf, 'publication')
-      end
-
-      def event_for(date, type)
-        return unless date
-
-        date_props = {
-          encoding: { code: 'edtf' },
-          type: type
-        }.merge(date.is_a?(EDTF::Interval) ? interval_props_for(date) : date_props_for(date))
-
-        Cocina::Models::Event.new(
-          type: type,
-          date: [date_props]
-        )
-      end
-
-      # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/CyclomaticComplexity
-
-      def interval_props_for(date)
-        structured_values = []
-        structured_values << date_props_for(date.from, type: 'start') if date.from
-        structured_values << date_props_for(date.to, type: 'end') if date.to
-        result_props = {
-          structuredValue: structured_values
-        }
-
-        if date.from&.uncertain? || date.to&.uncertain?
-          result_props[:qualifier] = 'approximate'
-          result_props[:structuredValue].each { |struct_date_val| struct_date_val.delete(:qualifier) }
-        end
-
-        result_props.compact
-      end
-      # rubocop:enable Metrics/AbcSize
-      # rubocop:enable Metrics/CyclomaticComplexity
-
-      def date_props_for(date, type: nil)
-        {
-          type: type,
-          qualifier: date.uncertain? ? 'approximate' : nil,
-          value: date.edtf.chomp('?')
-        }.compact
-      end
-
       def access
         args = {
           accessContact: access_contacts
@@ -173,18 +113,11 @@ def related_works
         end
       end
 
-      # rubocop:disable Metrics/MethodLength
-
       def admin_metadata
         Cocina::Models::DescriptiveAdminMetadata.new(
           event: [
             Cocina::Models::Event.new(type: 'creation',
-                                      date: [
-                                        {
-                                          value: work_version.work.created_at.strftime('%Y-%m-%d'),
-                                          encoding: { code: 'w3cdtf' }
-                                        }
-                                      ])
+                                      date: [DateGenerator.generate(date: admin_metadata_creation_date)])
           ],
           note: [
             Cocina::Models::DescriptiveValue.new(
@@ -194,7 +127,10 @@ def admin_metadata
           ]
         )
       end
-      # rubocop:enable Metrics/MethodLength
+
+      def admin_metadata_creation_date
+        work_version.work.work_versions.first&.published_at || work_version.work.created_at
+      end
     end
   end
 end

db/structure.sql

@@ -21,6 +21,8 @@ CREATE TYPE public.work_access AS ENUM (
 
 SET default_tablespace = '';
 
+SET default_table_access_method = heap;
+
 --
 -- Name: abstract_contributors; Type: TABLE; Schema: public; Owner: -
 --

spec/factories/work_versions.rb

@@ -13,6 +13,7 @@
     access { 'world' }
     state { 'first_draft' }
     description { 'initial version' }
+    published_at { Time.zone.parse('2019-01-01') }
     work
 
     factory :valid_work_version do
@@ -159,4 +160,16 @@
     license { 'none' }
     state { 'reserving_purl' }
   end
+
+  trait :with_work do
+    transient do
+      collection { nil }
+      owner { association(:user) }
+    end
+    work { association :work, collection: collection, owner: owner, work_versions: [instance] }
+
+    after(:create) do |work_version, _evaluator|
+      work_version.work.update(head: work_version)
+    end
+  end
 end