mumuki-domain 6.0.0

data/app/models/concerns/with_case_insensitive_search.rb

@@ -0,0 +1,7 @@
+module WithCaseInsensitiveSearch
+  extend ActiveSupport::Concern
+
+  included do
+    scope :find_by_ignore_case!, lambda { |attribute, value| where("lower(#{attribute}) = ?", value.downcase).first! }
+  end
+end

data/app/models/concerns/with_description.rb

@@ -0,0 +1,12 @@
+module WithDescription
+  extend ActiveSupport::Concern
+
+  included do
+    markdown_on :description, :description_teaser
+    validates_presence_of :description
+  end
+
+  def description_teaser
+    description.markdown_paragraphs.first
+  end
+end

data/app/models/concerns/with_discussion_creation/subscription.rb

@@ -0,0 +1,33 @@
+module WithDiscussionCreation::Subscription
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :discussions, foreign_key: 'initiator_id'
+    has_many :subscriptions
+    has_many :watched_discussions, through: :subscriptions, source: :discussion
+  end
+
+  def subscribed_to?(discussion)
+    discussion.subscription_for(self).present?
+  end
+
+  def subscribe_to!(discussion)
+    watched_discussions << discussion
+  end
+
+  def unsubscribe_to!(discussion)
+    watched_discussions.delete(discussion)
+  end
+
+  def toggle_subscription!(discussion)
+    if subscribed_to?(discussion)
+      unsubscribe_to!(discussion)
+    else
+      subscribe_to!(discussion)
+    end
+  end
+
+  def unread_discussions
+    subscriptions.where(read: false).map(&:discussion)
+  end
+end

data/app/models/concerns/with_discussion_creation/upvote.rb

@@ -0,0 +1,28 @@
+module WithDiscussionCreation::Upvote
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :upvotes
+    has_many :upvoted_discussions, through: :upvotes, source: :discussion
+  end
+
+  def upvoted?(discussion)
+    discussion.upvote_for(self).present?
+  end
+
+  def upvote!(discussion)
+    upvoted_discussions << discussion
+  end
+
+  def undo_upvote!(discussion)
+    upvoted_discussions.delete(discussion)
+  end
+
+  def toggle_upvote!(discussion)
+    if upvoted?(discussion)
+      undo_upvote!(discussion)
+    else
+      upvote!(discussion)
+    end
+  end
+end

data/app/models/concerns/with_discussion_creation.rb

@@ -0,0 +1,9 @@
+module WithDiscussionCreation
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :discussions, foreign_key: 'initiator_id'
+    include WithDiscussionCreation::Subscription
+    include WithDiscussionCreation::Upvote
+  end
+end

data/app/models/concerns/with_discussion_status.rb

@@ -0,0 +1,11 @@
+module WithDiscussionStatus
+  extend ActiveSupport::Concern
+
+  included do
+    serialize :status, Mumuki::Domain::Status::Discussion
+    validates_presence_of :status
+    scope :by_status, -> (status) { where(status: status) }
+  end
+
+  delegate :closed?, :opened?, :solved?, :pending_review?, :reachable_statuses, to: :status
+end

data/app/models/concerns/with_discussions.rb

@@ -0,0 +1,23 @@
+module WithDiscussions
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :discussions, as: :item, dependent: :delete_all
+  end
+
+  def discuss!(user, discussion)
+    discussion.merge!(initiator_id: user.id)
+    discussion.merge!(submission: submission_for(user)) if submission_for(user).present?
+    created_discussion = discussions.create discussion
+    user.subscribe_to! created_discussion
+    created_discussion
+  end
+
+  def submission_for(_)
+    nil
+  end
+
+  def try_solve_discussions(user)
+    discussions.where(initiator: user).map(&:try_solve!)
+  end
+end

data/app/models/concerns/with_editor.rb

