Save user metrics in db

.gitignore

@@ -63,3 +63,4 @@
 # End of https://www.toptal.com/developers/gitignore/api/visualstudiocode,rails
 
 .DS_Store
+.idea/

app/helpers/metrics_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module MetricsHelper
+end

app/models/friend.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Friend < ApplicationRecord
+  has_many :relationships
+  has_many :users, through: :relationships
+
+  validates :first_name, presence: true
+  validates :last_name, presence: true
+  validates :vk_uid, presence: true, uniqueness: true
+end

app/models/metric.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Metric < ApplicationRecord
+  belongs_to :user
+end

app/models/post.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Post < ApplicationRecord
+  belongs_to :user
+
+  validates :vk_uid, presence: true, uniqueness: true
+end

app/models/relationship.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Relationship < ApplicationRecord
+  belongs_to :user
+  belongs_to :friend
+
+  validates :active, inclusion: { in: [true, false] }
+end

app/models/user.rb

@@ -6,14 +6,54 @@ class User < ApplicationRecord
   devise :database_authenticatable, :registerable,
          :recoverable, :rememberable, :validatable
 
-  # include UserConcern
-
-  def self.from_omniauth(auth)
-    where(provider: auth.provider, uid: auth.uid).first_or_create do |user|
-      # Если Instagram не предоставляет email, вы можете использовать другой уникальный идентификатор
-      user.email = auth.info.email || "#{auth.uid}@instagram.com"
-      user.password = Devise.friendly_token[0, 20]
-      user.name = auth.info.name # assuming the user model has a name
+  has_one :metric, dependent: :destroy
+
+  has_many :posts
+  has_many :relationships
+  has_many :friends, through: :relationships
+
+  has_many :active_relationships, -> { where active: true }, class_name: 'Relationship'
+  has_many :inactive_relationships, -> { where active: false }, class_name: 'Relationship'
+
+  has_many :active_friends, through: :active_relationships, class_name: 'Friend', source: :friend
+  has_many :inactive_friends, through: :inactive_relationships, class_name: 'Friend', source: :friend
+
+  after_create :create_metric
+
+  def create_metric
+    Metric.create(user: self)
+  end
+
+  def total_likes
+    posts.sum do |post|
+      post.likes.size
+    end
+  end
+
+  def total_comments
+    posts.sum do |post|
+      post.comments.size
     end
   end
+
+  def set_active(value, friends)
+    relationships.where(friend: friends).update_all(active: value)
+  end
+
+  def update_metrics
+    MetricsCalculator.call(self)
+  end
+
+  def update_metrics_needed?
+    metrics_fields = %i[
+      average_likes target_likes average_comments target_comments
+      comments_likes_ratio target_comments_likes_ratio audience_score
+      average_engagement_score
+    ]
+
+    metrics_have_nil = metrics_fields.map { |field| metric[field].nil? }.any?
+    post_metrics_have_nil = posts.map { |post| post.engagement_score.nil? }.any?
+
+    metrics_have_nil || post_metrics_have_nil
+  end
 end

app/services/metrics_calculator.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+# Contains logic for calculating user metrics
+class MetricsCalculator
+  class << self
+    def call(user)
+      metric = user.metric
+
+      active_friends, inactive_friends = active_friends(user)
+      user.set_active(true, active_friends)
+      user.set_active(false, inactive_friends)
+
+      metric.average_likes = average_likes(user)
+      metric.target_likes = target_likes(user)
+
+      metric.average_comments = average_comments(user)
+      metric.target_comments = target_comments(user)
+
+      metric.comments_likes_ratio = comments_likes_ratio(user)
+      metric.target_comments_likes_ratio = target_comments_likes_ratio(user)
+
+      metric.average_engagement_score = average_engagement_score(user)
+      metric.audience_score = audience_score(user)
+
+      metric.save
+    end
+
+    private
+
+    # Computes set of active and inactive friends' vk uids
+    # based on activity (likes and comments) on posts
+    def active_friends(user)
+      vk_uids = user.posts.flat_map do |post|
+        post.likes + post.comments
+      end.uniq
+
+      active_users = user.friends.where(vk_uid: vk_uids).to_set
+      friends = user.friends.to_set
+
+      active_friends = active_users & friends
+      inactive_friends = friends - active_friends
+      [active_friends, inactive_friends]
+    end
+
+    # Computes average number of likes per post
+    def average_likes(user)
+      return 0 if user.posts.empty?
+
+      (user.total_likes.to_f / user.posts.size).round
+    end
+
+    # Computes target number of likes based on `target_likes_ratio`
+    # Target number - theoretically possible with the current
+    # number of followers
+    def target_likes(user, target_likes_ratio: 0.3)
+      (user.friends.size * target_likes_ratio).round
+    end
+
+    # Computes average number of comments per post
+    def average_comments(user)
+      return 0 if user.posts.empty?
+
+      (user.total_comments.to_f / user.posts.size).round
+    end
+
+    # Computes target number of comments based on `target_comments_ratio`
+    # Target number - theoretically possible with the current
+    # number of followers
+    def target_comments(user, target_comments_ratio: 0.1)
+      (user.friends.size * target_comments_ratio).round
+    end
+
+    # Computes ratio of total comments to total likes
+    # in the form "comments:likes"
+    def comments_likes_ratio(user)
+      common_divisor = user.total_comments.gcd(user.total_likes)
+      return '0:0' if common_divisor.zero?
+
+      "#{user.total_comments / common_divisor}:#{user.total_likes / common_divisor}"
+    end
+
+    # Computes target ratio of total comments to total likes
+    # in the form "comments:likes"
+    # Target number - theoretically possible with the current
+    # number of followers
+    def target_comments_likes_ratio(
+      user,
+      target_likes_ratio: 0.3,
+      target_comments_ratio: 0.1
+    )
+      target_comments = (user.total_comments * target_comments_ratio).round
+      target_likes = (user.total_likes * target_likes_ratio).round
+
+      common_divisor = target_comments.gcd(target_likes)
+      return '0:0' if common_divisor.zero?
+
+      "#{target_comments / common_divisor}:#{target_likes / common_divisor}"
+    end
+
+    # Calculates engagement score for a single post
+    # Engagement score - average activity shown by each user
+    def engagement_score(post, engagement_score_factor: 1000)
+      return 0 if post.user.friends.empty?
+
+      ((post.likes.size + post.comments.size).to_f / post.user.friends.size * engagement_score_factor).round
+    end
+
+    # Computes average engagement score of posts
+    def average_engagement_score(user)
+      return 0 if user.posts.empty?
+
+      user.posts.each do |post|
+        post.engagement_score = engagement_score(post)
+        post.save
+      end
+
+      total_engagement_score = user.posts.sum(&:engagement_score)
+      (total_engagement_score / user.posts.size).round
+    end
+
+    # Computes audience score based on the ratio of active friends
+    # to total friends
+    # The score is scaled to a range of 0.0 to 10.0
+    def audience_score(user)
+      return 0.0 if user.friends.empty?
+
+      (user.active_relationships.count.to_f / user.friends.size * 10).round(1)
+    end
+  end
+end