effective_work_experience 0.0.1

data/app/models/effective/work_experience_category.rb

@@ -0,0 +1,29 @@
+# The top level grouping of work experience subcategories
+module Effective
+  class WorkExperienceCategory < ActiveRecord::Base
+    self.table_name = (EffectiveWorkExperience.work_experience_categories_table_name || :work_experience_categories).to_s
+
+    log_changes if respond_to?(:log_changes)
+
+    has_many :work_experience_subcategories, -> { order(:position) }, class_name: 'Effective::WorkExperienceSubcategory', inverse_of: :work_experience_category
+
+    effective_resource do
+      title           :string
+      minimum_hours   :integer
+      position        :integer
+
+      timestamps
+    end
+
+    scope :sorted, -> { order(:position) }
+    scope :deep, -> { all }
+
+    validates :title, presence: true, uniqueness: true
+    validates :minimum_hours, numericality: { greater_than_or_equal_to: 0, allow_blank: true }
+    validates :position, numericality: { greater_than: 0 }
+
+    def to_s
+      title.presence || model_name.human
+    end
+  end
+end

data/app/models/effective/work_experience_entry.rb

@@ -0,0 +1,43 @@
+# One row in a monthly work experience record
+module Effective
+  class WorkExperienceEntry < ActiveRecord::Base
+    self.table_name = (EffectiveWorkExperience.work_experience_entries_table_name || :work_experience_entries).to_s
+
+    belongs_to :user, polymorphic: true
+    belongs_to :work_experience_record, class_name: 'Effective::WorkExperienceRecord', inverse_of: :work_experience_entries
+    belongs_to :work_experience_subcategory, class_name: 'Effective::WorkExperienceSubcategory'
+
+    log_changes(to: :user) if respond_to?(:log_changes)
+
+    effective_resource do
+      week_1                  :decimal
+      week_2                  :decimal
+      week_3                  :decimal
+      week_4                  :decimal
+      week_5                  :decimal
+
+      timestamps
+    end
+
+    before_validation(if: -> { work_experience_record.present? }) do
+      assign_attributes(user: work_experience_record.user)
+    end
+
+    validates :week_1, numericality: { greater_than_or_equal_to: 0.0, allow_blank: true }
+    validates :week_2, numericality: { greater_than_or_equal_to: 0.0, allow_blank: true }
+    validates :week_3, numericality: { greater_than_or_equal_to: 0.0, allow_blank: true }
+    validates :week_4, numericality: { greater_than_or_equal_to: 0.0, allow_blank: true }
+    validates :week_5, numericality: { greater_than_or_equal_to: 0.0, allow_blank: true }
+
+    scope :sorted, -> { order(:id) }
+    scope :deep, -> { includes(:user, work_experience_subcategory: :work_experience_category) }
+
+    def to_s
+      'work experience entry'
+    end
+
+    def hours
+      (week_1.to_f + week_2.to_f + week_3.to_f + week_4.to_f + week_5.to_f)
+    end
+  end
+end

data/app/models/effective/work_experience_outside_mentor.rb

@@ -0,0 +1,35 @@
+# An intern whose mentor does not have an account. We store their mentor as freeform fields.
+module Effective
+  class WorkExperienceOutsideMentor < ActiveRecord::Base
+    self.table_name = (EffectiveWorkExperience.work_experience_outside_mentors_table_name || :work_experience_outside_mentors).to_s
+
+    belongs_to :user, polymorphic: true
+
+    log_changes(to: :user) if respond_to?(:log_changes)
+
+    effective_resource do
+      name                    :string
+      email                   :string
+      phone                   :string
+      regulated_profession    :string
+      admin_notes             :text
+
+      timestamps
+    end
+
+    scope :sorted, -> { order(:name) }
+    scope :deep, -> { includes(:user) }
+
+    validates :name, presence: true
+    validates :email, presence: true, email: true
+    validates :phone, presence: true
+    validates :regulated_profession, presence: true
+
+    # A user has just one outside mentor
+    validates :user_id, uniqueness: { scope: :user_type }
+
+    def to_s
+      name.presence || model_name.human
+    end
+  end
+end

