ish_models 0.0.33.304 → 3.1.0.0

data/lib/ish/user_profile.rb

@@ -1,146 +0,0 @@
-
-require 'ish/utils'
-require 'mongoid/votable'
-
-##
-## It explicitly doesn't have a relation to user! Use email as key.
-##
-class Ish::UserProfile
-  include Mongoid::Document
-  include Mongoid::Timestamps
-  include Mongoid::Voter
-  include Ish::Utils
-
-  store_in collection: 'ish_user_profiles'
-
-  field :email
-  validates_format_of :email,:with => /\A[^@\s]+@([^@\s]+\.)+[^@\s]+\z/
-  validates_uniqueness_of :email
-
-  field :name
-
-  def export_fields
-    %w|
-      email
-      role_name
-    |
-  end
-
-  field :scratchpad, default: ''
-
-  field :fb_access_token
-  field :fb_long_access_token
-  field :fb_expires_in
-
-  field :lang, default: 'en'
-  field :leadset_id, type: Integer
-  def organization_name
-    'Some Org'
-    # ::Leadset.find( leadset_id )&.name || 'Some Org'
-  end
-  # def leadset
-  #   ::Leadset.find( leadset_id )
-  # end
-  # @TODO: change _vp_ 2023-08-21
-  def next_serverhost
-    Wco::Serverhost.where({ leadset_id: leadset_id }).first
-  end
-
-  ROLE_GUY     = :guy
-  ROLE_MANAGER = :manager
-  ROLE_ADMIN   = :admin
-  ROLES        = [ :guy, :manager, :admin ]
-  field :role_name, :type => Symbol, default: :guy
-
-  has_one  :profile_photo,                   inverse_of: :profile_city,    class_name: 'Photo'
-  has_many :galleries,                       inverse_of: :user_profile
-  has_and_belongs_to_many :shared_galleries, inverse_of: :shared_profiles, class_name: 'Gallery'
-  has_and_belongs_to_many :shared_markers,   inverse_of: :shared_profiles, class_name: 'Gameui::Marker'
-  has_and_belongs_to_many :shared_locations, inverse_of: :shared_profiles, class_name: 'Gameui::Map'
-  has_and_belongs_to_many :shared_reports,   inverse_of: :shared_profiles, class_name: '::Report'
-  has_and_belongs_to_many :shared_videos,    inverse_of: :shared_profiles, class_name: '::Video'
-  has_many :my_markers,                      inverse_of: :creator_profile, class_name: 'Gameui::Marker'
-  has_many :my_locations,                    inverse_of: :creator_profile, class_name: 'Gameui::Map'
-  has_many :invoices,                                                      class_name: '::Ish::Invoice'
-  has_many :photos
-  has_many :reports,                         inverse_of: :user_profile
-  has_many :videos,                          inverse_of: :user_profile
-  has_many :newsitems,                       inverse_of: :profile
-  has_and_belongs_to_many :friends,   :class_name => '::Ish::UserProfile', inverse_of: :friendeds
-  has_and_belongs_to_many :friendeds, :class_name => '::Ish::UserProfile', inverse_of: :friends
-
-  def sudoer?
-    %w( piousbox@gmail.com victor@wasya.co ).include?( self.email )
-  end
-
-  def self.list
-    out = self.all
-    [['', nil]] + out.map { |item| [ item.email, item.id ] }
-  end
-  def self.list_lg
-    out = self.all
-    [['', nil]] + out.map { |item| [ "#{item.email} :: #{item.name}", item.id ] }
-  end
-
-  field :n_unlocks, type: Integer, default: 0
-
-  has_many :payments, :class_name => '::Ish::Payment'
-  has_many :subscriptions, class_name: 'Wco::Subscription', inverse_of: :profile
-
-  def has_premium_purchase item
-    payments.confirmed.where( item: item ).exists?
-  end
-
-  field :is_purchasing, type: Boolean, default: false
-
-  field :customer_id # stripe
-
-  def customer_id
-    if !self[:customer_id]
-      # return nil if !email
-      existing = Stripe::Customer.search({ query: "email: '#{email}'" })
-      # puts! existing, 'existing'
-      if existing.data.present?
-        update_attributes( customer_id: existing.data[0][:id] )
-      else
-        customer = Stripe::Customer.create({ email: email })
-        # puts! customer, 'customer'
-        update_attributes( customer_id: customer[:id] )
-      end
-    end
-    self[:customer_id]
-  end
-
-  # used in rake tasks
-  def self.generate delta
-    email = delta[:email]
-    password = delta[:password]
-    role_name = delta[:role_name]
-
-    profile = Ish::UserProfile.where( email: email ).first
-    if profile
-      return
-    end
-
-    user = User.where( email: email ).first
-    if !user
-      user = User.new({ email: email, password: password })
-    end
-    profile = Ish::UserProfile.new({
-      email: email,
-      role_name: role_name,
-    })
-    profile.save
-
-    if profile.persisted?
-      ;
-    else
-      puts! profile.errors.full_messages, "Cannot save profile"
-    end
-  end
-
-  field :per_page, type: Integer, default: 100
-
-end
-
-Profile = Ish::UserProfile

