govuk_content_models 6.0.2

data/app/models/expectant.rb

@@ -0,0 +1,21 @@
+module Expectant
+
+  module ClassMethods
+    def expectation_choices
+      Hash[Expectation.all.order_by(text: :asc).map {|e| [e.text, e._id.to_s] }]
+    end
+  end
+
+  extend ActiveSupport::Concern
+
+  included do
+    field :expectation_ids,         type: Array,   default: []
+    field :minutes_to_complete,     type: String
+    field :uses_government_gateway, type: Boolean
+  end
+
+  def expectations
+    Expectation.criteria.in(_id: self.expectation_ids)
+  end
+
+end

data/app/models/expectation.rb

@@ -0,0 +1,12 @@
+require "safe_html"
+
+class Expectation
+  include Mongoid::Document
+  cache
+
+  field :text,      type: String
+
+  GOVSPEAK_FIELDS = []
+
+  validates_with SafeHtml
+end

data/app/models/guide_edition.rb

@@ -0,0 +1,19 @@
+require "edition"
+require "parted"
+
+class GuideEdition < Edition
+  include Parted
+
+  field :video_url,     type: String
+  field :video_summary, type: String
+
+  @fields_to_clone = [:video_url, :video_summary]
+
+  def has_video?
+    video_url.present?
+  end
+
+  def safe_to_preview?
+    parts.any? and parts.first.slug.present?
+  end
+end

data/app/models/help_page_edition.rb

@@ -0,0 +1,13 @@
+require "edition"
+
+class HelpPageEdition < 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/licence_edition.rb

@@ -0,0 +1,35 @@
+require "edition"
+
+class LicenceEdition < Edition
+
+  field :licence_identifier,  :type => String
+  field :licence_short_description, :type => String
+  field :licence_overview,  :type => String
+  field :will_continue_on, :type => String
+  field :continuation_link, :type => String
+
+  GOVSPEAK_FIELDS = Edition::GOVSPEAK_FIELDS + [:licence_overview]
+
+  validates :licence_identifier, :presence => true
+  validate :licence_identifier_unique
+  validates_format_of :continuation_link, :with => URI::regexp(%w(http https)), :allow_blank => true
+  
+  @fields_to_clone = [:licence_identifier, :licence_short_description,
+                      :licence_overview, :will_continue_on, :continuation_link]
+
+  def whole_body
+    [licence_short_description, licence_overview].join("\n\n")
+  end
+
+  def indexable_content
+    "#{super} #{licence_short_description} #{Govspeak::Document.new(licence_overview).to_text}".strip
+  end
+
+  private
+  def licence_identifier_unique
+    if self.class.without_state('archived').where(:licence_identifier => licence_identifier,
+                        :panopticon_id.ne => panopticon_id).any?
+      errors.add(:licence_identifier, :taken)
+    end
+  end
+end

data/app/models/local_authority.rb

@@ -0,0 +1,58 @@
+require "csv"
+require "local_interaction"
+require "safe_html"
+
+class LocalAuthority
+  include Mongoid::Document
+
+  embeds_many :local_interactions
+
+  field :name,               type: String
+  field :snac,               type: String
+  field :local_directgov_id, type: Integer
+  field :tier,               type: String
+  field :contact_address,    type: Array
+  field :contact_url,        type: String
+  field :contact_phone,      type: String
+  field :contact_email,      type: String
+
+  GOVSPEAK_FIELDS = []
+
+  validates_uniqueness_of :snac
+  validates_presence_of   :snac, :local_directgov_id, :name, :tier
+  validates_with SafeHtml
+
+  scope :for_snacs, ->(snacs) { any_in(snac: snacs) }
+
+  def self.find_by_snac(snac)
+    for_snacs([snac]).first
+  end
+
+  def provides_service?(lgsl_code, lgil_code = nil)
+    interactions_for(lgsl_code, lgil_code).any?
+  end
+
+  def interactions_for(lgsl_code, lgil_code = nil)
+    interactions = local_interactions.where(lgsl_code: lgsl_code)
+    if lgil_code
+      interactions.where(lgil_code: lgil_code)
+    else
+      interactions
+    end
+  end
+
+  def preferred_interaction_for(lgsl_code, lgil_code = nil)
+    interactions = local_interactions.where(lgsl_code: lgsl_code)
+    if lgil_code
+      interactions.where(lgil_code: lgil_code).first
+    else
+      interactions.excludes(
+        lgil_code: LocalInteraction::LGIL_CODE_PROVIDING_INFORMATION
+      ).order_by([:lgil_code, :asc]).first ||
+      interactions.where(
+        lgil_code: LocalInteraction::LGIL_CODE_PROVIDING_INFORMATION
+      ).first
+    end
+  end
+
+end

data/app/models/local_interaction.rb

