269 lines
9.6 KiB
Ruby
269 lines
9.6 KiB
Ruby
namespace :oneoff do
|
|
task build_trackable_usages: :environment do
|
|
build_trackable_usages
|
|
end
|
|
def build_trackable_usages
|
|
TrackableUsage.delete_all
|
|
User.all.each do |user|
|
|
Rails.logger.info("[#{__method__}] === #{user.email} ===")
|
|
user.checkins.each do |checkin|
|
|
Rails.logger.info("[#{__method__}] --- #{checkin.date.strftime("%Y-%m-%d")} ---")
|
|
Rails.logger.info("[#{__method__}] --- Conditions ---")
|
|
checkin.conditions.each do |condition|
|
|
trackable = Condition.find(condition.condition_id)
|
|
usage = TrackableUsage.create_or_update_by(user: user, trackable: trackable)
|
|
Rails.logger.info("[#{__method__}] - #{trackable.name}: #{usage.count}")
|
|
end
|
|
Rails.logger.info("[#{__method__}] --- Symptoms ---")
|
|
checkin.symptoms.each do |symptom|
|
|
trackable = Symptom.find(symptom.symptom_id)
|
|
usage = TrackableUsage.create_or_update_by(user: user, trackable: trackable)
|
|
Rails.logger.info("[#{__method__}] - #{trackable.name}: #{usage.count}")
|
|
end
|
|
Rails.logger.info("[#{__method__}] --- Treatments ---")
|
|
checkin.treatments.each do |treatment|
|
|
trackable = Treatment.find(treatment.treatment_id)
|
|
usage = TrackableUsage.create_or_update_by(user: user, trackable: trackable)
|
|
Rails.logger.info("[#{__method__}] - #{trackable.name}: #{usage.count}")
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
task fix_trackable_colors: :environment do
|
|
fix_trackable_colors
|
|
end
|
|
# FIXME
|
|
# rubocop:disable Metrics/AbcSize
|
|
def fix_trackable_colors
|
|
colors = (0..32).to_a
|
|
User.all.each do |user|
|
|
Rails.logger.info("[#{__method__}] === #{user.email} ===")
|
|
colors_hash = {}
|
|
user.checkins.each do |checkin|
|
|
Rails.logger.info("[#{__method__}] --- #{checkin.date.strftime("%Y-%m-%d")} ---")
|
|
used_colors = []
|
|
fix_and_store_color_id = lambda do |checkin_trackable, trackable_type|
|
|
trackable_id = checkin_trackable.send("#{trackable_type.downcase}_id")
|
|
key = "#{trackable_type}-#{trackable_id}"
|
|
if colors_hash[key].present?
|
|
checkin_trackable.update!(color_id: colors_hash[key])
|
|
else
|
|
if checkin_trackable.color_id.nil?
|
|
trackable = trackable_type.constantize.find(trackable_id)
|
|
checkin_trackable.color_id = Flaredown::Colorable.color_id_for(trackable, user)
|
|
end
|
|
if used_colors.include?(checkin_trackable.color_id)
|
|
checkin_trackable.color_id = if used_colors.count >= colors.count
|
|
used_colors.count % colors.count
|
|
else
|
|
(colors - used_colors).sample
|
|
end
|
|
end
|
|
checkin_trackable.save!
|
|
colors_hash[key] = checkin_trackable.color_id
|
|
used_colors << checkin_trackable.color_id
|
|
end
|
|
end
|
|
Rails.logger.info("[#{__method__}] --- Conditions ---")
|
|
checkin.conditions.each do |condition|
|
|
fix_and_store_color_id.call(condition, "Condition")
|
|
end
|
|
Rails.logger.info("[#{__method__}] --- Symptoms ---")
|
|
checkin.symptoms.each do |symptom|
|
|
fix_and_store_color_id.call(symptom, "Symptom")
|
|
end
|
|
Rails.logger.info("[#{__method__}] --- Treatments ---")
|
|
checkin.treatments.each do |treatment|
|
|
fix_and_store_color_id.call(treatment, "Treatment")
|
|
end
|
|
end
|
|
user.trackings.active_at(Time.now).each do |tracking|
|
|
key = "#{tracking.trackable_type.downcase}-#{tracking.trackable_id}"
|
|
tracking.update!(color_id: colors_hash[key]) if colors_hash[key].present?
|
|
end
|
|
Rails.logger.info("[#{__method__}] Colors: #{colors_hash}")
|
|
end
|
|
end
|
|
# rubocop:enable Metrics/AbcSize
|
|
|
|
task generate_screen_names: :environment do
|
|
generate_screen_names
|
|
end
|
|
def generate_screen_names
|
|
Profile.all.each do |profile|
|
|
if profile.screen_name.blank?
|
|
generated_screen_name = profile.user.email.split("@")[0]
|
|
profile.update!(screen_name: generated_screen_name)
|
|
end
|
|
end
|
|
end
|
|
|
|
task remove_checkin_trackable_duplicates: :environment do
|
|
remove_checkin_trackable_duplicates
|
|
end
|
|
def remove_checkin_trackable_duplicates
|
|
[Checkin::Condition, Checkin::Symptom, Checkin::Treatment].each do |c|
|
|
c.all.each do |trackable|
|
|
key = "#{c.name.demodulize.downcase}_id"
|
|
count = c.where(
|
|
:checkin => trackable.checkin,
|
|
key.to_sym => trackable.send(key)
|
|
).count
|
|
trackable.destroy if count > 1
|
|
end
|
|
end
|
|
end
|
|
|
|
task generate_trackable_positions: :environment do
|
|
Checkin.all.each do |checkin|
|
|
checkin.conditions.sort_by { |t| t.position.to_i }
|
|
.each_with_index do |condition, i|
|
|
condition.update!(position: i)
|
|
end
|
|
checkin.symptoms.sort_by { |t| t.position.to_i }
|
|
.each_with_index do |symptom, i|
|
|
symptom.update!(position: i)
|
|
end
|
|
checkin.treatments.sort_by { |t| t.position.to_i }
|
|
.each_with_index do |treatment, i|
|
|
treatment.update!(position: i)
|
|
end
|
|
end
|
|
end
|
|
|
|
task save_most_recent_trackables_positions: :environment do
|
|
Profile.update_all(
|
|
most_recent_conditions_positions: {},
|
|
most_recent_symptoms_positions: {},
|
|
most_recent_treatments_positions: {}
|
|
)
|
|
User.all.each do |user|
|
|
latest_checkin = user.checkins.min(date: -1)
|
|
next if latest_checkin.nil?
|
|
latest_checkin.conditions.each_with_index do |cc, i|
|
|
condition = Condition.find(cc.condition_id)
|
|
user.profile.set_most_recent_condition_position(condition, cc.position || i)
|
|
end
|
|
latest_checkin.symptoms.each_with_index do |cs, i|
|
|
symptom = Symptom.find(cs.symptom_id)
|
|
user.profile.set_most_recent_symptom_position(symptom, cs.position || i)
|
|
end
|
|
latest_checkin.treatments.each_with_index do |ct, i|
|
|
treatment = Treatment.find(ct.treatment_id)
|
|
user.profile.set_most_recent_treatment_position(treatment, ct.position || i)
|
|
end
|
|
user.profile.save!
|
|
end
|
|
end
|
|
|
|
task update_last_commented_for_posts: :environment do
|
|
Post.where(_type: "Post").each do |post|
|
|
post.update(last_commented: post.created_at)
|
|
end
|
|
end
|
|
|
|
task add_position_reference_to_checkins_and_weathers: :environment do
|
|
add_position_reference_to_checkins
|
|
add_position_reference_to_weathers
|
|
end
|
|
|
|
def add_position_reference_to_checkins
|
|
Checkin.all.each do |checkin|
|
|
postal_code = checkin.postal_code
|
|
next if postal_code.nil? || postal_code.blank?
|
|
|
|
PositionReferenceJob.perform_async("Checkin", checkin.id.to_s, postal_code)
|
|
end
|
|
end
|
|
|
|
def add_position_reference_to_weathers
|
|
Weather.find_each(batch_size: 500) do |weather|
|
|
postal_code = weather.postal_code
|
|
next if postal_code.nil? || postal_code.blank?
|
|
|
|
PositionReferenceJob.perform_async("Weather", weather.id, postal_code)
|
|
end
|
|
end
|
|
|
|
task :send_optional_email, [:email] => :environment do |t, args|
|
|
email = args[:email]
|
|
abort("Email should be present") unless email
|
|
|
|
CheckinReminderMailer.remind(email: email).deliver_now
|
|
end
|
|
|
|
task :send_top_post_email, [:email] => :environment do |t, args|
|
|
notify_token = User.find_by(email: args[:email])&.profile&.notify_token
|
|
abort("There is no such email") if notify_token.nil?
|
|
|
|
GroupTopPostsJob.perform_async(notify_token)
|
|
end
|
|
|
|
# Send email with posts, comments, reactions count
|
|
task :send_notification_email, [:email] => :environment do |t, args|
|
|
email = args[:email]
|
|
abort("Email should be present") unless email
|
|
|
|
NotificationsMailer.notify(email: email, data: {}).deliver_now
|
|
end
|
|
|
|
# Send email with statistic about Promotion Rate for given time
|
|
# end_promotion_rate_statistic['email@ex.com','17-09-2017','22-09-2017']
|
|
task :send_promotion_rate_statistic, [:email, :start_time, :end_time] => :environment do |t, args|
|
|
email = args[:email]
|
|
start_time = args[:start_time]
|
|
end_time = args[:end_time]
|
|
|
|
objects = PromotionRate.group_by_score_and_date(start_time, end_time)
|
|
|
|
PromotionRate::StatisticMailer.show(email, objects.to_a, start_time, end_time).deliver_later
|
|
end
|
|
|
|
# send_promotion_rate_low_rate['email@ex.com','17-09-2017','22-09-2017']
|
|
task :send_promotion_rate_low_rate, [:email, :start_time, :end_time] => :environment do |t, args|
|
|
email = args[:email]
|
|
start_time = args[:start_time]
|
|
end_time = args[:end_time]
|
|
|
|
objects = PromotionRate.filter_low_scores_by_date(start_time, end_time)
|
|
serialized_objects = objects.to_a.map { |obj| obj.each_with_object({}) { |(k, v), h| h[k] = v.to_s; } }
|
|
|
|
PromotionRate::LowRateMailer.show(email, serialized_objects.to_a, start_time, end_time).deliver_later
|
|
end
|
|
|
|
task :update_checkin_reminder, ["profile_id"] => :environment do |t, args|
|
|
profile_id = args[:profile_id]
|
|
|
|
abort UpdateCheckinReminders.perform_async(profile_id) if profile_id
|
|
|
|
Profile.where(checkin_reminder: true).find_each do |profile|
|
|
UpdateCheckinReminders.perform_async(profile.id)
|
|
end
|
|
end
|
|
|
|
# remove_users_by_email['email1 email2']
|
|
task :remove_users_by_email, ["email_list"] => :environment do |t, args|
|
|
email_string = args["email_list"]
|
|
abort if email_string.blank?
|
|
|
|
email_array = email_string.split(" ")
|
|
email_array.each do |email|
|
|
user = User.find_by(email: email)
|
|
next if user.blank?
|
|
|
|
remove_user(user, email)
|
|
end
|
|
end
|
|
|
|
def remove_user(user, email)
|
|
ActiveRecord::Base.transaction do
|
|
user.profile&.destroy!
|
|
user.checkins.or({:postal_code.ne => nil}, :position_id.ne => nil)
|
|
&.update_all(postal_code: nil, position_id: nil)
|
|
|
|
user.destroy!
|
|
end
|
|
end
|
|
end
|