cnfs-cognito 0.0.1.alpha1

data/app/operations/segments/age.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Segments
+  class Age < Ros::ActivityBase
+    step :init
+    step :verify_segment
+    failed :incorrect_segment, Output(:success) => End(:failure)
+    step :translate_segment
+    step :apply_segment
+    failed :segment_not_applied, Output(:success) => End(:failure)
+
+    private
+
+    def init(ctx, segment:, **)
+      ctx[:segment] = Array.wrap(segment)
+      ctx[:translated_segments] = []
+    end
+
+    def verify_segment(_ctx, segment:, **)
+      segment.all? { |s| segment_element_valid?(s) }
+    end
+
+    def incorrect_segment(_ctx, errors:, segment:, **)
+      errors.add(:segment, "Incorrect age segment value: #{segment}")
+    end
+
+    def translate_segment(_ctx, segment:, translated_segments:, **)
+      segment.each do |element|
+        translated_segments << case element
+                               when Hash
+                                 el = element.with_indifferent_access
+                                 date_range(el['from'], el['to'])
+                               when String, Integer
+                                 date_range(element, element)
+                               end
+      end
+    end
+
+    def apply_segment(ctx, users:, translated_segments:, **)
+      ctx[:model] = users.where(birthday: translated_segments)
+    end
+
+    def segment_not_applied(_ctx, errors:, segment:, **)
+      errors.add(:model, "can't apply age segment: #{segment}")
+    end
+
+    def segment_element_valid?(element)
+      case element
+      when Hash
+        element.with_indifferent_access.keys.sort == %w[from to] && element.values.all? { |el| el.to_s.match(/^\d+$/) }
+      when String, Integer
+        element.to_s.match(/^\d+$/)
+      else
+        false
+      end
+    end
+
+    def date_range(from, to, base_date = Time.zone.today)
+      Range.new(
+        base_date - to.to_i.years - 1.year + 1.day,
+        base_date - from.to_i.years
+      )
+    end
+  end
+end

data/app/operations/segments/birthday.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Segments
+  class Birthday < Ros::ActivityBase
+    step :init
+    step :verify_segment
+    failed :incorrect_segment, Output(:success) => End(:failure)
+    step :apply_segment
+    failed :segment_not_applied, Output(:success) => End(:failure)
+
+    private
+
+    def init(ctx, segment:, **)
+      if segment.match(/^\d{2}$/)
+        ctx[:date] = Date.strptime(segment, '%m')
+        ctx[:segment] = 'this_month'
+      elsif segment.match(/^\d{2}-\d{2}$/)
+        ctx[:date] = Date.strptime(segment, '%m-%d')
+        ctx[:segment] = 'this_day'
+      else
+        ctx[:date] = Time.zone.today
+      end
+    end
+
+    def verify_segment(_ctx, segment:, **)
+      %w[this_day this_month].include?(segment)
+    end
+
+    def incorrect_segment(_ctx, errors:, segment:, **)
+      errors.add(:segment, "Incorrect birthday segment value: #{segment}")
+    end
+
+    def apply_segment(ctx, users:, segment:, date:, **)
+      ctx[:model] = send(segment, users, date)
+    end
+
+    def segment_not_applied(_ctx, errors:, segment:, **)
+      errors.add(:model, "Can't apply birthday segment: #{segment}")
+    end
+
+    def this_day(users, date)
+      users.where("TO_CHAR(birthday, 'DD-MM') = TO_CHAR(DATE(?), 'DD-MM')", date)
+    end
+
+    def this_month(users, date)
+      users.where("TO_CHAR(birthday, 'MM') = TO_CHAR(DATE(?), 'MM')", date)
+    end
+  end
+end

data/app/operations/segments/except_ids.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Segments
+  class ExceptIds < Ros::ActivityBase
+    step :verify_segment
+    failed :incorrect_segment, Output(:success) => End(:failure)
+    step :apply_segment
+    failed :segment_not_applied
+
+    private
+
+    def verify_segment(_ctx, segment:, **)
+      segment.is_a?(Array)
+    end
+
+    def incorrect_segment(_ctx, errors:, segment:, **)
+      errors.add(:segment, "Incorrect except ids segment value: #{segment}")
+    end
+
+    def apply_segment(ctx, users:, segment:, **)
+      ctx[:model] = users.where.not(id: segment)
+    end
+
+    def segment_not_applied(_ctx, errors:, segment:, **)
+      errors.add(:model, "Can't apply except ids segment: #{segment}")
+    end
+  end
+end