data/app/models/effective/work_experience_project.rb

@@ -0,0 +1,38 @@
+# A work experience project
+module Effective
+  class WorkExperienceProject < ActiveRecord::Base
+    self.table_name = (EffectiveWorkExperience.work_experience_projects_table_name || :work_experience_projects).to_s
+
+    belongs_to :user, polymorphic: true
+
+    log_changes(to: :user) if respond_to?(:log_changes)
+
+    effective_resource do
+      name                  :string
+      description           :text
+
+      start_on              :date
+      end_on                :date
+
+      timestamps
+    end
+
+    scope :sorted, -> { order(:start_on) }
+    scope :deep, -> { includes(:user) }
+
+    scope :during, ->(months) {
+      where('start_on <= ? AND (end_on IS NULL OR end_on >= ?)', months.last, months.first)
+    }
+
+    validates :name, presence: true, uniqueness: { scope: [:user_id, :user_type] }
+    validates :start_on, presence: true
+
+    validate(if: -> { start_on.present? && end_on.present? }) do
+      errors.add(:end_on, 'must be after the start date') if end_on < start_on
+    end
+
+    def to_s
+      name.presence || model_name.human
+    end
+  end
+end

data/app/models/effective/work_experience_record.rb

@@ -0,0 +1,99 @@
+# A monthly record of work experience
+module Effective
+  class WorkExperienceRecord < ActiveRecord::Base
+    self.table_name = (EffectiveWorkExperience.work_experience_records_table_name || :work_experience_records).to_s
+
+    belongs_to :user, polymorphic: true
+
+    has_many :work_experience_entries, -> { order(:id) }, class_name: 'Effective::WorkExperienceEntry', inverse_of: :work_experience_record, dependent: :destroy
+    accepts_nested_attributes_for :work_experience_entries, allow_destroy: true
+
+    log_changes(to: :user) if respond_to?(:log_changes)
+    has_many_rich_texts
+
+    acts_as_statused(
+      :draft,       # In-progress submission
+      :submitted,   # Submitted by intern
+      :reviewed     # Reviewed by mentor
+    )
+
+    effective_resource do
+      month                 :date       # The 1st day of the month of the work experience
+      total_hours           :decimal    # The total number of hours worked for the month
+
+      # There can only be one backdated work experience record
+      backdated             :boolean, default: false
+
+      # Acts as Statused
+      status                :string
+      status_steps          :text
+
+      submitted_at          :datetime
+      reviewed_at           :datetime
+
+      timestamps
+    end
+
+    before_validation do
+      assign_attributes(total_hours: work_experience_entries.sum(&:hours).round(2))
+    end
+
+    before_validation do
+      assign_attributes(month: month&.beginning_of_month)
+      assign_attributes(month: nil) if backdated?
+    end
+
+    validates :month, presence: true, unless: -> { backdated }
+    validates :month, absence: true, if: -> { backdated }
+
+    validates :month, uniqueness: { scope: [:user_id, :user_type] }
+    validates :total_hours, numericality: { greater_than_or_equal_to: 0.0 }
+
+    validate(if: -> { month.present? }) do
+      errors.add(:month, 'must be the first day of the month') unless month.day == 1
+    end
+
+    scope :sorted, -> { order(:month) }
+    scope :deep, -> { includes(:user, work_experience_entries: { work_experience_subcategory: :work_experience_category }) }
+    scope :during, ->(months) { where(month: months) }
+
+    def to_s
+      month&.strftime('%B %Y') || model_name.human
+    end
+
+    def work_experience_subcategories
+      Effective::WorkExperienceSubcategory.all.sorted
+    end
+
+    # Find or build
+    def work_experience_entry(work_experience_subcategory:)
+      entry = work_experience_entries.find { |work_experience_entry| work_experience_entry.work_experience_subcategory_id == work_experience_subcategory.id }
+      entry ||= work_experience_entries.build(work_experience_subcategory: work_experience_subcategory)
+      entry
+    end
+
+    def week_1_total
+      work_experience_entries.sum { |work_experience_entry| work_experience_entry.week_1 || 0.0 }.round(2)
+    end
+
+    def week_2_total
+      work_experience_entries.sum { |work_experience_entry| work_experience_entry.week_2 || 0.0 }.round(2)
+    end
+
+    def week_3_total
+      work_experience_entries.sum { |work_experience_entry| work_experience_entry.week_3 || 0.0 }.round(2)
+    end
+
+    def week_4_total
+      work_experience_entries.sum { |work_experience_entry| work_experience_entry.week_4 || 0.0 }.round(2)
+    end
+
+    def week_5_total
+      work_experience_entries.sum { |work_experience_entry| work_experience_entry.week_5 || 0.0 }.round(2)
+    end
+
+    def total_hours_to_date
+      user&.work_experience_total_hours_to_date(month: month)
+    end
+  end
+end

