specify_cli 0.0.5

data/lib/specify/models/auto_numbering_scheme.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Specify
+  module Model
+    # AutoNumberingSchemes represent automatically incrementable numbers
+    # (serial numbers such as catalog numbers or accession numbers).
+    #
+    # An AutoNumberingScheme is scoped to one or more #collections
+    # (instances of Specify::Model::Collection) in the case of catalog numbers,
+    # one or more #divisions (instances of Specify::Model::Division) in the case
+    # of accession numbers. Serial numbers (_incrementers_) will be incremented
+    # across that scope.
+    #
+    # An AutoNumberingScheme has a #number_format (an instance of
+    # Specify::NumberFormat) that determines the format of the number
+    # (auto-numbers in _Specify_ are strings).
+    class AutoNumberingScheme < Sequel::Model(:autonumberingscheme)
+      include Createable
+      include Updateable
+
+      many_to_one :created_by,
+                  class: 'Specify::Model::Agent',
+                  key: :CreatedByAgentID
+      many_to_one :modified_by,
+                  class: 'Specify::Model::Agent',
+                  key: :ModifiedByAgentID
+      many_to_many :collections,
+                   left_key: :AutoNumberingSchemeID,
+                   right_key: :CollectionID,
+                   join_table: :autonumsch_coll
+      many_to_many :disciplines,
+                   left_key: :AutoNumberingSchemeID,
+                   right_key: :DisciplineID,
+                   join_table: :autonumsch_dsp
+      many_to_many :divisions,
+                   left_key: :AutoNumberingSchemeID,
+                   right_key: :DivisionID,
+                   join_table: :autonumsch_div
+
+      # Returns +true+ if +self+ applies to catalog numbers.
+      def catalog_number?
+        scheme_model == CollectionObject && scheme_type == :catalog_number
+      end
+
+      # Returns the next available serial number in the scope of the scheme,
+      # formatted according to the #number_format.
+      def increment
+        @number_format ||= number_format
+        @number_format.create(@number_format.incrementer(max) + 1)
+      end
+
+      # Returns the currently highest number within the scope of self.
+      # Currently only supports catalog numbers.
+      def max
+        raise 'not implemented' unless catalog_number?
+        collections.map(&:highest_catalog_number).compact.max
+      end
+
+      # Returns the Specify::NumberFormat instance for the +self+.
+      def number_format
+        # TODO: get proper number format from xml
+        case self.FormatName
+        when 'CatalogNumberNumeric'
+          NumberFormat.new
+        end
+      end
+
+      # Returns the model class the numbering scheme applies to;
+      # Specify::Model::CollectionObject for catalog numbers,
+      # Specify::Model::Accession for accession numbers.
+      def scheme_model
+        case self.TableNumber
+        when 1
+          CollectionObject
+        when 7
+          Accession
+        end
+      end
+
+      # Returns a symbol for the type of numbering scheme
+      # (+:catalog_number+, +accession_number+, or +:custom+).
+      def scheme_type
+        case self.SchemeName
+        when 'Catalog Numbering Scheme'
+          :catalog_number
+        when 'Accession Numbering Scheme'
+          :accession_number
+        else
+          :custom
+        end
+      end
+    end
+  end
+end

data/lib/specify/models/collecting_event.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Specify
+  module Model
+    # CollectingEvents hold information about when, where, how, and by whom a
+    # Specify::Model::CollectionObject was collected.
+    #
+    # A CollectingEvent takes place in (has one) Specify::Model::Locality
+    # (_where_ it was collected).
+    #
+    # A CollectingEvent can have one or many #collection_objects, depending
+    # on the value of Specify::Model::Collection#embedded_collecting_event? for
+    # the collection an associated CollectionObject belongs to.
+    class CollectingEvent < Sequel::Model(:collectingevent)
+      include Createable
+      include Updateable
+
+      many_to_one :discipline,
+                  key: :DisciplineID
+      many_to_one :locality,
+                  key: :LocalityID
+      one_to_many :collection_objects,
+                  key: :CollectingEventID
+      many_to_one :created_by,
+                  class: 'Specify::Model::Agent',
+                  key: :CreatedByAgentID
+      many_to_one :modified_by,
+                  class: 'Specify::Model::Agent',
+                  key: :ModifiedByAgentID
+
+      # Sequel hook that assigns a GUID.
+      def before_create
+        self[:GUID] = SecureRandom.uuid
+        super
+      end
+    end
+  end
+end

