fluke/devops-service/db/mongo/models/mongo_model.rb

require "providers/provider_factory"
require "exceptions/invalid_record"
require "json"
require 'db/validators/all'

module Devops
  module Model
    class MongoModel

      # multi_json sends argument to 'to_json' method
      def to_json arg=nil
        JSON.pretty_generate self.to_hash
      end

      def to_hash
        h = to_hash_without_id
        h["id"] = self.id
        h
      end

      def to_mongo_hash
        h = to_hash_without_id
        h["_id"] = self.id
        h
      end

      def is_empty? val
        val.nil? or val.strip.empty?
      end

      def check_string! val
        raise ArgumentError unless val.is_a?(String)
        val.strip!
        raise ArgumentError if val.empty?
      end

      def check_array! val, type, empty=false
        raise ArgumentError unless val.is_a?(Array)
        raise ArgumentError if !empty and val.empty?
        val.each do |v|
          raise ArgumentError unless v.is_a?(type)
        end
      end

      def check_name_value val
        raise ArgumentError.new "Invalid name, it should contains 0-9, a-z, A-Z, _, - symbols only" if val.match(/^[0-9a-zA-Z_\-]+$/).nil?
      end

      def check_provider provider=self.provider
        unless ::Provider::ProviderFactory.providers.include?(provider)
          raise InvalidRecord.new "Invalid provider '#{provider}'"
        end
      end

      def validate!
        begin
          self.validate_fields_types
          self.class.validate_model(self)
          true
        rescue InvalidRecord => e
          error_message = self.build_error_message(e.message)
          raise InvalidRecord.new(error_message)
        end
      end

      def build_error_message(message)
        # overrided in descendants
        message
      end

      # types - Hash
      #   key - param name
      #   value - Hash
      #     :type - param type
      #     :empty - can param be empty? (false)
      #     :nil - can param be nil? (false)
      #     :value_type - type of array element (String)
      def self.types types
        define_method :validate_fields_types do
          t = types.keys
          e = types.keys
          n = types.keys
          types.each do |name, value|
            if value[:nil]
              n.delete(name)
              if self.send(name).nil?
                e.delete(name)
                t.delete(name)
                next
              end
            else
              n.delete(name) unless self.send(name).nil?
            end
            if self.send(name).is_a? value[:type]
              t.delete(name)
              self.send(name).strip! if value[:type] == String
              if value[:type] == Array
                unless value[:value_type] == false
                  type = value[:value_type] || String
                  self.send(name).each do |e|
                    unless e.is_a?(type)
                      t.push(name)
                      break
                    end
                  end
                end
              end
              e.delete(name) if value[:empty] or !self.send(name).empty?
            end
          end
          raise InvalidRecord.new "Parameter(s) '#{n.join("', '")}' can not be undefined" unless n.empty?
          raise InvalidRecord.new "Parameter(s) '#{t.join("', '")}' have invalid type(s)" unless t.empty?
          raise InvalidRecord.new "Parameter(s) '#{e.join("', '")}' can not be empty" unless e.empty?
          if types.has_key? :provider
            self.send("check_provider")
          end
          true
        end
      end

      def self.validators
        @validators ||= []
      end

      # all exceptions are handled in @validate! method
      def self.validate_model(model)
        validators.each do |validator|
          validator.new(model).validate!
        end
      end

      # private class methods
      class << self

        private

        def set_validators(*validators_to_add)
          @validators ||= []
          @validators += validators_to_add
        end

        def unset_validators(*validators_to_remove)
          @validators ||= []
          self.validators -= validators_to_remove
        end

      end

    end
  end
end