govuk_content_models 6.0.2

data/app/models/artefact_action.rb

@@ -0,0 +1,27 @@
+require "safe_html"
+
+class ArtefactAction
+  include Mongoid::Document
+  include Mongoid::Timestamps::Created
+
+  field "action_type", type: String
+  field "snapshot", type: Hash
+
+  GOVSPEAK_FIELDS = []
+
+  embedded_in :artefact
+
+  validates_with SafeHtml
+
+  # Ideally we would like to use the UID field here, since that will be the
+  # same across all applications, but Mongoid doesn't yet support using a
+  # custom primary key on a related field
+  belongs_to :user
+
+  # Not validating presence of a user just yet, since there may be some
+  # circumstances where we can't reliably determine the user. As an example
+  # of this, requests made through the API are not yet tied to a user. If we
+  # find out that there are no such circumstances in practice, we can add a
+  # validator for :user.
+  validates_presence_of :action_type, :snapshot
+end

data/app/models/artefact_external_link.rb

@@ -0,0 +1,15 @@
+class ArtefactExternalLink
+  include Mongoid::Document
+
+  field "title", type: String
+  field "url", type: String
+
+  GOVSPEAK_FIELDS = []
+
+  embedded_in :artefact
+
+  validates_with SafeHtml
+
+  validates_presence_of :title
+  validates :url, :presence => true, :format => { :with => URI::regexp(%w{http https}) }
+end

data/app/models/business_support/business_size.rb

@@ -0,0 +1,14 @@
+module BusinessSupport
+  class BusinessSize
+    include Mongoid::Document
+
+    field :name, type: String
+    field :slug, type: String
+    index :slug => 1
+
+    validates_presence_of :name
+    validates_uniqueness_of :name
+    validates_presence_of :slug
+    validates_uniqueness_of :slug
+  end
+end

data/app/models/business_support/business_type.rb

@@ -0,0 +1,14 @@
+module BusinessSupport
+  class BusinessType
+    include Mongoid::Document
+
+    field :name, type: String
+    field :slug, type: String
+    index :slug => 1
+
+    validates_presence_of :name
+    validates_uniqueness_of :name
+    validates_presence_of :slug
+    validates_uniqueness_of :slug
+  end
+end

data/app/models/business_support/location.rb

@@ -0,0 +1,14 @@
+module BusinessSupport
+  class Location
+    include Mongoid::Document
+
+    field :name, type: String
+    field :slug, type: String
+    index :slug => 1
+
+    validates_presence_of :name
+    validates_uniqueness_of :name
+    validates_presence_of :slug
+    validates_uniqueness_of :slug
+  end
+end

data/app/models/business_support/purpose.rb

@@ -0,0 +1,14 @@
+module BusinessSupport
+  class Purpose
+    include Mongoid::Document
+
+    field :name, type: String
+    field :slug, type: String
+    index :slug => 1
+
+    validates_presence_of :name
+    validates_uniqueness_of :name
+    validates_presence_of :slug
+    validates_uniqueness_of :slug
+  end
+end

data/app/models/business_support/sector.rb

@@ -0,0 +1,14 @@
+module BusinessSupport
+  class Sector
+    include Mongoid::Document
+
+    field :name, type: String
+    field :slug, type: String
+    index :slug => 1
+
+    validates_presence_of :name
+    validates_uniqueness_of :name
+    validates_presence_of :slug
+    validates_uniqueness_of :slug
+  end
+end

data/app/models/business_support/stage.rb

@@ -0,0 +1,14 @@
+module BusinessSupport
+  class Stage
+    include Mongoid::Document
+
+    field :name, type: String
+    field :slug, type: String
+    index :slug => 1
+
+    validates_presence_of :name
+    validates_uniqueness_of :name
+    validates_presence_of :slug
+    validates_uniqueness_of :slug
+  end
+end

data/app/models/business_support/support_type.rb

@@ -0,0 +1,14 @@
+module BusinessSupport
+  class SupportType
+    include Mongoid::Document
+
+    field :name, type: String
+    field :slug, type: String
+    index :slug => 1
+
+    validates_presence_of :name
+    validates_uniqueness_of :name
+    validates_presence_of :slug
+    validates_uniqueness_of :slug
+  end
+end

