hydra-head 4.0.0.rc2 → 4.0.0.rc3

data/app/models/hydra/datastream/mods_image.rb

@@ -0,0 +1,496 @@
+module Hydra
+  module Datastream
+    class ModsImage < ActiveFedora::NokogiriDatastream       
+      include Hydra::Datastream::CommonModsIndexMethods
+
+      set_terminology do |t|
+        t.root(:path=>"mods", :xmlns=>"http://www.loc.gov/mods/v3", :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd")
+
+        t.title_info(:path=>"titleInfo") {
+          t.main_title(:path=>"title", :label=>"title")
+          t.language(:index_as=>[:facetable],:path=>{:attribute=>"lang"})
+        } 
+        
+        t.language{
+          t.lang_code(:index_as=>[:facetable], :path=>"languageTerm", :attributes=>{:type=>"code"})
+        }
+        t.abstract   
+        t.subject {
+          t.topic
+        }      
+        t.topic_tag(:index_as=>[:facetable],:path=>"subject", :default_content_path=>"topic")
+
+      # mods:physicaldescription/mods:extent - used for storing file size in human-readable form.
+      t.physical_description(:path => "physicalDescription") {
+        t.extent( :path => "extent" )
+      }
+        
+      # This is a mods:name.  The underscore is purely to avoid namespace conflicts.
+        t.name_ {
+          # this is a namepart
+          t.namePart(:type=>:string, :label=>"generic name")
+          # affiliations are great
+          t.affiliation
+          t.institution(:path=>"affiliation", :index_as=>[:facetable], :label=>"organization")
+          t.displayForm
+          t.role(:ref=>[:role])
+          t.description
+          t.date(:path=>"namePart", :attributes=>{:type=>"date"})
+          t.last_name(:path=>"namePart", :attributes=>{:type=>"family"})
+          t.first_name(:path=>"namePart", :attributes=>{:type=>"given"}, :label=>"first name")
+          t.terms_of_address(:path=>"namePart", :attributes=>{:type=>"termsOfAddress"})
+        }
+        # lookup :person, :first_name        
+        t.person(:ref=>:name, :attributes=>{:type=>"personal"}, :index_as=>[:facetable])
+        t.organization(:ref=>:name, :attributes=>{:type=>"corporate"}, :index_as=>[:facetable])
+        t.conference(:ref=>:name, :attributes=>{:type=>"conference"}, :index_as=>[:facetable])
+        t.role {
+          t.text(:path=>"roleTerm",:attributes=>{:type=>"text"})
+          t.code(:path=>"roleTerm",:attributes=>{:type=>"code"})
+        }
+        t.journal(:path=>'relatedItem', :attributes=>{:type=>"host"}) {
+          t.title_info(:index_as=>[:facetable],:ref=>[:title_info])
+          t.origin_info(:path=>"originInfo") {
+            t.publisher
+            t.date_issued(:path=>"dateIssued")
+          }
+          t.issn(:path=>"identifier", :attributes=>{:type=>"issn"})
+          t.issue(:path=>"part") {
+            t.volume(:path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
+            t.level(:path=>"detail", :attributes=>{:type=>"number"}, :default_content_path=>"number")
+            t.extent
+            t.pages(:path=>"extent", :attributes=>{:unit=>"pages"}) {
+              t.start
+              t.end
+            }
+            t.start_page(:proxy=>[:pages, :start])
+            t.end_page(:proxy=>[:pages, :end])
+            t.publication_date(:path=>"date")
+          }
+        }
+      end
+      
+        # accessor :title, :term=>[:mods, :title_info, :main_title]
+        
+        # Generates an empty Mods Image (used when you call ModsImage.new without passing in existing xml)
+        def self.xml_template
+          builder = Nokogiri::XML::Builder.new do |xml|
+            xml.mods(:version=>"3.3", "xmlns:xlink"=>"http://www.w3.org/1999/xlink",
+               "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
+               "xmlns"=>"http://www.loc.gov/mods/v3",
+               "xsi:schemaLocation"=>"http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-3.xsd") {
+                 xml.titleInfo(:lang=>"") {
+                   xml.title
+                 }
+                 xml.name(:type=>"personal") {
+                   xml.namePart(:type=>"given")
+                   xml.namePart(:type=>"family")
+                   xml.affiliation
+                   xml.role {
+                     xml.roleTerm(:authority=>"marcrelator", :type=>"text")
+                   }
+                 }
+                 xml.typeOfResource
+                 xml.genre(:authority=>"marcgt")
+                 xml.language {
+                   xml.languageTerm(:authority=>"iso639-2b", :type=>"code")
+                 }
+          # mods:physicaldescription/mods:extent - used for storing file size in human-readable form.
+          xml.physicalDescription {
+             xml.extent
+          }
+                 xml.abstract
+                 xml.subject {
+                   xml.topic
+                 }
+                 xml.relatedItem(:type=>"host") {
+                   xml.titleInfo {
+                     xml.title
+                   }
+                   xml.identifier(:type=>"issn")
+                   xml.originInfo {
+                     xml.publisher
+                     xml.dateIssued
+                   }
+                   xml.part {
+                     xml.detail(:type=>"volume") {
+                       xml.number
+                     }
+                     xml.detail(:type=>"number") {
+                       xml.number
+                     }
+                     xml.extent(:unit=>"pages") {
+                       xml.start
+                       xml.end
+                     }
+                     xml.date
+                   }
+                 }
+                 xml.location {
+                   xml.url
+                 }
+            }
+          end
+          return builder.doc
+        end    
+        
+        # Generates a new Person node
+        def self.person_template
+          builder = Nokogiri::XML::Builder.new do |xml|
+            xml.name(:type=>"personal") {
+              xml.namePart(:type=>"family")
+              xml.namePart(:type=>"given")
+              xml.affiliation
+              xml.role {
+                xml.roleTerm(:type=>"text")
+              }
+            }
+          end
+          return builder.doc.root
+        end
+       
+        def self.full_name_template
+          builder = Nokogiri::XML::Builder.new do |xml|
+            xml.full_name(:type => "personal")
+          end
+          return builder.doc.root
+        end
+
+        # Generates a new Organization node
+        # Uses mods:name[@type="corporate"]
+        def self.organization_template
+          builder = Nokogiri::XML::Builder.new do |xml|
+            xml.name(:type=>"corporate") {
+              xml.namePart
+              xml.role {
+                xml.roleTerm(:authority=>"marcrelator", :type=>"text")
+              }                          
+            }
+          end
+          return builder.doc.root
+        end
+        
+        # Generates a new Conference node
+        def self.conference_template
+          builder = Nokogiri::XML::Builder.new do |xml|
+            xml.name(:type=>"conference") {
+              xml.namePart
+              xml.role {
+                xml.roleTerm(:authority=>"marcrelator", :type=>"text")
+              }                          
+            }
+          end
+          return builder.doc.root
+        end
+        
+        # Inserts a new contributor (mods:name) into the mods document
+        # creates contributors of type :person, :organization, or :conference
+        def insert_contributor(type, opts={})
+          case type.to_sym 
+          when :person
+            node = Hydra::Datastream::ModsImage.person_template
+            nodeset = self.find_by_terms(:person)
+          when :organization
+            node = Hydra::Datastream::ModsImage.organization_template
+            nodeset = self.find_by_terms(:organization)
+          when :conference
+            node = Hydra::Datastream::ModsImage.conference_template
+            nodeset = self.find_by_terms(:conference)
+          else
+            ActiveFedora.logger.warn("#{type} is not a valid argument for Hydra::Datastream::ModsImage.insert_contributor")
+            node = nil
+            index = nil
+          end
+          
+          unless nodeset.nil?
+            if nodeset.empty?
+              self.ng_xml.root.add_child(node)
+              index = 0
+            else
+              nodeset.after(node)
+              index = nodeset.length
+            end
+            self.dirty = true
+          end
+          
+          return node, index
+        end
+        
+        # Remove the contributor entry identified by @contributor_type and @index
+        def remove_contributor(contributor_type, index)
+          self.find_by_terms( {contributor_type.to_sym => index.to_i} ).first.remove
+          self.dirty = true
+        end
+        
+        def self.common_relator_terms
+           {"aut" => "Author",
+            "clb" => "Collaborator",
+            "com" => "Compiler",
+            "ctb" => "Contributor",
+            "cre" => "Creator",
+            "edt" => "Editor",
+            "ill" => "Illustrator",
+            "oth" => "Other",
+            "trl" => "Translator",
+            }
+        end
+        
+        def self.person_relator_terms
+          {"aut" => "Author",
+           "clb" => "Collaborator",
+           "com" => "Compiler",
+           "cre" => "Creator",
+           "ctb" => "Contributor",
+           "edt" => "Editor",
+           "ill" => "Illustrator",
+           "res" => "Researcher",
+           "rth" => "Research team head",
+           "rtm" => "Research team member",
+           "trl" => "Translator"
+           }
+        end
+        
+        def self.conference_relator_terms
+          {
+            "hst" => "Host"
+          }
+        end
+        
+        def self.organization_relator_terms
+          {
+            "fnd" => "Funder",
+            "hst" => "Host"
+          }
+        end
+        
+        def self.dc_relator_terms
+           {"acp" => "Art copyist",
+            "act" => "Actor",
+            "adp" => "Adapter",
+            "aft" => "Author of afterword, colophon, etc.",
+            "anl" => "Analyst",
+            "anm" => "Animator",
+            "ann" => "Annotator",
+            "ant" => "Bibliographic antecedent",
+            "app" => "Applicant",
+            "aqt" => "Author in quotations or text abstracts",
+            "arc" => "Architect",
+            "ard" => "Artistic director ",
+            "arr" => "Arranger",
+            "art" => "Artist",
+            "asg" => "Assignee",
+            "asn" => "Associated name",
+            "att" => "Attributed name",
+            "auc" => "Auctioneer",
+            "aud" => "Author of dialog",
+            "aui" => "Author of introduction",
+            "aus" => "Author of screenplay",
+            "aut" => "Author",
+            "bdd" => "Binding designer",
+            "bjd" => "Bookjacket designer",
+            "bkd" => "Book designer",
+            "bkp" => "Book producer",
+            "bnd" => "Binder",
+            "bpd" => "Bookplate designer",
+            "bsl" => "Bookseller",
+            "ccp" => "Conceptor",
+            "chr" => "Choreographer",
+            "clb" => "Collaborator",
+            "cli" => "Client",
+            "cll" => "Calligrapher",
+            "clt" => "Collotyper",
+            "cmm" => "Commentator",
+            "cmp" => "Composer",
+            "cmt" => "Compositor",
+            "cng" => "Cinematographer",
+            "cnd" => "Conductor",
+            "cns" => "Censor",
+            "coe" => "Contestant -appellee",
+            "col" => "Collector",
+            "com" => "Compiler",
+            "cos" => "Contestant",
+            "cot" => "Contestant -appellant",
+            "cov" => "Cover designer",
+            "cpc" => "Copyright claimant",
+            "cpe" => "Complainant-appellee",
+            "cph" => "Copyright holder",
+            "cpl" => "Complainant",
+            "cpt" => "Complainant-appellant",
+            "cre" => "Creator",
+            "crp" => "Correspondent",
+            "crr" => "Corrector",
+            "csl" => "Consultant",
+            "csp" => "Consultant to a project",
+            "cst" => "Costume designer",
+            "ctb" => "Contributor",
+            "cte" => "Contestee-appellee",
+            "ctg" => "Cartographer",
+            "ctr" => "Contractor",
+            "cts" => "Contestee",
+            "ctt" => "Contestee-appellant",
+            "cur" => "Curator",
+            "cwt" => "Commentator for written text",
+            "dfd" => "Defendant",
+            "dfe" => "Defendant-appellee",
+            "dft" => "Defendant-appellant",
+            "dgg" => "Degree grantor",
+            "dis" => "Dissertant",
+            "dln" => "Delineator",
+            "dnc" => "Dancer",
+            "dnr" => "Donor",
+            "dpc" => "Depicted",
+            "dpt" => "Depositor",
+            "drm" => "Draftsman",
+            "drt" => "Director",
+            "dsr" => "Designer",
+            "dst" => "Distributor",
+            "dtc" => "Data contributor ",
+            "dte" => "Dedicatee",
+            "dtm" => "Data manager ",
+            "dto" => "Dedicator",
+            "dub" => "Dubious author",
+            "edt" => "Editor",
+            "egr" => "Engraver",
+            "elg" => "Electrician ",
+            "elt" => "Electrotyper",
+            "eng" => "Engineer",
+            "etr" => "Etcher",
+            "exp" => "Expert",
+            "fac" => "Facsimilist",
+            "fld" => "Field director ",
+            "flm" => "Film editor",
+            "fmo" => "Former owner",
+            "fpy" => "First party",
+            "fnd" => "Funder",
+            "frg" => "Forger",
+            "gis" => "Geographic information specialist ",
+            "grt" => "Graphic technician",
+            "hnr" => "Honoree",
+            "hst" => "Host",
+            "ill" => "Illustrator",
+            "ilu" => "Illuminator",
+            "ins" => "Inscriber",
+            "inv" => "Inventor",
+            "itr" => "Instrumentalist",
+            "ive" => "Interviewee",
+            "ivr" => "Interviewer",
+            "lbr" => "Laboratory ",
+            "lbt" => "Librettist",
+            "ldr" => "Laboratory director ",
+            "led" => "Lead",
+            "lee" => "Libelee-appellee",
+            "lel" => "Libelee",
+            "len" => "Lender",
+            "let" => "Libelee-appellant",
+            "lgd" => "Lighting designer",
+            "lie" => "Libelant-appellee",
+            "lil" => "Libelant",
+            "lit" => "Libelant-appellant",
+            "lsa" => "Landscape architect",
+            "lse" => "Licensee",
+            "lso" => "Licensor",
+            "ltg" => "Lithographer",
+            "lyr" => "Lyricist",
+            "mcp" => "Music copyist",
+            "mfr" => "Manufacturer",
+            "mdc" => "Metadata contact",
+            "mod" => "Moderator",
+            "mon" => "Monitor",
+            "mrk" => "Markup editor",
+            "msd" => "Musical director",
+            "mte" => "Metal-engraver",
+            "mus" => "Musician",
+            "nrt" => "Narrator",
+            "opn" => "Opponent",
+            "org" => "Originator",
+            "orm" => "Organizer of meeting",
+            "oth" => "Other",
+            "own" => "Owner",
+            "pat" => "Patron",
+            "pbd" => "Publishing director",
+            "pbl" => "Publisher",
+            "pdr" => "Project director",
+            "pfr" => "Proofreader",
+            "pht" => "Photographer",
+            "plt" => "Platemaker",
+            "pma" => "Permitting agency",
+            "pmn" => "Production manager",
+            "pop" => "Printer of plates",
+            "ppm" => "Papermaker",
+            "ppt" => "Puppeteer",
+            "prc" => "Process contact",
+            "prd" => "Production personnel",
+            "prf" => "Performer",
+            "prg" => "Programmer",
+            "prm" => "Printmaker",
+            "pro" => "Producer",
+            "prt" => "Printer",
+            "pta" => "Patent applicant",
+            "pte" => "Plaintiff -appellee",
+            "ptf" => "Plaintiff",
+            "pth" => "Patent holder",
+            "ptt" => "Plaintiff-appellant",
+            "rbr" => "Rubricator",
+            "rce" => "Recording engineer",
+            "rcp" => "Recipient",
+            "red" => "Redactor",
+            "ren" => "Renderer",
+            "res" => "Researcher",
+            "rev" => "Reviewer",
+            "rps" => "Repository",
+            "rpt" => "Reporter",
+            "rpy" => "Responsible party",
+            "rse" => "Respondent-appellee",
+            "rsg" => "Restager",
+            "rsp" => "Respondent",
+            "rst" => "Respondent-appellant",
+            "rth" => "Research team head",
+            "rtm" => "Research team member",
+            "sad" => "Scientific advisor",
+            "sce" => "Scenarist",
+            "scl" => "Sculptor",
+            "scr" => "Scribe",
+            "sds" => "Sound designer",
+            "sec" => "Secretary",
+            "sgn" => "Signer",
+            "sht" => "Supporting host",
+            "sng" => "Singer",
+            "spk" => "Speaker",
+            "spn" => "Sponsor",
+            "spy" => "Second party",
+            "srv" => "Surveyor",
+            "std" => "Set designer",
+            "stl" => "Storyteller",
+            "stm" => "Stage manager",
+            "stn" => "Standards body",
+            "str" => "Stereotyper",
+            "tcd" => "Technical director",
+            "tch" => "Teacher",
+            "ths" => "Thesis advisor",
+            "trc" => "Transcriber",
+            "trl" => "Translator",
+            "tyd" => "Type designer",
+            "tyg" => "Typographer",
+            "vdg" => "Videographer",
+            "voc" => "Vocalist",
+            "wam" => "Writer of accompanying material",
+            "wdc" => "Woodcutter",
+            "wde" => "Wood -engraver",
+            "wit" => "Witness"}
+          end
+        
+          def self.valid_child_types
+            ["data", "supporting file", "profile", "lorem ipsum", "dolor"]
+          end
+
+          def to_solr(solr_doc=Hash.new)
+            super(solr_doc)
+            solr_doc.merge!(extract_person_full_names)
+            solr_doc.merge!(extract_person_organizations)
+            solr_doc.merge!(:object_type_facet => "Image")
+            solr_doc
+          end
+
+        end
+  end
+end

data/app/models/hydra/datastream/rights_metadata.rb

@@ -0,0 +1,190 @@
+module Hydra
+  module Datastream
+    class RightsMetadata < ActiveFedora::NokogiriDatastream       
+      
+      set_terminology do |t|
+        t.root(:path=>"rightsMetadata", :xmlns=>"http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1", :schema=>"http://github.com/projecthydra/schemas/tree/v1/rightsMetadata.xsd") 
+        t.copyright {
+          t.machine {
+            t.uvalicense
+            t.cclicense   
+            t.license     
+          }
+          t.human_readable(:path=>"human")
+          t.license(:proxy=>[:machine, :license ])            
+          t.cclicense(:proxy=>[:machine, :cclicense ])                  
+        }
+        t.access {
+          t.human_readable(:path=>"human")
+          t.machine {
+            t.group
+            t.person
+          }
+          t.person(:proxy=>[:machine, :person])
+          t.group(:proxy=>[:machine, :group])
+          # accessor :access_person, :term=>[:access, :machine, :person]
+        }
+        t.discover_access(:ref=>[:access], :attributes=>{:type=>"discover"})
+        t.read_access(:ref=>[:access], :attributes=>{:type=>"read"})
+        t.edit_access(:ref=>[:access], :attributes=>{:type=>"edit"})
+        # A bug in OM prevnts us from declaring proxy terms at the root of a Terminology
+        # t.access_person(:proxy=>[:access,:machine,:person])
+        # t.access_group(:proxy=>[:access,:machine,:group])
+        
+        t.embargo {
+          t.human_readable(:path=>"human")
+          t.machine{
+            t.date(:type =>"release")
+          }
+          t.embargo_release_date(:proxy => [:machine, :date])
+        }    
+      end
+
+      # Generates an empty Mods Article (used when you call ModsArticle.new without passing in existing xml)
+      def self.xml_template
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.rightsMetadata(:version=>"0.1", "xmlns"=>"http://hydra-collab.stanford.edu/schemas/rightsMetadata/v1") {
+            xml.copyright {
+              xml.human
+              xml.machine {
+                xml.uvalicense "no"
+              }
+            }
+            xml.access(:type=>"discover") {
+              xml.human
+              xml.machine
+            }
+            xml.access(:type=>"read") {
+              xml.human 
+              xml.machine
+            }
+            xml.access(:type=>"edit") {
+              xml.human
+              xml.machine
+            }
+            xml.embargo{
+              xml.human
+              xml.machine
+            }        
+          }
+        end
+        return builder.doc
+      end
+        
+      # Returns the permissions for the selected person/group
+      # If new_access_level is provided, updates the selected person/group access_level to the one specified 
+      # A new_access_level of "none" will remove all access_levels for the selected person/group
+      # @param [Hash] selector hash in format {type => identifier}
+      # @param new_access_level (default nil)
+      # @return Hash in format {type => access_level}.  
+      # 
+      # ie. 
+      # permissions({:person=>"person123"})
+      # => {"person123"=>"edit"}
+      # permissions({:person=>"person123"}, "read")
+      # => {"person123"=>"read"}
+      # permissions({:person=>"person123"})
+      # => {"person123"=>"read"}
+      def permissions(selector, new_access_level=nil)
+        type = selector.keys.first.to_sym
+        actor = selector.values.first
+        if new_access_level.nil?
+          xpath = self.class.terminology.xpath_for(:access, type, actor)
+          nodeset = self.find_by_terms(xpath)
+          if nodeset.empty?
+            return "none"
+          else
+            return nodeset.first.ancestors("access").first.attributes["type"].text
+          end
+        else
+          remove_all_permissions(selector)
+          unless new_access_level == "none" 
+            access_type_symbol = "#{new_access_level}_access".to_sym
+            result = self.update_values([access_type_symbol, type] => {"-1"=>actor})
+          end
+          self.dirty = true
+          return new_access_level
+        end
+          
+      end
+      
+      # Reports on which groups have which permissions
+      # @return Hash in format {group_name => group_permissions, group_name => group_permissions}
+      def groups
+        return quick_search_by_type(:group)
+      end
+      
+      # Reports on which groups have which permissions
+      # @return Hash in format {person_name => person_permissions, person_name => person_permissions}
+      def individuals
+        return quick_search_by_type(:person)
+      end
+      
+      # Updates permissions for all of the persons and groups in a hash
+      # @param ex. {"group"=>{"group1"=>"discover","group2"=>"edit"}, "person"=>{"person1"=>"read","person2"=>"discover"}}
+      # Currently restricts actor type to group or person.  Any others will be ignored
+      def update_permissions(params)
+        params.fetch("group", {}).each_pair {|group_id, access_level| self.permissions({"group"=>group_id}, access_level)}
+        params.fetch("person", {}).each_pair {|group_id, access_level| self.permissions({"person"=>group_id}, access_level)}
+      end
+      
+      # @param [Symbol] symbol (either :group or :person)
+      # @return 
+      # This method limits the response to known access levels.  Probably runs a bit faster than .permissions().
+      def quick_search_by_type(type)
+        result = {}
+        [{:discover_access=>"discover"},{:read_access=>"read"},{:edit_access=>"edit"}].each do |access_levels_hash|
+          access_level = access_levels_hash.keys.first
+          access_level_name = access_levels_hash.values.first
+          self.find_by_terms(*[access_level, type]).each do |entry|
+            result[entry.text] = access_level_name
+          end
+        end
+        return result
+      end
+
+      attr_reader :embargo_release_date
+      def embargo_release_date=(release_date)
+        release_date = release_date.to_s if release_date.is_a? Date
+        begin
+          Date.parse(release_date)
+        rescue 
+          return "INVALID DATE"
+        end
+        self.update_values({[:embargo,:machine,:date]=>release_date})
+      end
+      def embargo_release_date(opts={})
+        embargo_release_date = self.find_by_terms(*[:embargo,:machine,:date]).first ? self.find_by_terms(*[:embargo,:machine,:date]).first.text : nil
+        if embargo_release_date.present? && opts[:format] && opts[:format] == :solr_date
+          embargo_release_date << "T23:59:59Z"
+        end
+        embargo_release_date
+      end
+      def under_embargo?
+        (embargo_release_date && Date.today < embargo_release_date.to_date) ? true : false
+      end
+
+      def to_solr(solr_doc=Hash.new)
+        super(solr_doc)
+        ::Solrizer::Extractor.insert_solr_field_value(solr_doc, "embargo_release_date_dt", embargo_release_date(:format=>:solr_date)) if embargo_release_date
+        solr_doc
+      end
+
+
+
+
+      
+      private
+      # Purge all access given group/person 
+      def remove_all_permissions(selector)
+        return unless ng_xml
+        type = selector.keys.first.to_sym
+        actor = selector.values.first
+        xpath = self.class.terminology.xpath_for(:access, type, actor)
+        nodes_to_purge = self.find_by_terms(xpath)
+        nodes_to_purge.each {|node| node.remove}
+      end
+      
+    end
+  end
+end