data/lib/specify/models/collection.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Specify
+  module Model
+    # Collections are the lowest level of scope in a Specify::Database.
+    #
+    # A Collection belongs to the a Specify::Model::Discipline.
+    #
+    # A Collection contains all instances of Specify::Model::CollectionObject
+    # belonging to that collection.
+    class Collection < Sequel::Model(:collection)
+      include Updateable
+
+      many_to_one :discipline,
+                  key: :DisciplineID
+      one_to_many :collection_objects,
+                  key: :CollectionID
+      one_to_many :preparation_types,
+                  key: :CollectionID
+      one_to_many :record_sets,
+                  key: :CollectionMemberID
+      one_to_many :app_resource_dirs,
+                  class: 'Specify::Model::AppResourceDir',
+                  key: :CollectionID
+      one_through_one :auto_numbering_scheme,
+                      left_key: :CollectionID,
+                      right_key: :AutoNumberingSchemeID,
+                      join_table: :autonumsch_coll
+      one_to_one :view_set_dir,
+                 class: 'Specify::Model::AppResourceDir',
+                 key: :CollectionID do |ds|
+                   ds.where(discipline: discipline,
+                            UserType: nil,
+                            IsPersonal: false)
+                 end
+
+      # Returns +false+ if Specify::Model::CollectionObject instances in +self+
+      # can share Specify::Model::CollectingEvent instances. +false+ otherwise.
+      def embedded_collecting_event?
+        self[:IsEmbeddedCollectingEvent]
+      end
+
+      # Returns the highest Specify::Model::CollectionObject#catalog_number
+      # for collection_objects belonging to +self+.
+      def highest_catalog_number
+        collection_objects_dataset.max(:CatalogNumber)
+      end
+
+      # Creates a string representation of +self+.
+      def inspect
+        "#{self} name: #{self.CollectionName}"
+      end
+
+      # Returns a String that is the name of +self+.
+      def name
+        self[:CollectionName]
+      end
+
+      # Returns the Specify::Model::ViewSetObject that belongs to +self+.
+      # The +_collection+ argument will be discared and is only there to allow
+      # intances to be used as a Specify::Service::ViewLoader#target.
+      def view_set(_collection = nil)
+        view_set_dir&.view_set_object
+      end
+    end
+  end
+end