data/lib/ish/utils.rb

@@ -1,45 +0,0 @@
-
-module Ish::Utils
-
-  def export
-    out = {}
-    %w| created_at updated_at |.map do |f|
-      out[f] = send(f)
-    end
-    export_fields.map do |field|
-      if field[-3..-1] == '_id'
-        out[field] = send(field).to_s
-      else
-        out[field] = send(field)
-      end
-    end
-    out[:_id] = id.to_s
-    out.with_indifferent_access
-  end
-
-  private
-
-  def set_slug
-    return if slug
-    if name
-      new_slug = name.downcase.gsub(/[^a-z0-9\s]/i, '').gsub(' ', '-')
-    else
-      new_slug = '1'
-    end
-    if self.class.where( slug: new_slug ).first
-      loop do
-        if new_slug[new_slug.length-1].to_i != 0
-          # inrement last digit
-          last_digit = new_slug[new_slug.length-1].to_i
-          new_slug = "#{new_slug[0...new_slug.length-1]}#{last_digit+1}"
-        else
-          # add '-1' to the end
-          new_slug = "#{new_slug}-1"
-        end
-        break if !self.class.where( slug: new_slug ).first
-      end
-    end
-    self.slug = new_slug
-  end
-
-end

data/lib/mongoid/votable.rb

