govuk_content_models 6.0.2

data/app/models/simple_smart_answer_edition/node.rb

@@ -0,0 +1,40 @@
+require "edition"
+
+class SimpleSmartAnswerEdition < Edition
+  class Node
+    include Mongoid::Document
+    embedded_in :edition, :class_name => "SimpleSmartAnswerEdition"
+    embeds_many :options, :class_name => "SimpleSmartAnswerEdition::Node::Option"
+
+    accepts_nested_attributes_for :options, :allow_destroy => true
+
+    field :slug, type: String
+    field :title, type: String
+    field :body, type: String
+    field :order, type: Integer
+    field :kind, type: String
+
+    default_scope order_by([:order, :asc])
+
+    GOVSPEAK_FIELDS = [:body]
+
+    KINDS = [
+      'question',
+      'outcome'
+    ]
+
+    validates :title, :kind, presence: true
+    validates :kind, inclusion: { :in => KINDS }
+    validates :slug, :presence => true, :format => {:with => /\A[a-z0-9-]+\z/}
+
+    validate :outcomes_have_no_options
+
+    validates_with SafeHtml
+
+    private
+
+    def outcomes_have_no_options
+      errors.add(:options, "cannot be added for an outcome") if options.present? and options.any? and kind == "outcome"
+    end
+  end
+end

data/app/models/simple_smart_answer_edition/node/option.rb

@@ -0,0 +1,31 @@
+require "edition"
+
+class SimpleSmartAnswerEdition < Edition
+  class Node
+    class Option
+      include Mongoid::Document
+
+      embedded_in :node, :class_name => "SimpleSmartAnswerEdition::Node"
+
+      field :label, type: String
+      field :slug, type: String
+      field :next_node, type: String
+      field :order, type: Integer
+
+      default_scope order_by([:order, :asc])
+
+      validates :label, :next_node, presence: true
+      validates :slug, :format => {:with => /\A[a-z0-9-]+\z/}
+
+      before_validation :populate_slug_if_blank
+
+      private
+
+      def populate_slug_if_blank
+        if self.slug.blank? and self.label.present?
+          self.slug = ActiveSupport::Inflector.parameterize(self.label)
+        end
+      end
+    end
+  end
+end

data/app/models/tag.rb

@@ -0,0 +1,88 @@
+require "safe_html"
+
+class Tag
+  include Mongoid::Document
+  field :tag_id,   type: String
+  field :title,    type: String
+  field :tag_type, type: String #TODO: list of accepted types?
+  field :description, type: String
+  field :short_description, type: String
+
+  field :parent_id, type: String
+
+  GOVSPEAK_FIELDS = []
+
+  index :tag_id
+  index [ [:tag_id, Mongo::ASCENDING], [:tag_type, Mongo::ASCENDING] ], unique: true
+  index :tag_type
+
+  validates_presence_of :tag_id, :title, :tag_type
+  validates_with SafeHtml
+
+  class MissingTags < RuntimeError
+    attr_reader :tag_ids
+
+    def initialize(tag_ids)
+      super("Missing tags: #{tag_ids.join(", ")}")
+      @tag_ids = tag_ids
+    end
+  end
+
+  # This doesn't get set automatically: the code that loads tags
+  # should go through them and set this attribute manually
+  attr_accessor :uniquely_named
+
+  def as_json(options = {})
+    {
+      id: self.tag_id,
+      title: self.title,
+      type: self.tag_type,
+      description: self.description,
+      short_description: self.short_description
+    }
+  end
+
+  def has_parent?
+    parent_id.present?
+  end
+
+  def parent
+    Tag.by_tag_id(parent_id, self.tag_type) if has_parent?
+  end
+
+  def unique_title
+    self.uniquely_named ? self.title : "#{self.title} [#{self.tag_id}]"
+  end
+
+  def to_s
+    title
+  end
+
+  def self.by_tag_id(tag_id, tag_type = nil)
+    scope = tag_type ? Tag.where(tag_type: tag_type) : Tag
+    scope.where(tag_id: tag_id).first
+  end
+
+  # Retrieve a list of tags by tag ID. Any missing tags become `nil`.
+  def self.by_tag_ids(tag_id_list, tag_type = nil)
+    scope = tag_type ? Tag.where(tag_type: tag_type) : Tag
+
+    # Load up all the tags in a single query
+    tags = scope.any_in(tag_id: tag_id_list).to_a
+    tag_id_list.map { |tag_id| tags.find { |t| t.tag_id == tag_id } }
+  end
+
+  # Retrieve a list of tags by tag ID. Any missing tags raise an exception.
+  def self.by_tag_ids!(tag_id_list, tag_type = nil)
+    tags = by_tag_ids(tag_id_list, tag_type)
+    if tags.any?(&:nil?)
+      # Find the tag IDs for which the resulting tag is nil
+      missing_ids = tag_id_list.zip(tags).select { |tag_id, tag|
+        tag.nil?
+      }.map(&:first)
+      raise MissingTags, missing_ids
+    else
+      tags
+    end
+  end
+end