data/app/models/effective/work_experience_report.rb

@@ -0,0 +1,50 @@
+# The total work experience for one intern. Not an ActiveRecord model.
+module Effective
+  class WorkExperienceReport
+    include ActiveModel::Model
+
+    attr_accessor :user # The intern
+
+    def to_s
+      'Work Experience Report'
+    end
+
+    def to_param
+      user&.to_param
+    end
+
+    def mentor
+      user&.try(:work_experience_mentor)
+    end
+
+    def backdated_work_experience_record
+      work_experience_records.find(&:backdated?)
+    end
+
+    def start_on
+      work_experience_records.select { |work_experience_record| work_experience_record.month.present? }.map(&:month).sort.first
+    end
+
+    def end_on
+      work_experience_records.select { |work_experience_record| work_experience_record.month.present? }.map(&:month).sort.last
+    end
+
+    def years
+      return [] unless start_on.present?
+      (start_on.year..end_on.year).to_a
+    end
+
+    def total_hours
+      work_experience_records.sum { |work_experience_record| work_experience_record.total_hours.to_f }.round(2)
+    end
+
+    def work_experience_subcategories
+      @work_experience_subcategories ||= Effective::WorkExperienceSubcategory.all.sorted
+    end
+
+    def work_experience_records
+      return unless user.present?
+      @work_experience_records ||= user.work_experience_records
+    end
+  end
+end

data/app/models/effective/work_experience_subcategory.rb

@@ -0,0 +1,31 @@
+# The subcategories of work experience. Interns record their hours against these.
+module Effective
+  class WorkExperienceSubcategory < ActiveRecord::Base
+    self.table_name = (EffectiveWorkExperience.work_experience_subcategories_table_name || :work_experience_subcategories).to_s
+
+    belongs_to :work_experience_category, class_name: 'Effective::WorkExperienceCategory'
+
+    log_changes if respond_to?(:log_changes)
+    has_rich_text :body
+
+    effective_resource do
+      title                         :string
+      minimum_hours                 :integer
+      position                      :integer
+      work_experience_category_id   :integer
+
+      timestamps
+    end
+
+    scope :sorted, -> { order(:position) }
+    scope :deep, -> { includes(:rich_text_body, :work_experience_category) }
+
+    validates :title, presence: true, uniqueness: { scope: :work_experience_category_id }
+    validates :minimum_hours, numericality: { greater_than_or_equal_to: 0, allow_blank: true }
+    validates :position, numericality: { greater_than: 0 }, uniqueness: true
+
+    def to_s
+      [position, title].compact.join('. ').presence || model_name.human
+    end
+  end
+end

data/app/models/effective/work_experience_summary.rb

