zydronium/internetee-registry
1
0
Fork 0
mirror of https://github.com/internetee/registry.git synced 2025-07-27 21:16:12 +02:00
Code Issues Projects Releases Packages Wiki Activity

Added indexes to log_domains table

Browse source
This commit is contained in:
Sergei Tsoganov 2022-12-07 11:21:30 +02:00
parent 10fb39980b
commit a682681625
7 changed files with 364 additions and 107 deletions
Download patch file Download diff file Expand all files Collapse all files

159
app/controllers/repp/v1/stats_controller.rb
View file

@ -1,68 +1,16 @@
module Repp
module V1
class StatsController < BaseController
class StatsController < BaseController # rubocop:disable Metrics/ClassLength
before_action :set_date_params
api :get, '/repp/v1/stats/market_share_distribution'
desc 'Get market share and distribution of registrars'
param :q, Hash, required: true, desc: 'Period parameters for data' do
param :end_date, String, required: true, desc: 'Period end date'
end
def market_share_distribution
date_to = to_date(search_params[:end_date]).end_of_month
date_from = to_date(search_params[:start_date] || '01.05')
log_domains_del = ::Version::DomainVersion.where(event: 'destroy')
.where('created_at > ?', date_to)
.where("object ->> 'created_at' <= ?", date_to)
.where("object ->> 'created_at' >= ?", date_from)
.select("DISTINCT ON (object ->> 'name') object, created_at")
.order(Arel.sql("object ->> 'name', created_at desc"))
# p "log_domains_del"
# log_domains_del.each do |d|
# p d.attributes
# end
# log_domains_del_grouped = log_domains_del.group("object ->> 'registrar_id'").count
log_domains_del_grouped = log_domains_del.group_by { |ld| ld.object['registrar_id'].to_s }
.transform_values(&:count)
# p log_domains_del_grouped
log_domains_trans = ::Version::DomainVersion.where(event: 'update')
.where('created_at > ?', date_to)
.where("object ->> 'created_at' <= ?", date_to)
.where("object ->> 'created_at' >= ?", date_from)
.where("object_changes ->> 'registrar_id' IS NOT NULL")
.select("DISTINCT ON (object ->> 'name') object, created_at")
.order(Arel.sql("object ->> 'name', created_at desc"))
# p "log_domains_trans"
# p log_domains_trans.map{|d| [d.object['name'], d.created_at] }
log_domains_trans_grouped = log_domains_trans.group_by { |ld| ld.object['registrar_id'].to_s }
.transform_values(&:count)
# p log_domains_trans_grouped
updated = log_domains_trans.map { |ld| ld.object['name'] } + log_domains_del.map { |ld| ld.object['name'] }
domains = ::Domain.where('created_at <= ? AND created_at >= ?', date_to, date_from)
.where.not(name: updated.uniq)
domains_grouped = domains.group(:registrar_id).count.stringify_keys
# p "domains"
# p domains_grouped
grouped = summarize([log_domains_del_grouped, log_domains_trans_grouped, domains_grouped])
registrar_names = ::Registrar.where(test_registrar: false)
.map { |r| { "#{r.id}": r.name }.with_indifferent_access }
.inject(:merge)
result = grouped.map do |key, value|
next unless registrar_names.key?(key)
name = registrar_names[key]
hash = { name: registrar_names[key], y: value }
hash.merge!({ sliced: true, selected: true }) if current_user.registrar.name == name
hash
end
# p result
domains_by_rar = domains_by_registrar(@date_to, @date_from)
result = serialize_distribution_result(domains_by_rar)
render_success(data: result)
end
@ -71,25 +19,23 @@ module Repp
desc 'Get market share and growth rate of registrars'
param :q, Hash, required: true, desc: 'Period parameters for data' do
param :end_date, String, required: true, desc: 'Period end date'
param :compare_to_date, String, required: true, desc: 'Comparison date'
param :compare_to_end_date, String, required: true, desc: 'Comparison date'
end
def market_share_growth_rate
registrars = ::Registrar.where(test_registrar: false).joins(:domains)
domains_by_rar = registrars.where(from_condition).where(to_condition).group(:name).count
prev_domains_by_rar = registrars.where(compare_to_condition).group(:name).count
domains_by_rar = domains_by_registrar(@date_to, @date_from)
prev_domains_by_rar = domains_by_registrar(@date_compare_to, @date_compare_from)
set_zero_values!(domains_by_rar, prev_domains_by_rar)
market_share_by_rar = calculate_market_share(domains_by_rar)
prev_market_share_by_rar = calculate_market_share(prev_domains_by_rar)
result = { prev_data: { name: search_params[:compare_to_date],
domains: serialize(prev_domains_by_rar),
market_share: serialize(prev_market_share_by_rar) },
result = { prev_data: { name: search_params[:compare_to_end_date],
domains: serialize_growth_rate_result(prev_domains_by_rar),
market_share: serialize_growth_rate_result(prev_market_share_by_rar) },
data: { name: search_params[:end_date],
domains: serialize(domains_by_rar),
market_share: serialize(market_share_by_rar) } }
domains: serialize_growth_rate_result(domains_by_rar),
market_share: serialize_growth_rate_result(market_share_by_rar) } }
render_success(data: result)
end
# rubocop:enable Metrics/MethodLength
@ -97,26 +43,15 @@ module Repp
private
def search_params
params.permit(:q, q: %i[start_date end_date compare_to_date])
params.permit(:q, q: %i[start_date end_date compare_to_end_date compare_to_start_date])
.fetch(:q, {}) || {}
end
def from_condition
return unless search_params[:start_date]
"domains.created_at >= '#{to_date(search_params[:start_date])}'"
end
def to_condition
return unless search_params[:end_date]
"domains.created_at <= '#{to_date(search_params[:end_date]).end_of_month}'"
end
def compare_to_condition
return unless search_params[:compare_to_date]
"domains.created_at <= '#{to_date(search_params[:compare_to_date]).end_of_month}'"
def set_date_params
@date_to = to_date(search_params[:end_date]).end_of_month
@date_from = to_date(search_params[:start_date] || '01.05')
@date_compare_to = to_date(search_params[:compare_to_end_date]).end_of_month
@date_compare_from = to_date(search_params[:compare_to_start_date] || '01.05')
end
def to_date(date_param)
@ -125,10 +60,6 @@ module Repp
Date.strptime(date_param, '%m.%y')
end
def serialize(rars)
rars.map { |key, value| [key, value] }
end
def set_zero_values!(cur, prev)
cur_dup = cur.dup
cur_dup.each_key do |k|
@ -147,9 +78,61 @@ module Repp
end
end
def domains_by_registrar(date_to, date_from)
log_domains_del = log_domains(event: 'destroy', date_to: date_to, date_from: date_from)
log_domains_trans = log_domains(event: 'update', date_to: date_to, date_from: date_from)
logged_domains = log_domains_trans.map { |ld| ld.object['name'] } +
log_domains_del.map { |ld| ld.object['name'] }
domains_grouped = ::Domain.where('created_at <= ? AND created_at >= ?', date_to, date_from)
.where.not(name: logged_domains.uniq)
.group(:registrar_id).count.stringify_keys
summarize([group(log_domains_del), group(log_domains_trans), domains_grouped])
end
def summarize(arr)
arr.inject { |memo, el| memo.merge(el) { |_, old_v, new_v| old_v + new_v } }
end
def log_domains(event:, date_to:, date_from:)
domains = ::Version::DomainVersion.where(event: event)
domains.where!("object_changes ->> 'registrar_id' IS NOT NULL") if event == 'update'
domains.where('created_at > ?', date_to)
.where("object ->> 'created_at' <= ?", date_to)
.where("object ->> 'created_at' >= ?", date_from)
.select("DISTINCT ON (object ->> 'name') object, created_at")
.order(Arel.sql("object ->> 'name', created_at desc"))
end
def group(domains)
domains.group_by { |ld| ld.object['registrar_id'].to_s }
.transform_values(&:count)
end
def registrar_names
@registrar_names ||= ::Registrar.where(test_registrar: false)
.map { |r| { "#{r.id}": r.name }.with_indifferent_access }
.inject(:merge)
end
def serialize_distribution_result(grouped)
grouped.map do |key, value|
next unless registrar_names.key?(key)
name = registrar_names[key]
hash = { name: registrar_names[key], y: value }
hash.merge!({ sliced: true, selected: true }) if current_user.registrar.name == name
hash
end
end
def serialize_growth_rate_result(grouped)
grouped.map do |key, value|
next unless registrar_names.key?(key)
name = registrar_names[key]
[name, value]
end
end
end
end
end