@@ -0,0 +1,39 @@
+module WithEditor
+  extend ActiveSupport::Concern
+
+  included do
+    enum editor: [:code, :upload, :text, :single_choice, :multiple_choice, :hidden, :multiple_files, :custom, :free_form]
+    validate :ensure_has_choices, if: :choice?
+  end
+
+  def choice?
+    [:single_choice, :multiple_choice].include? editor.to_sym
+  end
+
+  def editor_with_defaults?
+    code?
+  end
+
+  def pretty_choices
+    choices.each_with_index.map do |choice, index|
+      struct id: "content_choice_#{index}",
+             index: index,
+             value: choice,
+             text: Mumukit::ContentType::Markdown.to_html(choice_text(choice))
+    end
+  end
+
+  private
+
+  def choice_text(choice)
+    if language.name != 'text'
+      Mumukit::ContentType::Markdown.inline_code choice
+    else
+      choice
+    end
+  end
+
+  def ensure_has_choices
+    errors.add(:base, :choice_problem_has_no_choices) if choices.blank?
+  end
+end

data/app/models/concerns/with_expectations.rb

@@ -0,0 +1,29 @@
+module WithExpectations
+  extend ActiveSupport::Concern
+
+  included do
+    serialize :expectations, Array
+    validate :ensure_expectations_format
+  end
+
+  def expectations_yaml
+    self.expectations.to_yaml
+  end
+
+  def expectations_yaml=(yaml)
+    self.expectations = YAML.load yaml
+  end
+
+  def expectations=(expectations)
+    self[:expectations] = expectations.map(&:stringify_keys)
+  end
+
+  def own_expectations
+    self[:expectations]
+  end
+
+  def ensure_expectations_format
+    errors.add :own_expectations,
+               :invalid_format unless own_expectations.to_a.all? { |it| Mumukit::Expectation.valid? it }
+  end
+end

data/app/models/concerns/with_language.rb

@@ -0,0 +1,14 @@
+module WithLanguage
+  extend ActiveSupport::Concern
+
+  included do
+    belongs_to :language
+    delegate :visible_success_output?,
+             :highlight_mode,
+             :queriable?,
+             :prompt, to: :language
+
+    validates_presence_of :language
+  end
+
+end

data/app/models/concerns/with_layout.rb

@@ -0,0 +1,7 @@
+module WithLayout
+  extend ActiveSupport::Concern
+
+  included do
+    enum layout: [:input_right, :input_bottom, :input_kids]
+  end
+end

data/app/models/concerns/with_locale.rb

@@ -0,0 +1,7 @@
+module WithLocale
+  extend ActiveSupport::Concern
+
+  included do
+    validates_presence_of :locale
+  end
+end

data/app/models/concerns/with_messages.rb

@@ -0,0 +1,22 @@
+module WithMessages
+  def receive_answer!(answer)
+    build_message(answer).save!
+  end
+
+  def send_question!(question)
+    message = build_message question.merge(sender: submitter.uid, read: true)
+    message.save_and_notify!
+  end
+
+  def build_message(body)
+    messages.build({date: DateTime.now}.merge(body))
+  end
+
+  def has_messages?
+    messages.exists?
+  end
+
+  def pending_messages?
+    messages.exists? read: false
+  end
+end

data/app/models/concerns/with_name.rb

@@ -0,0 +1,15 @@
+module WithName
+  extend ActiveSupport::Concern
+
+  included do
+    validates_presence_of :name
+    validate :ensure_name_format
+  end
+
+  private
+
+  def ensure_name_format
+    errors.add :name, :invalid_format if name&.include?('/')
+  end
+
+end

data/app/models/concerns/with_number.rb

@@ -0,0 +1,9 @@
+module WithNumber
+  extend ActiveSupport::Concern
+
+  included do
+    validates_presence_of :number
+
+    default_scope -> { order(:number) }
+  end
+end

data/app/models/concerns/with_profile.rb

@@ -0,0 +1,12 @@
+module WithProfile
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def for_profile(profile)
+      where(uid: profile.uid).first_or_initialize.tap do |user|
+        user.assign_attributes(profile.to_h.compact)
+        user.save_and_notify_changes!
+      end
+    end
+  end
+end