@@ -0,0 +1,7 @@
+module Effective
+  class WorkExperienceSummary < ActiveRecord::Base
+    self.table_name = (EffectiveWorkExperience.work_experience_summaries_table_name || :work_experience_summaries).to_s
+
+    effective_work_experience_summary
+  end
+end

data/app/views/admin/work_experience/_user_fields.html.haml

@@ -0,0 +1,17 @@
+-# Render this from your admin user form to assign an intern's work experience mentor
+-# = render('admin/work_experience/user_fields', f: f, hint: 'Who can be a mentor')
+- ajax_url = (effective_resources.users_effective_ajax_index_path unless Rails.env.test?)
+- f.object.work_experience_outside_mentor_present = true if f.object.work_experience_outside_mentor?
+
+= f.hide_if(:work_experience_outside_mentor_present, true) do
+  = f.select :work_experience_mentor_id, current_user.class.all, ajax_url: ajax_url,
+    label: 'Intern work experience mentor',
+    hint: local_assigns[:hint]
+
+= f.check_box :work_experience_outside_mentor_present, label: 'Intern work experience mentor is from another regulated profession'
+
+= f.show_if(:work_experience_outside_mentor_present, true) do
+  = card('Outside Mentor') do
+    -# One outside mentor is built. It's ignored unless the fields are filled in.
+    = f.has_many :work_experience_outside_mentors, label: false, add: false, remove: false, reorder: false do |fo|
+      = render('effective/work_experience_outside_mentors/fields', f: fo)

data/app/views/admin/work_experience/_user_work_experience.html.haml

@@ -0,0 +1,21 @@
+-# Render this from your admin user form to display an intern's work experience
+-# = render('admin/work_experience/user_work_experience', user: user)
+= card(et(Effective::WorkExperienceReport)) do
+  = collapse("Show summary", card_class: 'mt-3') do
+    - work_experience_report = Effective::WorkExperienceReport.new(user: user)
+    = render('effective/work_experience_reports/work_experience_report', work_experience_report: work_experience_report)
+
+= card(EffectiveWorkExperience.WorkExperienceSummary) do
+  %p.text-muted #{EffectiveWorkExperience.summary_months}-month work experience summaries are submitted by the intern and approved by their mentor.
+  - datatable = Admin::EffectiveWorkExperienceSummariesDatatable.new(user: user)
+  = render_datatable(datatable, inline: true)
+
+= card(Effective::WorkExperienceRecord) do
+  %p.text-muted Monthly work experience records are used to keep track of the intern's hours each month.
+  - datatable = Admin::EffectiveWorkExperienceRecordsDatatable.new(user: user)
+  = render_datatable(datatable, inline: true)
+
+= card(Effective::WorkExperienceProject) do
+  %p.text-muted Work experience projects are used to keep track of the intern's projects.
+  - datatable = Admin::EffectiveWorkExperienceProjectsDatatable.new(user: user)
+  = render_datatable(datatable, inline: true)

data/app/views/admin/work_experience_categories/_form.html.haml

@@ -0,0 +1,7 @@
+= tabs do
+  = tab(work_experience_category) do
+    = render 'admin/work_experience_categories/form_work_experience_category', work_experience_category: work_experience_category
+
+  - if work_experience_category.persisted? && work_experience_category.respond_to?(:logs_datatable)
+    = tab 'Logs' do
+      = render_datatable(work_experience_category.logs_datatable, inline: true)

data/app/views/admin/work_experience_categories/_form_work_experience_category.html.haml

@@ -0,0 +1,5 @@
+= effective_form_with(model: [:admin, work_experience_category], engine: true) do |f|
+  = f.text_field :title
+  = f.number_field :minimum_hours
+
+  = effective_submit(f)

data/app/views/admin/work_experience_projects/_form.html.haml