data/app/models/business_support_edition.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+require "edition"
+
+class BusinessSupportEdition < Edition
+
+  include Mongoid::MultiParameterAttributes
+
+  field :short_description, type: String
+  field :body, type: String
+  field :min_value, type: Integer
+  field :max_value, type: Integer
+  field :max_employees, type: Integer
+  field :organiser, type: String
+  field :eligibility, type: String
+  field :evaluation, type: String
+  field :additional_information, type: String
+  field :continuation_link, type: String
+  field :will_continue_on, type: String
+  field :contact_details, type: String
+  field :business_support_identifier, type: String
+
+  field :priority,        type: Integer, default: 1
+  field :business_types,  type: Array, default: []
+  field :business_sizes,  type: Array, default: []
+  field :locations,       type: Array, default: []
+  field :purposes,        type: Array, default: []
+  field :sectors,         type: Array, default: []
+  field :stages,          type: Array, default: []
+  field :support_types,   type: Array, default: []
+  field :start_date,      type: Date
+  field :end_date,        type: Date
+
+  index :business_support_identifier
+
+  GOVSPEAK_FIELDS = Edition::GOVSPEAK_FIELDS + [:body, :eligibility, :evaluation, :additional_information]
+
+  validate :min_must_be_less_than_max
+  validates :business_support_identifier, :presence => true
+  validate :business_support_identifier_unique
+  validates_format_of :continuation_link, :with => URI::regexp(%w(http https)), :allow_blank => true
+
+  # https://github.com/mongoid/mongoid/issues/1735 Really Mongoid‽
+  validates :min_value, :max_value, :max_employees, :numericality => {:allow_nil => true, :only_integer => true}
+
+  @fields_to_clone = [:body, :min_value, :max_value, :max_employees, :organiser,
+      :eligibility, :evaluation, :additional_information, :continuation_link,
+      :will_continue_on, :contact_details, :short_description,
+      :business_support_identifier]
+
+  def whole_body
+    [short_description, body].join("\n\n")
+  end
+
+  private
+
+  def min_must_be_less_than_max
+    if !min_value.nil? && !max_value.nil? && min_value > max_value
+      errors[:min_value] << "Min value must be smaller than max value"
+      errors[:max_value] << "Max value must be larger than min value"
+    end
+  end
+
+  def business_support_identifier_unique
+    if self.class.without_state('archived').where(:business_support_identifier => business_support_identifier,
+                        :panopticon_id.ne => panopticon_id).any?
+      errors.add(:business_support_identifier, :taken)
+    end
+  end
+end

data/app/models/campaign_edition.rb

@@ -0,0 +1,72 @@
+require 'attachable'
+require 'edition'
+
+class CampaignEdition < Edition
+  include Attachable
+
+  field :body, type: String
+  field :organisation_formatted_name, type: String
+  field :organisation_url, type: String
+  field :organisation_brand_colour, type: String
+  field :organisation_crest, type: String
+
+  attaches :large_image, :medium_image, :small_image
+
+  GOVSPEAK_FIELDS = Edition::GOVSPEAK_FIELDS + [:body]
+  @fields_to_clone = [
+    :body, :large_image_id, :medium_image_id, :small_image_id,
+    :organisation_formatted_name, :organisation_url, :organisation_brand_colour, :organisation_crest
+  ]
+
+  BRAND_COLOURS = [
+    "attorney-generals-office",
+    "cabinet-office",
+    "department-for-business-innovation-skills",
+    "department-for-communities-and-local-government",
+    "department-for-culture-media-sport",
+    "department-for-education",
+    "department-for-environment-food-rural-affairs",
+    "department-for-international-development",
+    "department-for-transport",
+    "department-for-work-pensions",
+    "department-of-energy-climate-change",
+    "department-of-health",
+    "foreign-commonwealth-office",
+    "hm-government",
+    "hm-revenue-customs",
+    "hm-treasury",
+    "home-office",
+    "ministry-of-defence",
+    "ministry-of-justice",
+    "northern-ireland-office",
+    "office-of-the-advocate-general-for-scotland",
+    "office-of-the-leader-of-the-house-of-lords",
+    "scotland-office",
+    "the-office-of-the-leader-of-the-house-of-commons",
+    "uk-export-finance",
+    "uk-trade-investment",
+    "wales-office"
+  ]
+  CRESTS = {
+    "No identity" => "no-identity",
+    "Single identity" => "single-identity",
+    "Department for Business, Innovation and Skills" => "bis",
+    "Scotland Office" => "so",
+    "Home Office" => "ho",
+    "Ministry of Defence" => "mod",
+    "Wales Office" => "wales",
+    "HM Coastguard" => "coastguard",
+    "Portcullis" => "portcullis",
+    "UK Hydrographic Office" => "ukho",
+    "Executive Office" => "eo",
+    "HM Revenue and Customs" => "hmrc",
+    "UK Atomic Energy Authority" => "ukaea"
+  }
+
+  validates :organisation_brand_colour, :inclusion => { :in => BRAND_COLOURS, :allow_blank => true }
+  validates :organisation_crest, :inclusion => { :in => CRESTS.values, :allow_blank => true }
+
+  def whole_body
+    self.body
+  end
+end

data/app/models/completed_transaction_edition.rb