data/app/models/concerns/with_randomizations.rb

@@ -0,0 +1,43 @@
+module WithRandomizations
+  extend ActiveSupport::Concern
+
+  included do
+    serialize :randomizations, Hash
+    validate :ensure_randomizations_format
+  end
+
+  def seed
+    @seed || 0
+  end
+
+  def seed_with!(seed)
+    @seed = seed
+  end
+
+  def randomizer
+    #TODO remove this hack after removing seed state from here
+    @randomizer ||= (Mumukit::Randomizer.parse(randomizations) rescue Mumukit::Randomizer.new([]))
+  end
+
+  private
+
+  def ensure_randomizations_format
+    errors.add :randomizations,
+               :invalid_format unless Mumukit::Randomizer.valid? randomizations.to_h
+  end
+
+  module ClassMethods
+    def randomize(*selectors)
+      selectors.each { |selector| randomize_field selector }
+    end
+
+    private
+
+    def randomize_field(selector)
+      define_method(selector) do |*args|
+        return unless super(*args)
+        randomizer.randomize!(super(*args), seed)
+      end
+    end
+  end
+end

data/app/models/concerns/with_reminders.rb

@@ -0,0 +1,74 @@
+module WithReminders
+  extend ActiveSupport::Concern
+
+  def build_reminder
+    mailer = UserMailer.new
+    last_submission_date.nil? ?
+      mailer.no_submissions_reminder(self) :
+      mailer.we_miss_you_reminder(self, cycles_since(last_submission_date))
+  end
+
+  def remind!
+    build_reminder.deliver
+    update! last_reminded_date: Time.now
+  end
+
+  def should_remind?
+    reminder_due? && (has_no_submissions? || has_no_recent_submission?)
+  end
+
+  # Try to send a reminder, by acquiring a database lock for update
+  # the aproppriate record. This object can't be updated as long as
+  # the reminder is being sent.
+  #
+  # This method is aimed to be sent across multiple servers or processed concurrently
+  # and still not send duplicate mails
+  def try_remind_with_lock!
+    # Some notes:
+    #
+    # * nowait is a postgre specific option and may not work with other databases
+    # * nowait will raise an exception if the lock can not be acquired
+    # * we are using a double check lock pattern to reduce lock acquisition
+    with_lock('for update nowait') do
+      reload
+      remind! if should_remind?
+    end if should_remind?
+  rescue
+    nil
+  end
+
+  private
+
+  def cycles_since(time)
+    ((Date.current - time.to_date) / self.class.reminder_frequency).to_i
+  end
+
+  def reminder_due?
+    last_reminded_date.nil? || cycles_since(last_reminded_date) >= 1
+  end
+
+  def can_still_remind?(date)
+    cycles_since(date).between?(1, 3)
+  end
+
+  def has_no_submissions?
+    last_submission_date.nil? && can_still_remind?(created_at)
+  end
+
+  def has_no_recent_submission?
+    !last_submission_date.nil? && can_still_remind?(last_submission_date)
+  end
+
+  module ClassMethods
+    def remindable
+      where('accepts_reminders  and email is not null
+                                and last_organization_id is not null
+                                and (last_submission_date < ? or last_submission_date is null)', reminder_frequency.days.ago)
+    end
+
+    # The frequency of reminders, expressed in days
+    def reminder_frequency
+      Rails.configuration.reminder_frequency
+    end
+  end
+end

data/app/models/concerns/with_scoped_queries/filter.rb

@@ -0,0 +1,15 @@
+module WithScopedQueries::Filter
+  def self.query_by(params, current_scope, _)
+    params.to_h.inject(current_scope) do |scope, (field, value)|
+      if value.present?
+        scope.public_send("by_#{field}", value)
+      else
+        scope
+      end
+    end
+  end
+
+  def self.add_queriable_attributes_to(klass, attributes)
+    klass.queriable_attributes.merge!(filter: attributes)
+  end
+end