@@ -1,247 +0,0 @@
-module Mongoid
-  module Votable
-    extend ActiveSupport::Concern
-
-    # How many points should be assigned for each up or down vote.
-    # This array should be manipulated using Votable.vote_point method
-    VOTE_POINT = {}
-
-    included do
-      field :votable, type: Hash
-
-      index({ "votable.votes_count" => 1 })
-      index({ "votable.votes_point" => 1 })
-
-      scope :most_voted, -> { order_by(["votable.votes_count", :desc]) }
-      scope :best_voted, -> { order_by(["votable.votes_point", :desc]) }
-
-      # Set vote point for each up (down) vote on an object of this class
-      def self.vote_point(klass = self, options = nil)
-        VOTE_POINT[self.name] ||= {}
-        VOTE_POINT[self.name][klass.name] ||= options
-      end
-
-      #
-      # We usually need to show current_user his voting value on votable object
-      # voting value can be nil (not voted yet), :up or :down
-      # from voting value, we can decide it should be new vote or revote with :up or :down
-      # In this case, validation can be skip to maximize performance
-      #
-      # Make a vote on an object of this class
-      #
-      # @param [Hash] options a hash containings:
-      #   - :votee_id: the votee document id
-      #   - :voter_id: the voter document id
-      #   - :value: :up or :down
-      #   - :revote: change from vote up to vote down
-      #   - :unvote: unvote the vote value (:up or :down)
-      #
-      def self.vote(options)
-        options.symbolize_keys!
-        value = options[:value]
-        votee_id = options[:votee_id]
-        voter_id = options[:voter_id]
-
-        klass = options[:class]
-        klass ||= VOTE_POINT.keys.include?(name) ? name : collection.name.classify
-        value_point = VOTE_POINT[klass][klass]
-
-        if options[:revote]
-          if value == :up
-            positive_field = :up_voter_ids
-            negative_field = :down_voter_ids
-            point_delta = value_point[:up] - value_point[:down]
-          else
-            positive_field = :down_voter_ids
-            negative_field = :up_voter_ids
-            point_delta = -value_point[:up] + value_point[:down]
-          end
-
-          update_result = collection.update_one({
-            # Validate voter_id did a vote with value for votee_id
-            :_id => votee_id,
-            "votable.#{positive_field.to_s}" => { '$ne' => voter_id },
-            "votable.#{negative_field.to_s}" => voter_id
-          }, {
-            # then update
-            '$pull' => { "votable.#{negative_field.to_s}" => voter_id },
-            '$push' => { "votable.#{positive_field.to_s}" => voter_id },
-            '$inc' => {
-              "votable.votes_point" => point_delta
-            }
-          }, {
-            :safe => true
-          })
-
-        elsif options[:unvote]
-          if value == :down
-            positive_field = :down_voter_ids
-            negative_field = :up_voter_ids
-          else
-            positive_field = :up_voter_ids
-            negative_field = :down_voter_ids
-          end
-
-          # Check if voter_id did a vote with value for votee_id
-          update_result = collection.update_one({
-            # Validate voter_id did a vote with value for votee_id
-            :_id => votee_id,
-            "votable.#{negative_field.to_s}" => { '$ne' => voter_id },
-            "votable.#{positive_field.to_s}" => voter_id
-          }, {
-            # then update
-            '$pull' => { "votable.#{positive_field.to_s}" => voter_id },
-            '$inc' => {
-              "votable.votes_count" => -1,
-              "votable.votes_point" => -value_point[value]
-            }
-          }, {
-            :safe => true
-          })
-
-        else # new vote
-          if value == :up
-            positive_field = :up_voter_ids
-          else
-            positive_field = :down_voter_ids
-          end
-
-          update_result = collection.update_one({
-            # Validate voter_id did not vote for votee_id yet
-            :_id => votee_id,
-            "votable.up_voter_ids" => { '$ne' => voter_id },
-            "votable.down_voter_ids" => { '$ne' => voter_id }
-          }, {
-            # then update
-            '$push' => { "votable.#{positive_field.to_s}" => voter_id },
-            '$inc' => {
-              "votable.votes_count" => +1,
-              "votable.votes_point" => value_point[value] }
-          }, {
-            :safe => true
-          })
-        end
-
-        # Only update parent class if votee is updated successfully
-        success = ( update_result.documents[0]['err'] == nil and
-          update_result.documents[0]['nModified'] == 1 and
-          update_result.documents[0]['n'] == 1 )
-
-        if success
-          VOTE_POINT[klass].each do |class_name, value_point|
-            # For other class in VOTE_POINT options, if is parent of current class
-            next unless relation_metadata = relations[class_name.underscore]
-            votee ||= options[:votee] || find(options[:votee_id])
-            # If can find current votee foreign_key value for that class
-            next unless foreign_key_value = votee.read_attribute(relation_metadata.foreign_key.to_sym)
-
-            # Update that class / collection
-            inc_options = if options[:revote]
-              {
-                "votable.votes_point" => ( value == :up ?
-                   value_point[:up] - value_point[:down] :
-                  -value_point[:up] + value_point[:down] )
-              }
-            elsif options[:unvote]
-              {
-                "votable.votes_count" => value_point[:not_increase_votes_count] ? 0 : -1,
-                "votable.votes_point" => -value_point[value]
-              }
-            else
-              {
-                "votable.votes_count" => value_point[:not_increase_votes_count] ? 0 : 1,
-                "votable.votes_point" => value_point[value]
-              }
-            end
-
-            class_name.constantize.collection.update_one(
-              { :_id => foreign_key_value },
-              { '$inc' =>  inc_options }
-            )
-          end
-        end
-
-        success
-      end
-
-    end
-
-    # Make a vote on this votee
-    #
-    # @param [Hash] options a hash containings:
-    #   - :voter_id: the voter document id
-    #   - :value: vote :up or vote :down
-    def vote(options)
-      options[:votee_id] ||= _id
-      options[:votee] ||= self
-
-      if options[:unvote]
-        options[:value] ||= vote_value(options[:voter_id])
-      else
-        options[:revote] ||= !vote_value(options[:voter_id]).nil?
-      end
-
-      self.class.vote(options)
-    end
-
-    # Get a voted value on this votee
-    #
-    # Let's NOT CONVERT bson::objectid's to strings. _vp_ 2022-08-31
-    #
-    # @param [Mongoid Object, BSON::ObjectId] voter is Mongoid object the id of the voter who made the vote
-    def vote_value(voter)
-      ## The last last one, voter.id not voter.id.to_s _vp_ 2022-09-19
-      voter_id = voter.is_a?(BSON::ObjectId) ? voter : voter.is_a?(String) ? voter : voter.id
-
-      return :up if up_voter_ids.try(:include?, voter_id)
-      return :down if down_voter_ids.try(:include?, voter_id)
-    end
-
-    # Get the number of up votes
-    def up_votes_count
-      up_voter_ids.length
-    end
-
-    # Get the number of down votes
-    def down_votes_count
-      down_voter_ids.length
-    end
-
-    # Get the number of votes count
-    def votes_count
-      if self.has_attribute?(:votable)
-        self["votable"]["votes_count"]
-      else
-        0
-      end
-    end
-
-    # Get the votes point
-    def votes_point
-      if self.has_attribute?(:votable)
-        self["votable"]["votes_point"]
-      else
-        0
-      end
-    end
-    alias :votes_score :votes_point
-
-    # Array of up voter ids
-    def up_voter_ids
-      if self.has_attribute?(:votable)
-        self['votable']["up_voter_ids"]
-      else
-        []
-      end
-    end
-
-    # Array of down voter ids
-    def down_voter_ids
-      if self.has_attribute?(:votable)
-        self["votable"]["down_voter_ids"]
-      else
-        []
-      end
-    end
-  end
-end

