govuk_content_models 6.0.2

data/app/models/workflow.rb

@@ -0,0 +1,217 @@
+require "differ"
+require "state_machine"
+require "action"
+
+module Workflow
+  class CannotDeletePublishedPublication < RuntimeError; end
+  extend ActiveSupport::Concern
+
+  included do
+    validate :not_editing_published_item
+    before_destroy :check_can_delete_and_notify
+
+    before_save :denormalise_users
+    after_create :notify_siblings_of_new_edition
+
+    field :state, type: String, default: "lined_up"
+    belongs_to :assigned_to, class_name: "User"
+    embeds_many :actions
+
+    state_machine initial: :lined_up do
+      after_transition on: :request_amendments do |edition, transition|
+        edition.mark_as_rejected
+      end
+
+      after_transition on: :publish do |edition, transition|
+        edition.was_published
+      end
+
+      event :start_work do
+        transition lined_up: :draft
+      end
+
+      event :request_review do
+        transition [:draft, :amends_needed] => :in_review
+      end
+
+      event :approve_review do
+        transition in_review: :ready
+      end
+
+      event :approve_fact_check do
+        transition fact_check_received: :ready
+      end
+
+      event :request_amendments do
+        transition [:fact_check_received, :in_review] => :amends_needed
+      end
+
+      # Editions can optionally be sent out for fact check
+      event :send_fact_check do
+        transition ready: :fact_check
+      end
+
+      # If no response is received to a fact check request we can skip
+      # that fact check and return the edition to the 'ready' state
+      event :skip_fact_check do
+        transition fact_check: :ready
+      end
+
+      # Where a fact check response has been received the item is moved
+      # into a special state so that the fact check responses can be
+      # reviewed
+      event :receive_fact_check do
+        transition fact_check: :fact_check_received
+      end
+
+      event :publish do
+        transition ready: :published
+      end
+
+      event :emergency_publish do
+        transition draft: :published
+      end
+
+      event :archive do
+        transition all => :archived, :unless => :archived?
+      end
+    end
+
+    # alias_method :created_by, :creator
+    # alias_method :published_by, :publisher
+    # alias_method :archived_by, :archiver
+  end
+
+  def fact_checked?
+    (self.actions.where(request_type: Action::APPROVE_FACT_CHECK).count > 0)
+  end
+
+  def capitalized_state_name
+    self.human_state_name.capitalize
+  end
+
+  def update_user_action(property, statuses)
+    actions.where(:request_type.in => statuses).limit(1).each do |action|
+      # This can be invoked by Panopticon when it updates an artefact and associated
+      # editions. The problem is that Panopticon and Publisher users live in different
+      # collections, but share a model and relationships with eg actions.
+      # Therefore, Panopticon might not find a user for an action.
+      if action.requester
+        self[property] = action.requester.name
+      end
+    end
+  end
+
+  def denormalise_users
+    self.assignee = assigned_to.name if assigned_to
+    update_user_action("creator",   [Action::CREATE, Action::NEW_VERSION])
+    update_user_action("publisher", [Action::PUBLISH])
+    update_user_action("archiver",  [Action::ARCHIVE])
+    self
+  end
+
+  def created_by
+    creation = actions.detect do |a|
+      a.request_type == Action::CREATE || a.request_type == Action::NEW_VERSION
+    end
+    creation.requester if creation
+  end
+
+  def published_by
+    publication = actions.where(request_type: Action::PUBLISH).first
+    publication.requester if publication
+  end
+
+  def archived_by
+    publication = actions.where(request_type: Action::ARCHIVE).first
+    publication.requester if publication
+  end
+
+  def latest_status_action(type = nil)
+    if type
+      self.actions.where(request_type: type).last
+    else
+      most_recent_action(&:status_action?)
+    end
+  end
+
+  def last_fact_checked_at
+    last_fact_check = actions.reverse.find(&:is_fact_check_request?)
+    last_fact_check ? last_fact_check.created_at : NullTimestamp.new
+  end
+
+  def new_action(user, type, options={})
+    actions.create!(options.merge(requester_id: user.id, request_type: type))
+  end
+
+  def new_action_without_validation(user, type, options={})
+    action = actions.build(options.merge(requester_id: user.id, request_type: type))
+    save(validate: false)
+    action
+  end
+
+  def most_recent_action(&blk)
+    self.actions.sort_by(&:created_at).reverse.find(&blk)
+  end
+
+  def not_editing_published_item
+    if changed? and ! state_changed?
+      if archived?
+        errors.add(:base, "Archived editions can't be edited")
+      end
+      if published?
+        changes_allowed_when_published = ["slug", "section",
+                                          "department", "business_proposition"]
+        illegal_changes = changes.keys - changes_allowed_when_published
+        if illegal_changes.empty?
+          # Allow it
+        else
+          errors.add(:base, "Published editions can't be edited")
+        end
+      end
+    end
+  end
+
+  def can_destroy?
+    ! published? and ! archived?
+  end
+
+  def check_can_delete_and_notify
+    raise CannotDeletePublishedPublication unless can_destroy?
+  end
+
+  def mark_as_rejected
+    self.inc(:rejected_count, 1)
+  end
+
+  def previous_edition
+    self.previous_published_edition || false
+  end
+
+  def edition_changes
+    if self.whole_body.empty?
+      false
+    else
+      my_body, their_body = [self, self.published_edition].map do |edition|
+        edition.whole_body.gsub("\r\n", "\n")
+      end
+      Differ.diff_by_line(my_body, their_body)
+    end
+  end
+
+  def notify_siblings_of_new_edition
+    siblings.update_all(sibling_in_progress: self.version_number)
+  end
+
+  def notify_siblings_of_published_edition
+    siblings.update_all(sibling_in_progress: nil)
+  end
+
+  def update_sibling_in_progress(version_number_or_nil)
+    update_attribute(:sibling_in_progress, version_number_or_nil)
+  end
+
+  def in_progress?
+    ! ["archived", "published"].include? self.state
+  end
+end