@@ -0,0 +1,11 @@
+= effective_form_with(model: [:admin, work_experience_project], engine: true) do |f|
+  = f.hidden_field :user_id
+  = f.hidden_field :user_type, value: current_user.class.name
+
+  - unless inline_datatable?
+    = f.select :user_id, current_user.class.all,
+    ajax_url: (effective_resources.users_effective_ajax_index_path unless Rails.env.test?)
+
+  = render('effective/work_experience_projects/fields', f: f)
+
+  = effective_submit(f)

data/app/views/admin/work_experience_projects/_work_experience_project.html.haml

@@ -0,0 +1 @@
+= render('effective/work_experience_projects/work_experience_project', work_experience_project: work_experience_project)

data/app/views/admin/work_experience_records/_form.html.haml

@@ -0,0 +1,12 @@
+= effective_form_with(model: [:admin, work_experience_record], engine: true) do |f|
+  = f.hidden_field :user_id
+  = f.hidden_field :user_type, value: current_user.class.name
+
+  = card(et(f.object)) do
+    - unless inline_datatable?
+      = f.select :user_id, current_user.class.all,
+      ajax_url: (effective_resources.users_effective_ajax_index_path unless Rails.env.test?)
+
+    = render('effective/work_experience_records/fields', f: f, namespace: :admin)
+
+  = effective_submit(f)

data/app/views/admin/work_experience_records/_work_experience_record.html.haml

@@ -0,0 +1 @@
+= render('effective/work_experience_records/work_experience_record', work_experience_record: work_experience_record)

data/app/views/admin/work_experience_reports/show.html.haml

@@ -0,0 +1,2 @@
+%h1= @page_title
+= render('effective/work_experience_reports/work_experience_report', work_experience_report: @work_experience_report)

data/app/views/admin/work_experience_subcategories/_form.html.haml

@@ -0,0 +1,7 @@
+= tabs do
+  = tab(work_experience_subcategory) do
+    = render 'admin/work_experience_subcategories/form_work_experience_subcategory', work_experience_subcategory: work_experience_subcategory
+
+  - if work_experience_subcategory.persisted? && work_experience_subcategory.respond_to?(:logs_datatable)
+    = tab 'Logs' do
+      = render_datatable(work_experience_subcategory.logs_datatable, inline: true)

data/app/views/admin/work_experience_subcategories/_form_work_experience_subcategory.html.haml

@@ -0,0 +1,10 @@
+= effective_form_with(model: [:admin, work_experience_subcategory], engine: true) do |f|
+  = f.select :work_experience_category_id, Effective::WorkExperienceCategory.sorted.all
+
+  = f.text_field :title
+
+  = f.number_field :minimum_hours, hint: 'Guidance target hours for this subcategory over the intern period'
+
+  = f.article_editor :body
+
+  = effective_submit(f)

data/app/views/admin/work_experience_summaries/_form.html.haml

@@ -0,0 +1,7 @@
+= tabs do
+  = tab(work_experience_summary) do
+    = render 'admin/work_experience_summaries/form_work_experience_summary', work_experience_summary: work_experience_summary
+
+  - if work_experience_summary.persisted? && work_experience_summary.respond_to?(:logs_datatable)
+    = tab 'Logs' do
+      = render_datatable(work_experience_summary.logs_datatable, inline: true)

data/app/views/admin/work_experience_summaries/_form_work_experience_summary.html.haml