data/app/operations/segments/gender.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Segments
+  class Gender < Ros::ActivityBase
+    step :verify_segment
+    failed :incorrect_segment, Output(:success) => End(:failure)
+    step :apply_segment
+    failed :segment_not_applied, Output(:success) => End(:failure)
+
+    private
+
+    def verify_segment(_ctx, segment:, **)
+      case segment
+      when Array
+        (segment - %w[male female other]).empty?
+      when String
+        %w[male female other any].include?(segment)
+      else
+        false
+      end
+    end
+
+    def incorrect_segment(_ctx, errors:, segment:, **)
+      errors.add(:segment, "Incorrect gender segment value: #{segment}")
+    end
+
+    def apply_segment(ctx, users:, segment:, **)
+      ctx[:model] = segment == 'any' ? users : users.where(gender: segment)
+    end
+
+    def segment_not_applied(_ctx, errors:, segment:, **)
+      errors.add(:model, "Can't apply gender segment: #{segment}")
+    end
+  end
+end

data/app/operations/segments_apply.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class SegmentsApply < Ros::ActivityBase
+  step :init
+  step :apply_segments
+  failed :unset_model
+
+  private
+
+  def init(ctx, users:, **)
+    ctx[:model] = users
+  end
+
+  def apply_segments(ctx, model:, segments:, errors:, **)
+    segments.each do |segment_key, segment_value|
+      res = apply_segment(segment_key, segment_value, model, errors)
+      return false if res.nil?
+
+      if res.failure?
+        ctx[:errors] = res.errors
+        return false
+      end
+
+      model = res.model
+    end
+    ctx[:model] = model
+  end
+
+  def apply_segment(segment_key, segment_value, users, errors)
+    segment_class = "Segments::#{segment_key.classify}".constantize
+    segment_class.call(users: users, segment: segment_value)
+  rescue NameError => _e
+    errors.add(:segment, "can't find segmentation class")
+    nil
+  end
+
+  def unset_model(ctx, **)
+    ctx[:model] = nil
+  end
+end

data/app/policies/chown_request_policy.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class ChownRequestPolicy < Cognito::ApplicationPolicy
+end

data/app/policies/chown_result_policy.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class ChownResultPolicy < Cognito::ApplicationPolicy
+end

data/app/policies/cognito/application_policy.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Cognito
+  class ApplicationPolicy < ::ApplicationPolicy
+  end
+end

data/app/policies/endpoint_policy.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class EndpointPolicy < Cognito::ApplicationPolicy
+end

data/app/policies/identifier_policy.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class IdentifierPolicy < Cognito::ApplicationPolicy
+end

data/app/policies/metabase_card_policy.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class MetabaseCardPolicy < Cognito::ApplicationPolicy
+end

data/app/policies/pool_policy.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class PoolPolicy < Cognito::ApplicationPolicy
+end

data/app/policies/tenant_policy.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class TenantPolicy < Cognito::ApplicationPolicy
+  include Ros::TenantPolicyConcern
+end

data/app/policies/user_policy.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class UserPolicy < Cognito::ApplicationPolicy
+  class Scope
+    attr_reader :user, :scope
+
+    def initialize(user, scope)
+      @user  = user
+      @scope = scope
+    end
+
+    def resolve
+      if user.cognito_user_id
+        scope.where(id: user.cognito_user_id)
+      else
+        scope.all
+      end
+    end
+  end
+end

data/app/resources/chown_request_resource.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ChownRequestResource < Cognito::ApplicationResource
+  attributes :from_ids, :to_id
+end

data/app/resources/chown_result_resource.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class ChownResultResource < Cognito::ApplicationResource
+  attributes :from_id, :to_id, :status, :service_name, :chown_request_id
+  has_one :chown_request
+
+  filters :from_id, :to_id, :status
+end