data/lib/mongoid/voter.rb

@@ -1,96 +0,0 @@
-module Mongoid
-  module Voter
-    extend ActiveSupport::Concern
-
-    # Get list of voted votees
-    #
-    # @param [Class] klass the votee class, e.g. `Post` or `Comment`
-    # @return [Array, nil] an array of votable objects voted by this voter
-    def votees(klass)
-      # Is this id, or id.to_s ?
-      # let's not convert to string, lets use bson::objectid.
-      # _vp_ 2022-08-31
-      klass.any_of({ "votable.up_voter_ids" => _id }, { "votable.down_voter_ids" => _id })
-    end
-
-    # Check to see if this voter voted on the votee or not
-    #
-    # @param [Hash, Object] options the hash containing the votee, or the votee itself
-    # @return [true, false] true if voted, false otherwise
-    def voted?(options)
-      unless options.is_a?(Hash)
-        votee_class = options.class
-        votee_id = options._id
-      else
-        votee = options[:votee]
-        if votee
-          votee_class = votee.class
-          votee_id = votee._id
-        else
-          votee_class = options[:votee_type].classify.constantize
-          votee_id = options[:votee_id]
-        end
-      end
-
-      votees(votee_class).where(:_id => votee_id).count == 1
-    end
-
-    # Get the voted value on a votee
-    #
-    # @param (see #voted?)
-    # @return [Symbol, nil] :up or :down or nil if not voted
-    def vote_value(options)
-      votee = unless options.is_a?(Hash)
-        options
-      else
-        options[:votee] || options[:votee_type].classify.constantize.only(:up_vote_ids, :down_vote_ids).where(
-          :_id => options[:votee_id]
-        ).first
-      end
-      votee.vote_value(_id)
-    end
-
-    # Cancel the vote on a votee
-    #
-    # @param [Object] votee the votee to be unvoted
-    def unvote(options)
-      unless options.is_a?(Hash)
-        options = { :votee => options }
-      end
-      options[:unvote] = true
-      options[:revote] = false
-      vote(options)
-    end
-
-    # Vote on a votee
-    #
-    # @param (see #voted?)
-    # @param [:up, :down] vote_value vote up or vote down, nil to unvote
-    def vote(options, value = nil)
-      if options.is_a?(Hash)
-        votee = options[:votee]
-      else
-        votee = options
-        options = { :votee => votee, :value => value }
-      end
-
-      if votee
-        options[:votee_id] = votee._id
-        votee_class = votee.class
-      else
-        votee_class = options[:votee_type].classify.constantize
-      end
-
-      if options[:value].nil?
-        options[:unvote] = true
-        options[:value] = vote_value(options)
-      else
-        options[:revote] = options.has_key?(:revote) ? !options[:revote].blank? : voted?(options)
-      end
-
-      options[:voter_id] = _id
-
-      ( votee || votee_class ).vote(options)
-    end
-  end
-end

data/lib/newsitem.rb