@@ -0,0 +1,32 @@
+= effective_form_with(model: [:admin, work_experience_summary], engine: true) do |f|
+  = f.hidden_field :user_id
+  = f.hidden_field :user_type, value: current_user.class.name
+  = f.hidden_field :mentor_type, value: current_user.class.name
+  = f.hidden_field :supervisor_type, value: current_user.class.name
+
+  - unless inline_datatable?
+    = f.select :user_id, current_user.class.all,
+    ajax_url: (effective_resources.users_effective_ajax_index_path unless Rails.env.test?)
+
+    = f.select :mentor_id, current_user.class.all,
+    ajax_url: (effective_resources.users_effective_ajax_index_path unless Rails.env.test?)
+
+    = f.select :supervisor_id, current_user.class.all,
+    ajax_url: (effective_resources.users_effective_ajax_index_path unless Rails.env.test?)
+
+  = f.select :status, work_experience_summary_status_collection
+
+  -# Read only. These are serialized hashes and can't be submitted back as text.
+  = f.static_field :status_steps
+  = f.static_field :wizard_steps
+
+  = f.date_field :start_on
+  = f.date_field :end_on
+  = f.number_field :total_hours
+  = f.select :recommendation, work_experience_recommendation_collection
+  = f.text_area :comments
+  = f.datetime_field :submitted_at
+  = f.datetime_field :reviewed_at
+  = f.text_field :token
+
+  = effective_submit(f)

data/app/views/admin/work_experience_summaries/_work_experience_summary.html.haml

@@ -0,0 +1 @@
+= render('effective/work_experience_summaries/work_experience_summary', work_experience_summary: work_experience_summary)

data/app/views/effective/work_experience/_dashboard_intern.html.haml

@@ -0,0 +1,73 @@
+%h2 Work Experience
+
+%p Please use the following tables to track your work experience.
+
+%p
+  You can view your entire
+  = link_to("work experience summary report", effective_work_experience.work_experience_report_path(current_user))
+  at any time.
+
+%p Interns are required to submit a record for each month of their internship. Every #{EffectiveWorkExperience.summary_months} months they are required to submit a summary report.
+
+%hr
+
+%h4 Mentor
+
+- if current_user.work_experience_mentor.present?
+  %p Your mentor is #{link_to(current_user.work_experience_mentor, "mailto:#{current_user.work_experience_mentor.email}")}.
+- elsif current_user.work_experience_outside_mentor?
+  - outside_mentor = current_user.work_experience_outside_mentor
+  %p Your outside mentor is #{link_to(outside_mentor.name, "mailto:#{outside_mentor.email}")}.
+- else
+  %p You have not been assigned a mentor. Please contact us to be assigned one.
+
+%hr
+
+%h4 Monthly Records
+%p Please use the following table to track your monthly #{etsd(Effective::WorkExperienceRecord)}.
+
+.mb-2
+  = collapse("Show #{ets(Effective::WorkExperienceRecord)}") do
+    - datatable = EffectiveWorkExperienceRecordsDatatable.new(self, user: current_user)
+    = render_datatable(datatable)
+
+%p= link_to "Add a new #{etd(Effective::WorkExperienceRecord)}", effective_work_experience.new_work_experience_record_path, class: 'btn btn-primary'
+
+%hr
+
+%h4 Projects
+%p Please use the following table to track your #{etsd(Effective::WorkExperienceProject)}.
+
+.mb-2
+  = collapse("Show #{ets(Effective::WorkExperienceProject)}") do
+    - datatable = EffectiveWorkExperienceProjectsDatatable.new(self, user: current_user)
+    = render_datatable(datatable)
+
+%p= link_to "Add a new #{etd(Effective::WorkExperienceProject)}", effective_work_experience.new_work_experience_project_path, class: 'btn btn-primary'
+
+%hr
+
+%h4 #{EffectiveWorkExperience.summary_months}-Month Summary Submissions
+%p Every #{EffectiveWorkExperience.summary_months} months you are required to submit a summary of your work experience to be reviewed by your mentor.
+
+.mb-2
+  = collapse("Show #{ets(EffectiveWorkExperience.WorkExperienceSummary)}") do
+    - datatable = EffectiveWorkExperienceSummariesDatatable.new(self, user: current_user)
+    = render_datatable(datatable)
+
+- # In progress
+- work_experience_summary = current_user.work_experience_summaries.in_progress.first
+
+- if work_experience_summary.present? && work_experience_summary.draft?
+  %p
+    Your submission is incomplete.
+
+    %p
+      Please
+      = link_to("Continue summary", effective_work_experience.work_experience_summary_build_path(work_experience_summary, work_experience_summary.next_step), 'data-turbolinks' => false, class: 'btn btn-primary')
+      or you can
+      = link_to('Abandon summary', effective_work_experience.work_experience_summary_path(work_experience_summary), 'data-confirm': "Really delete #{work_experience_summary}?", 'data-method': :delete, class: 'btn btn-danger')
+      to start again.
+
+- elsif EffectiveResources.authorized?(self, :new, EffectiveWorkExperience.WorkExperienceSummary)
+  %p= link_to "Add a new #{etd(EffectiveWorkExperience.WorkExperienceSummary)}", effective_work_experience.new_work_experience_summary_path, class: 'btn btn-primary'