data/app/models/workflow_actor.rb

@@ -0,0 +1,141 @@
+require "answer_edition"
+require "guide_edition"
+require "local_transaction_edition"
+require "place_edition"
+require "programme_edition"
+require "transaction_edition"
+
+module WorkflowActor
+  SIMPLE_WORKFLOW_ACTIONS = %W[start_work request_review
+    request_amendments approve_review approve_fact_check archive]
+
+  def record_action(edition, type, options={})
+    type = Action.const_get(type.to_s.upcase)
+    action = edition.new_action(self, type, options)
+    edition.save! # force callbacks for denormalisation
+    action
+  end
+
+  def record_action_without_validation(edition, type, options={})
+    type = Action.const_get(type.to_s.upcase)
+    action = edition.new_action_without_validation(self, type, options)
+    edition.save! # force callbacks for denormalisation
+    action
+  end
+
+  def can_take_action(action, edition)
+    respond_to?(:"can_#{action}?") ? __send__(:"can_#{action}?", edition) : true
+  end
+
+  def take_action(edition, action, details = {})
+    if can_take_action(action, edition) and edition.send(action)
+      record_action(edition, action, details)
+      edition
+    else
+      false
+    end
+  end
+
+  def take_action!(edition, action, details = {})
+    edition = take_action(edition, action, details)
+    edition.save if edition
+  end
+
+  def progress(edition, activity_details)
+    activity = activity_details.delete(:request_type)
+
+    edition = send(activity, edition, activity_details)
+    edition.save if edition
+  end
+
+  def record_note(edition, comment)
+    edition.new_action(self, "note", comment: comment)
+  end
+
+  def create_edition(format, attributes = {})
+    format = "#{format}_edition" unless format.to_s.match(/edition$/)
+    publication_class = format.to_s.camelize.constantize
+
+    item = publication_class.create(attributes)
+    record_action(item, Action::CREATE) if item.persisted?
+    item
+  end
+
+  def new_version(edition, convert_to = nil)
+    return false unless edition.published?
+
+    if not convert_to.nil?
+      convert_to = convert_to.to_s.camelize.constantize
+      new_edition = edition.build_clone(convert_to)
+    else
+      new_edition = edition.build_clone
+    end
+
+    if new_edition
+      record_action new_edition, Action::NEW_VERSION
+      new_edition
+    else
+      false
+    end
+  end
+
+  def send_fact_check(edition, details)
+    return false if details[:email_addresses].blank?
+
+    details[:comment] ||= "Fact check requested"
+    details[:comment] += "\n\nResponses should be sent to: " +
+                         edition.fact_check_email_address
+
+    take_action(edition, __method__, details)
+  end
+
+  # Advances state if possible (i.e. if in "fact_check" state)
+  # Always records the action.
+  def receive_fact_check(edition, details)
+    edition.receive_fact_check
+    # Fact checks are processed async, so the user doesn't get an opportunity
+    # to retry without the content that (inadvertantly) fails validation, which happens frequently.
+    record_action_without_validation(edition, :receive_fact_check, details)
+  end
+
+  def skip_fact_check(edition, details)
+    edition.skip_fact_check
+    record_action(edition, :skip_fact_check, details)
+  end
+
+  SIMPLE_WORKFLOW_ACTIONS.each do |method|
+    define_method(method) do |edition, details = {}|
+      take_action(edition, __method__, details)
+    end
+  end
+
+  def publish(edition, details)
+    if edition.published_edition
+      details.merge!({ diff: edition.edition_changes })
+    end
+
+    take_action(edition, __method__, details)
+  end
+
+  def can_approve_review?(edition)
+    # To accommodate latest_status_action being nil, we'll always return true in
+    # those cases
+    # This is intended as a v.temporary fix until we can remedy the root cause
+    if edition.latest_status_action
+      edition.latest_status_action.requester_id != self.id
+    else
+      true
+    end
+  end
+  alias :can_request_amendments? :can_approve_review?
+
+  def assign(edition, recipient)
+    edition.assigned_to_id = recipient.id
+
+    # We're saving the edition here as the controller treats assignment as a
+    # special case.
+    # The controller saves the publication, then updates assignment.
+    edition.save! and edition.reload
+    record_action edition, __method__, recipient: recipient
+  end
+end