@@ -0,0 +1,14 @@
+require "edition"
+
+class CompletedTransactionEdition < Edition
+  field :body, type: String
+
+  GOVSPEAK_FIELDS = Edition::GOVSPEAK_FIELDS + [:body]
+
+  @fields_to_clone = [:body]
+
+  def whole_body
+    self.body
+  end
+
+end

data/app/models/curated_list.rb

@@ -0,0 +1,32 @@
+require "slug_validator"
+require "traits/taggable"
+require "safe_html"
+
+class CuratedList
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  include Taggable
+  stores_tags_for :sections
+
+  field "slug", type: String
+  has_and_belongs_to_many :artefacts, class_name: "Artefact"
+
+  index "slug"
+
+  GOVSPEAK_FIELDS = []
+
+  validates :slug, presence: true, uniqueness: true, slug: true
+  validates_with SafeHtml
+
+  def self.find_by_slug(slug)
+    where(slug: slug).first
+  end
+
+  # Returns the artefacts in order, skipping missing artefacts
+  def artefacts
+    Artefact.where(:_id.in => artefact_ids).sort_by do |artefact|
+      artefact_ids.index(artefact.id)
+    end
+  end
+end

data/app/models/edition.rb

@@ -0,0 +1,286 @@
+require "workflow"
+require "fact_check_address"
+
+class Edition
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include Workflow
+
+  field :panopticon_id,        type: String
+  field :version_number,       type: Integer,  default: 1
+  field :sibling_in_progress,  type: Integer,  default: nil
+  field :business_proposition, type: Boolean,  default: false
+
+  field :title,                type: String
+  field :created_at,           type: DateTime, default: lambda { Time.zone.now }
+  field :overview,             type: String
+  field :alternative_title,    type: String
+  field :slug,                 type: String
+  field :section,              type: String
+  field :department,           type: String
+  field :rejected_count,       type: Integer,  default: 0
+  field :tags,                 type: String
+
+  field :assignee,             type: String
+  field :creator,              type: String
+  field :publisher,            type: String
+  field :archiver,             type: String
+
+  GOVSPEAK_FIELDS = []
+
+  belongs_to :assigned_to, class_name: "User"
+
+  scope :lined_up,            where(state: "lined_up")
+  scope :draft,               where(state: "draft")
+  scope :amends_needed,       where(state: "amends_needed")
+  scope :in_review,           where(state: "in_review")
+  scope :fact_check,          where(state: "fact_check")
+  scope :fact_check_received, where(state: "fact_check_received")
+  scope :ready,               where(state: "ready")
+  scope :published,           where(state: "published")
+  scope :archived,            where(state: "archived")
+  scope :in_progress,         where(:state.nin => ["archived", "published"])
+  scope :assigned_to,         lambda { |user|
+    if user
+      where(assigned_to_id: user.id)
+    else
+      where(:assigned_to_id.exists => false)
+    end
+  }
+
+  validates :title, presence: true
+  validates :version_number, presence: true
+  validates :panopticon_id, presence: true
+  validates_with SafeHtml
+
+  before_save :check_for_archived_artefact
+  before_destroy :destroy_artefact
+
+  index "assigned_to_id"
+  index "panopticon_id"
+  index "state"
+
+  class << self; attr_accessor :fields_to_clone end
+  @fields_to_clone = []
+
+  alias_method :admin_list_title, :title
+
+  def series
+    Edition.where(panopticon_id: panopticon_id)
+  end
+
+  def history
+    series.order([:version_number, :desc])
+  end
+
+  def siblings
+    series.excludes(id: id)
+  end
+
+  def previous_siblings
+    siblings.where(:version_number.lt => version_number)
+  end
+
+  def subsequent_siblings
+    siblings.where(:version_number.gt => version_number)
+  end
+
+  def latest_edition?
+    subsequent_siblings.empty?
+  end
+
+  def published_edition
+    series.where(state: "published").order(version_number: "desc").first
+  end
+
+  def previous_published_edition
+    series.where(state: "published").order(version_number: "desc").second
+  end
+
+  def in_progress_sibling
+    subsequent_siblings.in_progress.order(version_number: "desc").first
+  end
+
+  def can_create_new_edition?
+    subsequent_siblings.in_progress.empty?
+  end
+
+  def meta_data
+    PublicationMetadata.new self
+  end
+
+  def fact_check_email_address
+    FactCheckAddress.new.for_edition(self)
+  end
+
+  def get_next_version_number
+    latest_version = series.order(version_number: "desc").first.version_number
+    latest_version + 1
+  end
+
+  def indexable_content
+    respond_to?(:parts) ? indexable_content_with_parts : indexable_content_without_parts
+  end
+
+  def indexable_content_without_parts
+    if respond_to?(:body)
+      "#{alternative_title} #{Govspeak::Document.new(body).to_text}".strip
+    else
+      alternative_title
+    end
+  end
+
+  def indexable_content_with_parts
+    content = indexable_content_without_parts
+    return content unless published_edition
+    parts.inject([content]) { |acc, part|
+      acc.concat([part.title, Govspeak::Document.new(part.body).to_text])
+    }.compact.join(" ").strip
+  end
+
+  # If the new clone is of the same type, we can copy all its fields over; if
+  # we are changing the type of the edition, any fields other than the base
+  # fields will likely be meaningless.
+  def fields_to_copy(edition_class)
+    edition_class == self.class ? self.class.fields_to_clone : []
+  end
+
+  def build_clone(edition_class=nil)
+    unless state == "published"
+      raise "Cloning of non published edition not allowed"
+    end
+    unless can_create_new_edition?
+      raise "Cloning of a published edition when an in-progress edition exists
+             is not allowed"
+    end
+
+    edition_class = self.class unless edition_class
+    new_edition = edition_class.new(title: self.title,
+                                    version_number: get_next_version_number)
+
+    real_fields_to_merge = fields_to_copy(edition_class) +
+                           [:panopticon_id, :overview, :alternative_title,
+                            :slug, :section, :department]
+
+    real_fields_to_merge.each do |attr|
+      new_edition[attr] = read_attribute(attr)
+    end
+
+    if edition_class == AnswerEdition and self.class == GuideEdition
+      new_edition.body = whole_body
+    end
+
+    if edition_class == GuideEdition and self.class == AnswerEdition
+      new_edition.parts.build(title: "Part One", body: whole_body,
+                              slug: "part-one")
+    end
+
+    new_edition
+  end
+
+  def self.find_or_create_from_panopticon_data(panopticon_id,
+                                               importing_user, api_credentials)
+    existing_publication = Edition.where(panopticon_id: panopticon_id)
+                                  .order_by([:version_number, :desc]).first
+    return existing_publication if existing_publication
+
+    raise "Artefact not found" unless metadata = Artefact.find(panopticon_id)
+
+    importing_user.create_edition(metadata.kind.to_sym,
+      panopticon_id: metadata.id,
+      slug: metadata.slug,
+      title: metadata.name,
+      section: metadata.section,
+      department: metadata.department,
+      business_proposition: metadata.business_proposition)
+  end
+
+  def self.find_and_identify(slug, edition)
+    scope = where(slug: slug)
+
+    if edition.present? and edition == "latest"
+      scope.order_by(:version_number).last
+    elsif edition.present?
+      scope.where(version_number: edition).first
+    else
+      scope.where(state: "published").order_by(:created_at).last
+    end
+  end
+
+  def panopticon_uri
+    Plek.current.find("panopticon") + "/artefacts/" + (panopticon_id || slug).to_s
+  end
+
+  def format
+    self.class.to_s.gsub("Edition", "")
+  end
+
+  def format_name
+    format
+  end
+
+  def has_video?
+    false
+  end
+
+  def safe_to_preview?
+    true
+  end
+
+  def has_sibling_in_progress?
+    ! sibling_in_progress.nil?
+  end
+
+  # Stop broadcasting a delete message unless there are no siblings.
+  def broadcast_action(callback_action)
+    unless callback_action == "destroyed" and self.siblings.any?
+      super(callback_action)
+    end
+  end
+
+  def was_published
+    previous_siblings.all.each(&:archive)
+    notify_siblings_of_published_edition
+  end
+
+  def update_from_artefact(artefact)
+    self.title = artefact.name unless published?
+    self.slug = artefact.slug
+    self.section = artefact.section
+    self.department = artefact.department
+    self.business_proposition = artefact.business_proposition
+    self.save!
+  end
+
+  def check_for_archived_artefact
+    if panopticon_id
+      a = Artefact.find(panopticon_id)
+      if a.state == "archived" and changed_attributes.any?
+        # If we're only changing the state to archived, that's ok
+        # Any other changes are not allowed
+        allowed_keys = ["state", "updated_at"]
+        unless ((changed_attributes.keys - allowed_keys).empty?) and state == "archived"
+          raise "Editing of an edition with an Archived artefact is not allowed"
+        end
+      end
+    end
+  end
+
+  def artefact
+    Artefact.find(panopticon_id)
+  end
+
+  # When we delete an edition is the only one in its series
+  # we delete the associated artefact to remove all trace of the
+  # item from the system.
+  #
+  # We don't do this by notifying panopticon as this will only ever
+  # happen for artefacts representing editions that haven't been
+  # published (and therefore aren't registered in the rest of the)
+  # system.
+  def destroy_artefact
+    if can_destroy? && siblings.empty?
+      Artefact.find(self.panopticon_id).destroy
+    end
+  end
+end