data/app/resources/cognito/application_resource.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Cognito
+  class ApplicationResource < ::ApplicationResource
+    abstract
+  end
+end

data/app/resources/endpoint_resource.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class EndpointResource < Cognito::ApplicationResource
+  attributes :url, :properties, :target_type, :target_id
+
+  filters :target_type, :target_id
+  filter :url
+
+  def custom_links(options)
+    uri = URI(options[:serializer].link_builder.self_link(self))
+    { target: target_uri(uri) }
+  end
+
+  def target_uri(uri)
+    return '' unless @model.target_type
+
+    service, model = @model.target_type.underscore.split('/')
+    case Settings.external_connection.type
+    when 'service'
+      uri.host = uri.host.gsub(Settings.service.name, service)
+      uri.path = ['', model, @model.target_id].join('/')
+    when 'path'
+      uri.path = ['', service, model, @model.target_id].join('/')
+    when 'port'
+      # TODO: Test for whether service_endpoint is nil
+      uri.port = URI(Ros::Sdk.service_endpoints[service]).port
+    when 'host'
+      uri.host = URI(Ros::Sdk.service_endpoints[service]).host
+    end
+    uri.to_s
+  end
+
+  def fetchable_fields
+    super - [:urn]
+  end
+
+  # def self.updatable_fields(context)
+  #   super - [:full_name]
+  # end
+
+  # def self.creatable_fields(context)
+  #   super - [:full_name]
+  # end
+  # def resource; [@model.target_type.underscore.split('/').last, @model.target_id].join('/') end
+
+  # def self.sortable_fields(context)
+  #   super(context) - [:body]
+  # end
+end

data/app/resources/identifier_resource.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class IdentifierResource < Cognito::ApplicationResource
+  attributes :name, :value, :properties
+  has_one :user
+end

data/app/resources/metabase_card_resource.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class MetabaseCardResource < Cognito::ApplicationResource
+  attributes :card_id, :identifier
+end

data/app/resources/pool_resource.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class PoolResource < Cognito::ApplicationResource
+  attributes :name, :properties, :user_count, :system_generated
+  has_many :users
+
+  filter :query, apply: lambda { |records, value, _options|
+    query_by_id = 'pools.id IN (:id_query)'
+    query_by_non_id_attrs = %w[name]
+                            .map { |field| "#{field} ILIKE :ilike_query" }
+                            .join(' OR ')
+
+    filter_fields = /^\d+$/.match?(value[0]) ? query_by_id : query_by_non_id_attrs
+    records.where(filter_fields, id_query: value[0], ilike_query: "%#{value[0]}%")
+  }
+
+  filter :system_generated
+
+  def self.updatable_fields(context)
+    super - %i[user_count]
+  end
+
+  def self.creatable_fields(context)
+    super - %i[user_count]
+  end
+
+  def user_count
+    users.size
+  end
+end

data/app/resources/user_resource.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class UserResource < Cognito::ApplicationResource
+  attributes :title, :first_name, :last_name, :phone_number, :email_address,
+             :primary_identifier, :properties, :anonymous, :birthday, :gender
+  filter :primary_identifier
+
+  filter :query, apply: lambda { |records, value, _options|
+    searchable_columns = ['primary_identifier', 'first_name', 'last_name', 'phone_number', 'email_address',
+                          "first_name || ' ' || last_name", "last_name || ' ' || first_name"]
+    query_by_non_id_attrs = searchable_columns.map { |field| "#{field} ILIKE :non_id_query" }.join(' OR ')
+
+    results = records.where(query_by_non_id_attrs, non_id_query: "%#{value[0]}%")
+    results = results.or(records.where(id: value[0])) if /^(\d)+$/.match?(value[0])
+    results
+  }
+
+  filter :segments, apply: lambda { |records, value, _options|
+    SegmentsApply.call(users: records, segments: value[0].permit!.to_h).model
+  }
+
+  filter :pool_id, apply: lambda { |records, value, _options|
+    records.joins(:pools).where(pools: { id: value })
+  }
+
+  has_many :pools
+end