data/lib/specify/models/collection_object.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Specify
+  module Model
+    # CollectionObjects represent the organisms or artifeacts collected, but
+    # not the physical items stored in a collection (see
+    # Specify::Model::Preparation).
+    #
+    # A CollectionObject belongs to Specify::Model::Collection and can have one
+    # or many #preparations (instances of Specify::Model::Preparation).
+    #
+    # A CollectionObject belongs to a #collecting_event (an instance of
+    # Specify::Model::CollectingEvent), that holds information about when,
+    # where, how, and by whom it was collected.
+    #
+    # A CollectionObject can have one or many #determinations (instances of
+    # Specify::Model::Determination), which represent opinions on what
+    # Specify::Model::Taxon the CollectionObject represents.
+    class CollectionObject < Sequel::Model(:collectionobject)
+      include Createable
+      include Updateable
+
+      many_to_one :collection,
+                  key: :CollectionID
+      many_to_one :collection_member,
+                  class: 'Specify::Model::Collection',
+                  key: :CollectionMemberID
+      many_to_one :accession,
+                  key: :AccessionID
+      many_to_one :cataloger,
+                  class: 'Specify::Model::Agent',
+                  key: :CatalogerID
+      many_to_one :collecting_event,
+                  key: :CollectingEventID
+      one_to_many :determinations,
+                  key: :CollectionObjectID
+      one_to_many :preparations,
+                  key: :CollectionObjectID
+      many_to_one :created_by,
+                  class: 'Specify::Model::Agent',
+                  key: :CreatedByAgentID
+      many_to_one :modified_by,
+                  class: 'Specify::Model::Agent',
+                  key: :ModifiedByAgentID
+
+      # Returns the #catalog_number of +self+ if it has one. If not, returns
+      # the next available catalog number in the
+      # Specify::Model::AutoNumberingScheme in the Specify::Model::Collection
+      # +self+ belongs to.
+      def auto_number
+        catalog_number || collection.auto_numbering_scheme.increment
+      end
+
+      # Sequel hook that assigns a newly created records to a
+      # Specify::Model::Collection (the collection is referenced twice; through
+      # #collection and #collection_member; the #collection will be
+      # automatically set if the records is created through the
+      # Specify::Model::Collecion#add_collection_object association method; the
+      # hook will set the other reference).
+      #
+      # Assigns the next available #catalog_number in the collection.
+      #
+      # Sets the _CatalogedDate_ attribute and assigns a Specify::Model::Agent
+      # as the #cataloger.
+      #
+      # Assigns a GUID.
+      #
+      # If CollectionObjects in #collection can not share colecting events
+      # (there is one Specify::Model::CollectingEvent for every
+      # CollectionObject), this will create a new, empty,
+      # Specify::Model::CollectingEvent for the record.
+      def before_create
+        self.collection_member = collection
+        self[:CatalogNumber] = auto_number
+        self[:CatalogedDate] = Date.today
+        self[:CatalogedDatePrecision] = 1
+        self[:GUID] = SecureRandom.uuid
+        self.collecting_event = embed_collecting_event
+        super
+      end
+
+      # Returns a String that is the catalog number of +self+.
+      def catalog_number
+        self[:CatalogNumber]
+      end
+
+      # Returns a Date that is the date +self+ was cataloged (typically when
+      # it was registered in the database).
+      def cataloged_date
+        self[:CatalogedDate]
+      end
+
+      # If CollectionObjects in #collection can not share colecting events
+      # (there is one Specify::Model::CollectingEvent for every
+      # CollectionObject), this will create a new, empty,
+      # Specify::Model::CollectingEvent for the record.
+      def embed_collecting_event
+        return unless collection.embedded_collecting_event?
+        CollectingEvent.create discipline: collection.discipline
+      end
+
+      # Updates the associated Specify::Model::CollectingEvent with +vals+
+      # (a Hash).
+      def geo_locate(vals)
+        collecting_event.update(vals)
+        collecting_event.save
+      end
+
+      # Creates a new Specify::Model::Determination for +self+ with +vals+
+      # (a Hash).
+      def identify(vals)
+        add_determination vals
+        self.save
+      end
+
+      # Creates a string representation of +self+.
+      def inspect
+        to_s
+      end
+
+      # Creates a string representation of +self+.
+      def to_s
+        "#{catalog_number} cataloged by #{cataloger}, #{cataloged_date}"
+      end
+    end
+  end
+end

data/lib/specify/models/createable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Specify
+  module Model
+    # Creatable is a mixin that provides the standard #before_create hook for
+    # Specify::Model classes.
+    #
+    # Most tables in the _Specify_ schema have a _Version_ (an Integer) that is
+    # incremented for each modification and a creation timestamp. The
+    # #before_create hook will set these.
+    module Createable
+      # Initialized the _Version_ to +0+ and sets the creation timestamp of a
+      # record.
+      def before_create
+        self[:Version] = 0
+        self[:TimestampCreated] = Time.now
+        super
+      end
+    end
+  end
+end