data/app/models/transaction_edition.rb

@@ -0,0 +1,28 @@
+require "edition"
+require "expectant"
+
+class TransactionEdition < Edition
+
+  include Expectant
+
+  field :introduction,      type: String
+  field :will_continue_on,  type: String
+  field :link,              type: String
+  field :more_information,  type: String
+  field :alternate_methods, type: String
+
+  GOVSPEAK_FIELDS = Edition::GOVSPEAK_FIELDS + [:introduction, :more_information, :alternate_methods]
+
+  @fields_to_clone = [:introduction, :will_continue_on, :link,
+                      :more_information, :alternate_methods,
+                      :minutes_to_complete, :uses_government_gateway,
+                      :expectation_ids]
+
+  def indexable_content
+    "#{super} #{Govspeak::Document.new(introduction).to_text} #{Govspeak::Document.new(more_information).to_text}".strip
+  end
+
+  def whole_body
+    [ self.link, self.introduction, self.more_information ].join("\n\n")
+  end
+end

data/app/models/travel_advice_edition.rb

@@ -0,0 +1,177 @@
+require 'attachable'
+require 'parted'
+require 'state_machine'
+require 'safe_html'
+require 'govspeak_smart_quotes_fixer'
+
+class TravelAdviceEdition
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include Parted
+  include Attachable
+
+  field :country_slug,         type: String
+  field :title,                type: String
+  field :overview,             type: String
+  field :version_number,       type: Integer
+  field :state,                type: String,    default: "draft"
+  field :alert_status,         type: Array,     default: [ ]
+  field :summary,              type: String
+  field :change_description,   type: String
+  field :minor_update,         type: Boolean,   default: false
+  field :synonyms,             type: Array,     default: [ ]
+  # This is the publicly presented publish time. For minor updates, this will be the publish time of the previous version
+  field :published_at,         type: Time
+  field :reviewed_at,          type: Time
+
+  embeds_many :actions
+
+  index [[:country_slug, Mongo::ASCENDING], [:version_number, Mongo::DESCENDING]], :unique => true
+
+  attaches :image, :document
+
+  GOVSPEAK_FIELDS = [:summary]
+  ALERT_STATUSES = [
+    "avoid_all_but_essential_travel_to_parts",
+    "avoid_all_but_essential_travel_to_whole_country",
+    "avoid_all_travel_to_parts",
+    "avoid_all_travel_to_whole_country",
+  ]
+
+  include GovspeakSmartQuotesFixer
+  before_validation :populate_version_number, :on => :create
+
+  validates_presence_of :country_slug, :title
+  validate :state_for_slug_unique
+  validates :version_number, :presence => true, :uniqueness => { :scope => :country_slug }
+  validate :alert_status_contains_valid_values
+  validate :first_version_cant_be_minor_update
+  validates_with SafeHtml
+
+  scope :published, where(:state => "published")
+
+  class << self; attr_accessor :fields_to_clone end
+  @fields_to_clone = [:title, :country_slug, :overview, :alert_status, :summary, :image_id, :document_id, :synonyms]
+
+  state_machine initial: :draft do
+    before_transition :draft => :published do |edition, transition|
+      if edition.minor_update
+        previous = edition.previous_version
+        edition.published_at = previous.published_at
+        edition.reviewed_at = previous.reviewed_at
+        edition.change_description = previous.change_description
+      else
+        edition.published_at = Time.zone.now.utc
+        edition.reviewed_at = edition.published_at
+      end
+      edition.class.where(country_slug: edition.country_slug, state: 'published').each do |ed|
+        ed.archive
+      end
+    end
+
+    event :publish do
+      transition draft: :published
+    end
+
+    event :archive do
+      transition all => :archived, :unless => :archived?
+    end
+
+    state :published do
+      validate :cannot_edit_published
+      validates_presence_of :change_description, :unless => :minor_update, :message => "can't be blank on publish"
+    end
+    state :archived do
+      validate :cannot_edit_archived
+    end
+  end
+
+  def indexable_content
+    strings = [Govspeak::Document.new(self.summary).to_text]
+    parts.each do |part|
+      strings << part.title << Govspeak::Document.new(part.body).to_text
+    end
+    strings.join(" ").strip
+  end
+
+
+  def build_clone
+    new_edition = self.class.new
+    self.class.fields_to_clone.each do |attr|
+      new_edition[attr] = self.read_attribute(attr)
+    end
+    new_edition.parts = self.parts.map(&:dup)
+    new_edition
+  end
+
+  def build_action_as(user, action_type, comment = nil)
+    actions.build(:requester => user, :request_type => action_type, :comment => comment)
+  end
+
+  def publish_as(user)
+    comment = self.minor_update ? 'Minor update' : Govspeak::Document.new(self.change_description).to_text
+    build_action_as(user, Action::PUBLISH, comment) && publish
+  end
+
+  def previous_version
+    self.class.where(:country_slug => self.country_slug, :version_number.lt => self.version_number).order_by([:version_number, :desc]).first
+  end
+
+  private
+
+  def state_for_slug_unique
+    if %w(published draft).include?(self.state) and
+        self.class.where(:_id.ne => id,
+                         :country_slug => country_slug,
+                         :state => state).any?
+      errors.add(:state, :taken)
+    end
+  end
+
+  def populate_version_number
+    if self.version_number.nil? and ! self.country_slug.nil? and ! self.country_slug.empty?
+      if latest_edition = self.class.where(:country_slug => self.country_slug).order_by([:version_number, :desc]).first
+        self.version_number = latest_edition.version_number + 1
+      else
+        self.version_number = 1
+      end
+    end
+  end
+
+  def cannot_edit_published
+    if anything_other_than_state_changed?('reviewed_at') and self.state_was != 'draft'
+      errors.add(:state, "must be draft to modify")
+    end
+  end
+
+  def cannot_edit_archived
+    if anything_other_than_state_changed?
+      errors.add(:state, "must be draft to modify")
+    end
+  end
+
+  def anything_other_than_state_changed?(*additional_allowed_fields)
+    self.changed? and ((real_fields_changed - ['state'] - additional_allowed_fields) != [] or self.parts.any?(&:changed?))
+  end
+
+  def real_fields_changed
+    # There's an issue with dirty-tracking of Array fields.  Merely accessing them will mark
+    # them as changed, but with no changes. This recifies that.
+    # this also allows changes when the change is something changing from nil to an empty array
+    self.changes.reject { |k, v|
+      v.nil? || v == [nil, []]
+    }.keys
+  end
+
+  def alert_status_contains_valid_values
+    self.alert_status.each do |status|
+      errors.add(:alert_status, "is not in the list") unless ALERT_STATUSES.include?(status)
+    end
+  end
+
+  def first_version_cant_be_minor_update
+    if self.minor_update and self.version_number == 1
+      errors.add(:minor_update, "can't be set for first version")
+    end
+  end
+end