data/app/traits/attachable.rb

@@ -0,0 +1,60 @@
+module Attachable
+  class ApiClientNotPresent < StandardError; end
+
+  @asset_api_client = nil
+
+  def self.asset_api_client
+    @asset_api_client
+  end
+
+  def self.asset_api_client=(api_client)
+    @asset_api_client = api_client
+  end
+
+  module ClassMethods
+    def attaches(*fields)
+      fields.map(&:to_s).each do |field|
+        before_save "upload_#{field}".to_sym, :if => "#{field}_has_changed?".to_sym
+        self.field "#{field}_id".to_sym, type: String
+
+        define_method(field) do
+          raise ApiClientNotPresent unless Attachable.asset_api_client
+          unless self.send("#{field}_id").nil?
+            @attachments ||= { }
+            @attachments[field] ||= Attachable.asset_api_client.asset(self.send("#{field}_id"))
+          end
+        end
+
+        define_method("#{field}=") do |file|
+          instance_variable_set("@#{field}_has_changed", true)
+          instance_variable_set("@#{field}_file", file)
+        end
+
+        define_method("#{field}_has_changed?") do
+          instance_variable_get("@#{field}_has_changed")
+        end
+
+        define_method("remove_#{field}=") do |value|
+          unless value.nil? or value == false or (value.respond_to?(:empty?) and value.empty?)
+            self.send("#{field}_id=", nil)
+          end
+        end
+
+        define_method("upload_#{field}") do
+          raise ApiClientNotPresent unless Attachable.asset_api_client
+          begin
+            response = Attachable.asset_api_client.create_asset(:file => instance_variable_get("@#{field}_file"))
+            self.send("#{field}_id=", response.id.match(/\/([^\/]+)\z/) {|m| m[1] })
+          rescue StandardError
+            errors.add("#{field}_id".to_sym, "could not be uploaded")
+          end
+        end
+        private "upload_#{field}".to_sym
+      end
+    end
+  end
+
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+end

