mumuki-laboratory 7.3.0 → 7.5.0

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/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.current}.merge(body))
+  end
+
+  def has_messages?
+    messages.exists?
+  end
+
+  def pending_messages?
+    messages.exists? read: false
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/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/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/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/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/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/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/app/models/concerns/with_progress.rb

@@ -0,0 +1,27 @@
+module WithProgress
+  def progress_for(user, organization)
+    Indicator.find_or_initialize_by(user: user, organization: organization, content: self)
+  end
+
+  def completion_percentage_for(user, organization=Organization.current)
+    progress_for(user, organization).completion_percentage
+  end
+
+  def dirty_progresses!
+    Indicator.dirty_by_content_change! self
+  end
+
+  def dirty_progress_if_structural_children_changed!
+    old_structural_children = structural_children.to_a
+    yield
+    Indicator.dirty_by_content_change! self if structural_children_changed?(old_structural_children)
+
+    self
+  end
+
+  private
+
+  def structural_children_changed?(old_structural_children)
+    (Set.new(structural_children) ^ Set.new(old_structural_children)).present?
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/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/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/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/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/app/models/concerns/with_scoped_queries.rb

@@ -0,0 +1,47 @@
+module WithScopedQueries
+  extend ActiveSupport::Concern
+
+  SCOPING_METHODS = [Filter, Sort, Page]
+
+  included do
+    class_attribute :queriable_attributes, instance_writer: false
+    self.queriable_attributes = {}
+
+    SCOPING_METHODS.each do |mod|
+      define_singleton_method "#{mod.name.demodulize.underscore}able" do |*attributes|
+        include mod
+        mod.add_queriable_attributes_to(self, attributes)
+      end
+    end
+  end
+
+  class_methods do
+    def query_methods
+      queriable_attributes.keys
+    end
+
+    def scoped_query_module(method)
+      "WithScopedQueries::#{method.to_s.camelcase}".constantize
+    end
+
+    def permitted_query_params
+      queriable_attributes.values.flatten
+    end
+
+    def actual_params(params, excluded_param)
+      params.reject { |it| it == excluded_param.to_s }
+    end
+
+    def scoped_query_by(params, excluded_param=nil)
+      query_methods.inject(all) do |scope, method|
+        valid_params = valid_params_for(method, params, excluded_param)
+        scoped_query_module(method).query_by valid_params, scope, self
+      end
+    end
+
+    def valid_params_for(method, params, excluded_param)
+      actual_params = actual_params(params, excluded_param)
+      actual_params.permit queriable_attributes[method]
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/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

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/app/models/concerns/with_scoped_queries/page.rb

@@ -0,0 +1,10 @@
+module WithScopedQueries::Page
+  def self.query_by(params, current_scope, _)
+    page_param = params[:page] || 1
+    current_scope.page(page_param)
+  end
+
+  def self.add_queriable_attributes_to(klass, _)
+    klass.queriable_attributes.merge!(page: :page)
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/app/models/concerns/with_scoped_queries/sort.rb

@@ -0,0 +1,47 @@
+module WithScopedQueries::Sort
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :sorting_fields, :default_sorting_field, instance_writer: false
+  end
+
+  def self.query_by(params, scope, klass)
+    sort_param = params[:sort] || klass.default_sorting_field.to_s
+    normalized_params = normalize_params(sort_param)
+    if sort_param.present? && klass.sorting_params_allowed?(*normalized_params)
+      sort_method_for(klass, scope, *normalized_params)
+    else
+      scope
+    end
+  end
+
+  def self.normalize_params(param)
+    param&.split(/_(?!.*_)/)
+  end
+
+  def self.add_queriable_attributes_to(klass, attributes)
+    klass.default_sorting_field = attributes.extract_options![:default]
+    klass.sorting_fields = attributes
+    klass.queriable_attributes.merge!(sort: :sort)
+  end
+
+  def self.sort_method_for(klass, scope, field, direction)
+    if klass.column_names.include? field
+      scope.public_send(:reorder, "#{klass.table_name}.#{field} #{direction}")
+    else
+      scope.public_send("order_by_#{field}", direction)
+    end
+  end
+
+  class_methods do
+    def sorting_filters
+      sorting_fields.product([:asc, :desc]).map do |it|
+        "#{it.first}_#{it.second}"
+      end
+    end
+
+    def sorting_params_allowed?(sort_param, direction_param=nil)
+      sorting_fields.include?(sort_param.to_sym) && [:asc, :desc].include?(direction_param&.to_sym)
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/app/models/concerns/with_slug.rb

@@ -0,0 +1,61 @@
+#TODO may use mumukit slug
+module WithSlug
+  extend ActiveSupport::Concern
+
+  included do
+    validates_presence_of :slug
+    validates_uniqueness_of :slug
+    before_create :normalize_slug!
+  end
+
+  def transparent_params
+    org, repo = slug.split('/')
+    {organization: org, repository: repo}
+  end
+
+  def transparent_id
+    slug
+  end
+
+  def normalize_slug!
+    self.slug = self.slug.to_mumukit_slug.normalize.to_s
+  end
+
+  ## Copy and Rebase
+
+  def rebase!(organization)
+    self.slug = self.slug.to_mumukit_slug.rebase(organization).to_s
+  end
+
+  def rebased_dup(organization)
+    dup.tap { |it| it.rebase! organization }
+  end
+
+  ## Filtering
+
+  class_methods do
+
+    def allowed(permissions)
+      all.select { |it| permissions&.writer?(it.slug) }
+    end
+
+    def visible(permissions)
+      # FIXME no truly generic
+      all.select { |it| !it.private? || permissions&.writer?(it.slug) }
+    end
+
+    def find_transparently!(args)
+      find_by!(slug: "#{args[:organization]}/#{args[:repository]}")
+    end
+
+    ## Resource Protocol
+
+    def sync_key_id_field
+      :slug
+    end
+
+    def locate_resource(key)
+      find_or_initialize_by(slug: key)
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/app/models/concerns/with_usages.rb

@@ -0,0 +1,42 @@
+module WithUsages
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :usages, as: :item
+    before_destroy :ensure_unused!
+    organic_on :usages
+  end
+
+  def usage_in_organization(organization = Organization.current)
+    usages_in_organization(organization).first.try(:parent_item)
+  end
+
+  def usage_in_organization_of_type(type, organization = Organization.current)
+    item = usage_in_organization(organization)
+    item.is_a?(type) ? item : nil
+  end
+
+  class_methods do
+    def aggregate_of(association)
+      super
+
+      revamp "rebuild_#{association}!" do |_, this, children, hyper|
+        old_children = this.send association
+        added_children = children - old_children
+        hyper.(children)
+        this.usages.each { |it| it.index_children!(added_children) }
+
+        this
+      end
+    end
+  end
+
+  private
+
+  def ensure_unused!
+    if usages.present?
+      errors.add :base, :in_use, organization: usages.first.organization.name
+      throw :abort
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/app/models/concerns/with_user_navigation.rb

@@ -0,0 +1,9 @@
+module WithUserNavigation
+  def navigable_name
+    name
+  end
+
+  def navigation_end?
+    true
+  end
+end