data/app/models/user.rb

@@ -0,0 +1,54 @@
+require "digest/md5"
+require "cgi"
+require "gds-sso/user"
+require "workflow_actor"
+require "safe_html"
+
+class User
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include GDS::SSO::User
+  include WorkflowActor
+
+  # Let an app configure the collection name to use, e.g. set a constant in an
+  # initializer
+  def self.collection_name
+    defined?(USER_COLLECTION_NAME) ? USER_COLLECTION_NAME : "users"
+  end
+
+  field "name",                type: String
+  field "uid",                 type: String
+  field "version",             type: Integer
+  field "email",               type: String
+  field "permissions",         type: Array
+  field "remotely_signed_out", type: Boolean, default: false
+  
+  GOVSPEAK_FIELDS = []
+
+  # Setup accessible (or protected) attributes for your model
+  attr_accessible :email, :name, :uid
+  attr_accessible :email, :name, :uid, :permissions, as: :oauth
+
+  scope :alphabetized, order_by(name: :asc)
+
+  validates_with SafeHtml
+
+  # GDS::SSO specifically looks for find_by_uid within warden
+  # when loading authentication user from session
+  def self.find_by_uid(uid)
+    where(uid: uid).first
+  end
+
+  def to_s
+    name || email || ""
+  end
+
+  def gravatar_url(opts = {})
+    opts.symbolize_keys!
+    "%s.gravatar.com/avatar/%s%s" % [
+      opts[:ssl] ? "https://secure" : "http://www",
+      Digest::MD5.hexdigest(email.downcase),
+      opts[:s] ? "?s=#{CGI.escape(opts[:s])}" : ""
+    ]
+  end
+end

data/app/models/video_edition.rb

@@ -0,0 +1,24 @@
+require "edition"
+require "attachable"
+
+class VideoEdition < Edition
+  include Attachable
+
+  field :video_url,     type: String
+  field :video_summary, type: String
+  field :body,          type: String
+
+  GOVSPEAK_FIELDS = Edition::GOVSPEAK_FIELDS + [:body]
+
+  @fields_to_clone = [:video_url, :video_summary, :body]
+
+  attaches :caption_file
+
+  def has_video?
+    video_url.present?
+  end
+
+  def whole_body
+    [video_summary, video_url, body].join("\n\n")
+  end
+end