data/app/traits/govspeak_smart_quotes_fixer.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+module GovspeakSmartQuotesFixer
+  def self.included(model)
+    model.class_eval do
+      before_validation :fix_smart_quotes_in_govspeak
+    end
+  end
+
+  private
+
+  def fix_smart_quotes_in_govspeak
+    self.class::GOVSPEAK_FIELDS.each do |field|
+      if self.send(field) =~ /[“”]/
+        self.send(field).gsub!(/[“”]/, '"')
+      end
+    end
+  end
+end

data/app/traits/taggable.rb

@@ -0,0 +1,113 @@
+module Taggable
+  module ClassMethods
+    def stores_tags_for(*keys)
+      tag_types = keys.to_a.flatten.compact.map(&:to_s)
+      class_attribute :tag_types
+      self.tag_types = tag_types
+
+      tag_types.each do |k|
+        define_method "#{k}=" do |values|
+          set_tags_of_type(k, values)
+        end
+        alias_method :"#{k.singularize}_ids=", :"#{k}="
+
+        define_method k do
+          tags_of_type(k.singularize)
+        end
+        define_method "#{k.singularize}_ids" do
+          tags_of_type(k.singularize).collect(&:tag_id)
+        end
+      end
+    end
+
+    def has_primary_tag_for(*keys)
+      tag_types = keys.to_a.flatten.compact.map(&:to_s)
+      class_attribute :primary_tag_types
+      self.primary_tag_types = tag_types
+
+      tag_types.each do |key|
+        method_name = "primary_#{key}"
+
+        define_method "#{method_name}=" do |value|
+          set_primary_tag_of_type(key.to_s, value)
+        end
+
+        define_method method_name do
+          tags_of_type(key.to_s).first
+        end
+      end
+    end
+  end
+
+  def self.included(klass)
+    klass.extend         ClassMethods
+    klass.field          :tag_ids, type: Array, default: []
+    klass.index          :tag_ids
+    klass.attr_protected :tags, :tag_ids
+    klass.__send__       :private, :tag_ids=
+  end
+
+  def set_tags_of_type(collection_name, values)
+    tag_type = collection_name.singularize
+
+    # Ensure all tags loaded from database. This feels inelegant
+    # but ensures integrity. It could go away if we moved to a more
+    # consistent repository approach to retrieving and constructing
+    # objects, or if we used a custom serialization type for tags
+    # as documented on http://mongoid.org/en/mongoid/docs/documents.html
+    tags
+
+    # This will raise a Tag::MissingTags exception unless all the tags exist
+    new_tags = Tag.by_tag_ids!(values, tag_type)
+
+    @tags.reject! { |t| t.tag_type == tag_type }
+    @tags += new_tags
+  end
+
+  # The primary tag is simply the first one of its
+  # type. If that tag is already applied this method
+  # moves it to the start of the list. If it's not then
+  # we add it at the start of the list.
+  def set_primary_tag_of_type(tag_type, value)
+    tags
+
+    tag = Tag.by_tag_id(value, tag_type)
+    raise "Missing tag" unless tag
+    raise "Wrong tag type" unless tag.tag_type == tag_type
+
+    @tags -= [tag]
+    @tags.unshift(tag)
+  end
+
+  def tags_of_type(tag_type)
+    tags.select { |t| t.tag_type == tag_type }
+  end
+
+  def reconcile_tag_ids
+    # Ensure tags are loaded so we don't accidentally
+    # remove all tagging in situations where tags haven't
+    # been accessed during the lifetime of the object
+    tags
+
+    self.tag_ids = @tags.collect(&:tag_id)
+  end
+
+  def tags
+    @tags ||= Tag.by_tag_ids(tag_ids).compact.to_a
+  end
+
+  def reload
+    @tags = nil
+    super
+  end
+
+  def save(options={})
+    reconcile_tag_ids
+    super(options)
+  end
+
+  def save!(options={})
+    reconcile_tag_ids
+    super(options)
+  end
+end