@@ -0,0 +1,20 @@
+require "csv"
+require "safe_html"
+
+class LocalInteraction
+  include Mongoid::Document
+
+  LGIL_CODE_PROVIDING_INFORMATION = 8
+
+  field :lgsl_code, type: Integer
+  field :lgil_code, type: Integer
+  field :url,       type: String
+
+  GOVSPEAK_FIELDS = []
+
+  embedded_in :local_authority
+
+  validates_presence_of :url, :lgil_code, :lgsl_code
+  validates_uniqueness_of :lgil_code, :scope => :lgsl_code
+  validates_with SafeHtml
+end

data/app/models/local_service.rb

@@ -0,0 +1,49 @@
+require "csv"
+require "local_authority"
+require "safe_html"
+
+class LocalService
+  include Mongoid::Document
+
+  field :description,    type: String
+  field :lgsl_code,      type: Integer
+  field :providing_tier, type: Array
+
+  GOVSPEAK_FIELDS = []
+
+  validates_presence_of :lgsl_code, :providing_tier
+  validates_uniqueness_of :lgsl_code
+  validates :providing_tier, inclusion: {
+    in: [%w{county unitary}, %w{district unitary}, %w{district unitary county}]
+  }
+  validates_with SafeHtml
+
+  def self.find_by_lgsl_code(lgsl_code)
+    LocalService.where(lgsl_code: lgsl_code).first
+  end
+
+  def preferred_interaction(snac_or_snac_list, lgil_override = nil)
+    provider = preferred_provider(snac_or_snac_list)
+    provider && provider.preferred_interaction_for(lgsl_code, lgil_override)
+  end
+
+  def preferred_provider(snac_or_snac_list)
+    snac_list = [*snac_or_snac_list]
+    providers = LocalAuthority.for_snacs(snac_list)
+    select_tier(providers)
+  end
+
+  def provided_by
+    LocalAuthority.where("local_interactions.lgsl_code" => lgsl_code)
+                  .any_in(tier: providing_tier)
+  end
+
+private
+
+  def select_tier(authorities)
+    by_tier = Hash[authorities.map {|a| [a.tier, a]}]
+    tier = providing_tier.find { |t| by_tier.has_key?(t) }
+    tier && by_tier[tier]
+  end
+
+end

data/app/models/local_transaction_edition.rb

@@ -0,0 +1,49 @@
+require "expectant"
+require "local_service"
+require "edition"
+
+class LocalTransactionEdition < Edition
+  include Expectant
+
+  field :lgsl_code,         type: Integer
+  field :lgil_override,     type: Integer
+  field :introduction,      type: String
+  field :more_information,  type: String
+
+  GOVSPEAK_FIELDS = Edition::GOVSPEAK_FIELDS + [:introduction, :more_information]
+
+  @fields_to_clone = [
+    :lgsl_code, :introduction, :more_information,
+    :minutes_to_complete, :expectation_ids
+  ]
+
+  validate :valid_lgsl_code
+
+  def valid_lgsl_code
+    if ! self.service
+      errors.add(:lgsl_code, "#{lgsl_code} not recognised")
+    end
+  end
+
+  def format_name
+    "Local transaction"
+  end
+
+  def search_format
+    "transaction"
+  end
+
+  def service
+    LocalService.find_by_lgsl_code(lgsl_code)
+  end
+
+  def service_provided_by?(snac)
+    authority = LocalAuthority.find_by_snac(snac)
+    authority && authority.provides_service?(lgsl_code)
+  end
+
+  def whole_body
+    self.introduction
+  end
+
+end

data/app/models/overview_dashboard.rb

@@ -0,0 +1,25 @@
+require "safe_html"
+
+class OverviewDashboard
+  include Mongoid::Document
+
+  TOTAL_KEY = "**TOTAL**"
+  UNASSIGNED_KEY = "**UNASSIGNED**"
+
+  field :dashboard_type,      type: String
+  field :result_group,        type: Integer
+  field :count,               type: Integer
+  field :lined_up,            type: Integer
+  field :draft,               type: Integer
+  field :amends_needed,       type: Integer
+  field :in_review,           type: Integer
+  field :ready,               type: Integer
+  field :fact_check_received, type: Integer
+  field :fact_check,          type: Integer
+  field :published,           type: Integer
+  field :archived,            type: Integer
+
+  GOVSPEAK_FIELDS = []
+
+  validates_with SafeHtml
+end

data/app/models/part.rb

@@ -0,0 +1,28 @@
+require "safe_html"
+require 'govspeak_smart_quotes_fixer'
+
+class Part
+  include Mongoid::Document
+
+  embedded_in :guide_edition
+  embedded_in :programme_edition
+  embedded_in :business_support_edition
+
+  scope :in_order, order_by(:order, :asc)
+
+  field :order,      type: Integer
+  field :title,      type: String
+  field :body,       type: String
+  field :slug,       type: String
+  field :created_at, type: DateTime, default: lambda { Time.zone.now }
+
+  GOVSPEAK_FIELDS = [:body]
+
+  include GovspeakSmartQuotesFixer
+
+  validates_presence_of :title
+  validates_presence_of :slug
+  validates_exclusion_of :slug, in: ["video"], message: "Can not be video"
+  validates_format_of :slug, with: /^[a-z0-9\-]+$/i
+  validates_with SafeHtml
+end