data/app/views/effective/work_experience/_dashboard_mentor.html.haml

@@ -0,0 +1,28 @@
+%h2 Work Experience
+
+%p Every #{EffectiveWorkExperience.summary_months} months, interns are required to submit a summary report of their work experience for your review.
+
+%hr
+
+%h4 Mentees
+
+- if current_user.work_experience_mentees.present?
+  %p You are a mentor for the following interns: #{current_user.work_experience_mentees.map(&:to_s).sort.to_sentence}.
+- else
+  %p You are not a mentor for any interns.
+
+%hr
+
+%h4 #{EffectiveWorkExperience.summary_months}-Month Summary Submissions
+%p Please review the following #{etsd(EffectiveWorkExperience.WorkExperienceSummary)}:
+
+- datatable = EffectiveWorkExperienceSummariesReviewDatatable.new(self, mentor: current_user)
+= render_datatable(datatable)
+
+%hr
+
+%h4 Summary Reports
+%p View your intern's entire work experience hours.
+
+- datatable = EffectiveWorkExperienceReportsReviewDatatable.new(self, mentor: current_user)
+= render_simple_datatable(datatable)

data/app/views/effective/work_experience_mailer/work_experience_summary_reviewed.liquid

@@ -0,0 +1,13 @@
+---
+subject: 'Your work experience from {{ period }} has been reviewed'
+---
+
+Hello {{ user.name }},
+
+The {{ period }} Work Experience Summary was reviewed by {{ mentor.name }}.
+
+{{ url }}
+
+Thank you
+
+Please contact us for assistance.

data/app/views/effective/work_experience_mailer/work_experience_summary_submitted.liquid

@@ -0,0 +1,15 @@
+---
+subject: 'Work experience from {{ user.name }} is ready for review'
+---
+
+Hello {{ mentor.name }},
+
+The {{ period }} Work Experience Summary from {{ user.name }} is ready for your review:
+
+Please start your review at this url:
+
+{{ url }}
+
+Thank you
+
+Please contact us for assistance.

data/app/views/effective/work_experience_outside_mentors/_fields.html.haml

@@ -0,0 +1,5 @@
+= f.text_field :name, label: 'Name'
+= f.email_field :email, label: 'Email'
+= f.phone_field :phone, label: 'Phone'
+= f.text_field :regulated_profession, label: 'Regulated Profession'
+= f.text_area :admin_notes, label: 'Admin Notes'

data/app/views/effective/work_experience_projects/_fields.html.haml

@@ -0,0 +1,7 @@
+= f.text_field :name
+
+.row
+  .col-md-6= f.date_field :start_on
+  .col-md-6= f.date_field :end_on
+
+= f.article_editor :description

data/app/views/effective/work_experience_projects/_form.html.haml

@@ -0,0 +1,3 @@
+= effective_form_with(model: work_experience_project, engine: true) do |f|
+  = render('effective/work_experience_projects/fields', f: f)
+  = effective_submit(f)

data/app/views/effective/work_experience_projects/_work_experience_project.html.haml

@@ -0,0 +1,2 @@
+= card(et(work_experience_project.class)) do
+  = effective_table_with(work_experience_project)