data/lib/specify/models/determination.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Specify
+  module Model
+    # Determinations are opinions on what Specify::Model::Taxon a
+    # Specify::Model::CollectionObject represents.
+    #
+    # A Determination belongs to a Specify::Model::CollectionObject
+    # (collection_object).
+    #
+    # A Specify::Model::CollectionObject can have multiple determinations, only
+    # one of which can be the _current_ determination.
+    #
+    # A Determination can belong to a Specify::Model::Taxon. If that taxon
+    # is a synonym of another taxon, the Determination will also belong to
+    # the accepted Taxon as the preferred_taxon.
+    class Determination < Sequel::Model(:determination)
+      include Createable
+      include Updateable
+
+      many_to_one :collection,
+                  key: :CollectionMemberID
+      many_to_one :collection_object,
+                  key: :CollectionObjectID
+      many_to_one :taxon,
+                  key: :TaxonID
+      many_to_one :preferred_taxon,
+                  class: 'Specify::Model::Taxon',
+                  key: :PreferredTaxonID
+      many_to_one :determiner,
+                  class: 'Specify::Model::Agent',
+                  key: :DeterminerID
+      many_to_one :created_by,
+                  class: 'Specify::Model::Agent',
+                  key: :CreatedByAgentID
+      many_to_one :modified_by,
+                  class: 'Specify::Model::Agent',
+                  key: :ModifiedByAgentID
+
+      # Sequel hook that assigns a GUID. Sets the collection to the
+      # Specify::Model::Collection that the collection_object of +self+
+      # belongs to.
+      #
+      # Sets the preferred_taxon to the Specify::Model::Taxon#accepted_name if
+      # it has one, the Specify::Model::Taxon itself otherwise.
+      #
+      # Sets the _IsCurrent_ status to +true+.
+      def before_create
+        self[:GUID] = SecureRandom.uuid
+        self.collection = collection_object&.collection
+        self.preferred_taxon = taxon.accepted_name || taxon
+        self[:IsCurrent] = true
+        super
+      end
+
+      # Returns +true+ if +self+ is the current determination for
+      # #collection_object
+      def current?
+        self[:IsCurrent]
+      end
+    end
+  end
+end

data/lib/specify/models/discipline.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Specify
+  module Model
+    # Disciplines are the second lowest level of scope in a Specify::Database.
+    #
+    # A Discipline belongs to the a Specify::Model::Division.
+    #
+    # A Discipline has one or more instances of Specify::Model::Collection.
+    #
+    # A Discipline has one Specify::Model::Taxonomy, and one
+    # Specify::Model::Geography (both of which can be shared with other
+    # instances of Discipline).
+    class Discipline < Sequel::Model(:discipline)
+      include Updateable
+      many_to_one :division,
+                  key: :DivisionID
+      one_to_many :app_resource_dirs,
+                  class: 'Specify::Model::AppResourceDir',
+                  key: :DisciplineID
+      one_to_many :collecting_events,
+                  key: :DisciplineID
+      one_to_many :collections,
+                  key: :DisciplineID
+      one_to_many :localities,
+                  key: :DisciplineID
+      many_to_many :auto_numbering_schemes,
+                   left_key: :DisciplineID,
+                   right_key: :AutoNumberingSchemeID,
+                   join_table: :autonumsch_dsp
+      many_to_one :taxonomy,
+                  key: :TaxonTreeDefID
+      many_to_one :geography,
+                  key: :GeographyTreeDefID
+      one_to_one :view_set_dir,
+                 class: 'Specify::Model::AppResourceDir',
+                 key: :DisciplineID do |ds|
+                   ds.where(CollectionID: nil,
+                            UserType: nil,
+                            IsPersonal: false)
+                 end
+
+      # Creates a string representation of +self+.
+      def inspect
+        "#{self} name: #{self.Name}"
+      end
+
+      # Returns a String that is the name of +self+.
+      def name
+        self.Name
+      end
+
+      # Returns the Specify::Model::ViewSetObject that belongs to +self+.
+      # The +_collection+ argument will be discared and is only there to allow
+      # intances to be used as a Specify::Service::ViewLoader#target.
+      def view_set(_collection = nil)
+        view_set_dir&.view_set_object
+      end
+    end
+  end
+end