data/app/models/parted.rb

@@ -0,0 +1,32 @@
+require "part"
+
+module Parted
+  def self.included(klass)
+    klass.embeds_many :parts
+    klass.accepts_nested_attributes_for :parts, allow_destroy: true,
+      reject_if: proc { |attrs| attrs["title"].blank? and attrs["body"].blank? }
+  end
+
+  def build_clone(edition_class=nil)
+    new_edition = super
+
+    # If the new edition is of the same type or another type that has parts,
+    # copy over the parts from this edition
+    if edition_class.nil? or edition_class.include? Parted
+      new_edition.parts = self.parts.map {|p| p.dup }
+    end
+
+    new_edition
+  end
+
+  def order_parts
+    ordered_parts = parts.sort_by { |p| p.order ? p.order : 99999 }
+    ordered_parts.each_with_index do |obj, i|
+      obj.order = i + 1
+    end
+  end
+
+  def whole_body
+    self.parts.map {|i| %Q{\# #{i.title}\n\n#{i.body}} }.join("\n\n")
+  end
+end

data/app/models/place_edition.rb

@@ -0,0 +1,20 @@
+require "edition"
+require "expectant"
+
+class PlaceEdition < Edition
+  include Expectant
+
+  field :introduction,      type: String
+  field :more_information,  type: String
+  field :place_type,        type: String
+
+  GOVSPEAK_FIELDS = Edition::GOVSPEAK_FIELDS + [:introduction, :more_information]
+
+  @fields_to_clone = [:introduction, :more_information, :place_type,
+                      :expectation_ids]
+
+  def whole_body
+    self.introduction
+  end
+
+end

data/app/models/programme_edition.rb

@@ -0,0 +1,26 @@
+require "edition"
+require "parted"
+
+class ProgrammeEdition < Edition
+  include Parted
+
+  before_save :setup_default_parts, on: :create
+
+  @fields_to_clone = []
+
+  DEFAULT_PARTS = [
+    {title: "Overview", slug: "overview"},
+    {title: "What you'll get", slug: "what-youll-get"},
+    {title: "Eligibility", slug: "eligibility"},
+    {title: "How to claim", slug: "how-to-claim"},
+    {title: "Further information", slug: "further-information"},
+  ]
+
+  def setup_default_parts
+    if parts.empty?
+      DEFAULT_PARTS.each { |part|
+        parts.build(title: part[:title], slug: part[:slug], body: "")
+      }
+    end
+  end
+end

data/app/models/simple_smart_answer_edition.rb

@@ -0,0 +1,66 @@
+require "edition"
+require_relative 'simple_smart_answer_edition/node'
+require_relative 'simple_smart_answer_edition/node/option'
+
+class SimpleSmartAnswerEdition < Edition
+  include Mongoid::Document
+
+  field :body, type: String
+
+  embeds_many :nodes, :class_name => "SimpleSmartAnswerEdition::Node"
+
+  accepts_nested_attributes_for :nodes, allow_destroy: true
+
+  GOVSPEAK_FIELDS = Edition::GOVSPEAK_FIELDS + [:body]
+  @fields_to_clone = [:body]
+
+  def whole_body
+    body
+  end
+
+  def build_clone(edition_class=nil)
+    new_edition = super(edition_class)
+    new_edition.body = self.body
+
+    if new_edition.is_a?(SimpleSmartAnswerEdition)
+      self.nodes.each {|n| new_edition.nodes << n.clone }
+    end
+
+    new_edition
+  end
+
+
+  # Workaround mongoid conflicting mods error
+  # See https://github.com/mongoid/mongoid/issues/1219
+  # Override update_attributes so that nested nodes are updated individually. 
+  # This get around the problem of mongoid issuing a query with conflicting modifications 
+  # to the same document. 
+  alias_method :original_update_attributes, :update_attributes
+  
+  def update_attributes(attributes)
+    if nodes_attrs = attributes.delete(:nodes_attributes)
+      nodes_attrs.each do |index, node_attrs|
+        if node_id = node_attrs['id']
+          node = nodes.find(node_id)
+          if destroy_in_attrs?(node_attrs)
+            node.destroy
+          else
+            node.update_attributes(node_attrs)
+          end
+        else
+          nodes << Node.new(node_attrs) unless destroy_in_attrs?(node_attrs)
+        end
+      end
+    end
+
+    original_update_attributes(attributes)
+  end
+
+  def initial_node
+    self.nodes.first
+  end
+
+  def destroy_in_attrs?(attrs)
+    attrs['_destroy'] == '1'
+  end
+end