@@ -1,94 +0,0 @@
-
-require 'ish/utils'
-
-# require_relative './mongoid/votable.rb'
-
-class Newsitem
-  include Mongoid::Document
-  include Mongoid::Timestamps
-  include Ish::Utils
-
-  include Mongoid::Votable
-  vote_point self, :up => +1, :down => -1
-
-  belongs_to :gallery, optional: true  # seems correct. _vp_ 2022-03-21
-  def gallery
-    self.gallery_id ? Gallery.unscoped.find( self.gallery_id ) : nil
-  end
-  belongs_to :map,     optional: true, class_name: '::Gameui::Map'
-  belongs_to :profile, optional: true, class_name: '::Ish::UserProfile'
-  belongs_to :photo,   optional: true
-  belongs_to :report,  optional: true
-  belongs_to :video,   optional: true
-
-  field :name
-  field :descr
-  def description; descr; end
-  field :subhead
-
-  field :weight,           :type => Integer, :default => 10
-  field :n_upvotes,        :type => Integer, :default => 0
-  field :n_downvotes,      :type => Integer, :default => 0
-  field :upvoting_users,   :type => Array, :default => []
-  field :downvoting_users, :type => Array, :default => []
-
-  field :image_path # @deprecated ?
-  field :link_path  # @deprecated ?
-  field :iframe_src
-
-  ## This is used.
-  TYPE_GALLERY = :type_gallery
-  TYPE_PHOTO   = :type_photo
-  TYPE_REPORT  = :type_report
-  TYPE_VIDEO   = :type_video
-  def item_type
-    return TYPE_GALLERY if gallery_id
-    return TYPE_PHOTO   if photo_id
-    return TYPE_REPORT  if report_id
-    return TYPE_VIDEO   if video_id
-  end
-
-  default_scope ->{ order_by({ :created_at => :desc }) }
-
-  def self.from_params item
-    n = Newsitem.new
-    n.descr = item[:descr]
-    n.username = item[:username]
-
-    unless item[:report_id].blank?
-      n.report = Report.find item[:report_id]
-    end
-
-    unless item[:gallery_id].blank?
-      n.gallery = Gallery.find item[:gallery_id]
-    end
-
-    n.partial_name = item.partial_name unless item.partial_name.blank?
-
-    return n
-  end
-
-  def export_fields
-    %w|
-      descr
-      name
-
-      image_path
-      link_path
-
-      map_id
-      gallery_id
-      photo_id
-      report_id
-      video_id
-    |
-  end
-
-  def collect export_object
-    export_object[:galleries][gallery.id.to_s] = gallery.id.to_s if gallery
-    export_object[:photos][photo.id.to_s] = photo.id.to_s if photo
-    export_object[:reports][report.id.to_s] = report.id.to_s if report
-    export_object[:videos][video.id.to_s] = video.id.to_s if video
-  end
-
-end

data/lib/office/action.rb

@@ -1,32 +0,0 @@
-
-##
-## 2023-09-13 _vp_ I don't know if it's even used.
-##
-class Office::Action
-  include Mongoid::Document
-  include Mongoid::Timestamps
-  store_in collection: 'office_actions'
-
-  field     :slug, type: :string
-  validates :slug, uniqueness: true, allow_nil: true
-
-  field :descr, type: :string ## optional
-
-
-  STATE_ACTIVE   = 'active'
-  STATE_INACTIVE = 'inactive'
-  STATES         = [ STATE_ACTIVE, STATE_INACTIVE ]
-  field :state, type: :string
-  scope :active, ->{ where( state: STATE_ACTIVE ) }
-
-
-  has_many :ties,      class_name: '::Office::ActionTie', inverse_of: :office_action
-  has_many :prev_ties, class_name: '::Office::ActionTie', inverse_of: :next_office_action
-  accepts_nested_attributes_for :ties
-
-  field :action_exe, type: :string
-
-  field :perform_at, type: :time
-
-end
-OAct = Office::Action

data/lib/office/action_tie.rb

@@ -1,16 +0,0 @@
-
-class Office::ActionTie
-  include Mongoid::Document
-  include Mongoid::Timestamps
-  store_in collection: 'office_action_ties'
-
-  attr_accessor :to_delete
-
-  belongs_to :office_action,      class_name: '::Office::Action', inverse_of: :ties
-  belongs_to :next_office_action, class_name: '::Office::Action', inverse_of: :prev_ties
-
-  field :next_at_exe,     type: :string
-  validates :next_at_exe, presence: true
-
-end
-OActie = Office::ActionTie