flutter 0.1.0.pre.2 → 0.1.0.pre.3

data/integration_tests/minitest/grape_app/app/property/endpoint.rb

@@ -1,39 +0,0 @@
-require_relative './service'
-module Skee::App::Property
-  class Endpoint
-
-    ERRORS = Skee::App::Utils::Errors
-
-    def self.list
-      Service.list
-    end
-
-    def self.get(params)
-      Service.get(params)
-    end
-
-    def self.create(params)
-      Service.create(params)
-    rescue ERRORS::RecordNotFoundException,
-      ERRORS::NotAllowedToUpdate,
-      ERRORS::UniquenessViolationException => e
-      raise ERRORS::ValidationError.new(e.message)
-    end
-
-    def self.update(params)
-      Service.update(params)
-    rescue ERRORS::RecordNotFoundException,
-      ERRORS::NotAllowedToUpdate,
-      ERRORS::UniquenessViolationException => e
-      raise ERRORS::ValidationError.new(e.message)
-    end
-
-    def self.remove(params)
-      Service.remove(params)
-    rescue ERRORS::RecordNotFoundException,
-      ERRORS::NotAllowedToUpdate,
-      ERRORS::UniquenessViolationException => e
-      raise ERRORS::ValidationError.new(e.message)
-    end
-  end
-end

data/integration_tests/minitest/grape_app/app/property/service.rb

@@ -1,56 +0,0 @@
-require_relative '../../app/versioned_entity/service'
-module Skee
-  module App
-    module Property
-      class Service < Skee::App::VersionedEntityService
-        def self.entity
-          :property
-        end
-
-        def self.create_fields_keys
-          %i(
-            change_request_id
-            previous_snapshot_id
-            is_removed
-            name
-            property_of
-            description
-            is_nullable
-            data_type
-            additional_instructions
-            data_format_id
-            regex_validation
-          )
-        end
-
-        def self.update_fields_keys
-          %i(
-            change_request_id
-            is_removed
-            id
-            name
-            description
-            is_nullable
-            data_type
-            additional_instructions
-            data_format_id
-            regex_validation
-          )
-        end
-
-        def self.create(params)
-          new_property = super(params)
-          if params[:property_of] == :trackable_object
-            parent_reference_id = params[:parent_reference_id]
-            Skee::App::TrackableObject::Service.add_property(
-              change_request_id: params[:change_request_id],
-              id: parent_reference_id,
-              property_id: new_property.versioned_entity.id
-            )
-          end
-          new_property
-        end
-      end
-    end
-  end
-end

data/integration_tests/minitest/grape_app/app/trackable_object/endpoint.rb

@@ -1,38 +0,0 @@
-require_relative './service'
-module Skee::App::TrackableObject
-  class Endpoint
-    ERRORS = Skee::App::Utils::Errors
-
-    def self.list
-      Service.list
-    end
-
-    def self.get(params)
-      Service.get(params)
-    end
-
-    def self.create(params)
-      Service.create(params)
-    rescue ERRORS::RecordNotFoundException,
-      ERRORS::NotAllowedToUpdate,
-      ERRORS::UniquenessViolationException => e
-      raise ERRORS::ValidationError.new(e.message)
-    end
-
-    def self.update(params)
-      Service.update(params)
-    rescue ERRORS::RecordNotFoundException,
-      ERRORS::NotAllowedToUpdate,
-      ERRORS::UniquenessViolationException => e
-      raise ERRORS::ValidationError.new(e.message)
-    end
-
-    def self.remove(params)
-      Service.remove(params)
-    rescue ERRORS::RecordNotFoundException,
-      ERRORS::NotAllowedToUpdate,
-      ERRORS::UniquenessViolationException => e
-      raise ERRORS::ValidationError.new(e.message)
-    end
-  end
-end

data/integration_tests/minitest/grape_app/app/trackable_object/service.rb

@@ -1,49 +0,0 @@
-require_relative '../../app/versioned_entity/service'
-require_relative 'validator'
-module Skee
-  module App
-    module TrackableObject
-      class Service < Skee::App::VersionedEntityService
-        def self.entity
-          :trackable_object
-        end
-
-        def self.create_fields_keys
-          %i(
-            change_request_id
-            previous_snapshot_id
-            is_removed
-            name
-            property_ids
-          )
-        end
-
-        def self.update_fields_keys
-          %i(
-            change_request_id
-            is_removed
-            id
-            name
-            property_ids
-          )
-        end
-
-        def self.add_property(params)
-          Skee::App::TrackableObject::Validator.new(params).
-            validate_add_property
-          trackable_object = get(id: params[:id])
-          trackable_object_property_ids = trackable_object.versioned_entity_snapshot.property_ids
-          property_id = params[:property_id]
-
-          return if trackable_object_property_ids.include?(property_id)
-          update_property_ids = trackable_object_property_ids + [property_id]
-          update(
-            id: params[:id],
-            property_ids: update_property_ids,
-            change_request_id: params[:change_request_id]
-          )
-        end
-      end
-    end
-  end
-end

data/integration_tests/minitest/grape_app/app/trackable_object/validator.rb

@@ -1,40 +0,0 @@
-require_relative '../../app/change_request/service'
-require_relative '../../app/tracking_spec/service'
-module Skee
-  module App
-    module TrackableObject
-      class Validator
-        def initialize(params)
-          @params = params
-        end
-
-        ERRORS = Utils::Errors
-
-        def validate_add_property
-          validate_property_exists(@params[:property_id])
-        end
-
-        def validate_remove_property
-          validate_property_exists(@params[:property_id])
-          validate_property_belongs_to_trackable_object(@params[:property_id], @params[:id])
-        end
-
-        private
-
-        def validate_property_exists(property_id)
-          property_instance = Skee::App::DB_MAPPING_ENTITY[:property].find(property_id)
-          raise ERRORS::RecordNotFoundException.new('Resource not found') unless property_instance
-        end
-
-        def validate_property_belongs_to_trackable_object(property_id, trackable_object_id)
-          return if trackable_object(trackable_object_id).versioned_entity_snapshot.property_ids.include?(property_id)
-          raise ERRORS::NotAllowedToUpdate.new('Trackable object does not contain property.')
-        end
-
-        def trackable_object(trackable_object_id)
-          @trackable_object ||= Skee::App::TrackableObject::Service.get(id: trackable_object_id)
-        end
-      end
-    end
-  end
-end

data/integration_tests/minitest/grape_app/app/tracking_spec/endpoint.rb

@@ -1,58 +0,0 @@
-require_relative './service'
-require_relative './validator'
-require_relative './expand_tracking_spec_events'
-
-module Skee::App::TrackingSpec
-  class Endpoint
-    ERRORS = Skee::App::Utils::Errors
-
-    def self.list
-      Service.list
-    end
-
-    def self.get(params)
-      Service.get(params)
-    end
-
-    def self.full_spec(params)
-      Service.full_spec(params)
-    end
-
-    def self.create(params)
-      Service.create(params)
-    rescue ERRORS::RecordNotFoundException,
-      ERRORS::NotAllowedToUpdate => e
-      raise ERRORS::ValidationError.new(e.message)
-    end
-
-    def self.update(params)
-      Service.update(params)
-    rescue ERRORS::RecordNotFoundException,
-      ERRORS::NotAllowedToUpdate => e
-      raise ERRORS::ValidationError.new(e.message)
-    end
-
-    def self.delete(params)
-      Service.delete(params)
-    rescue ERRORS::RecordNotFoundException,
-      ERRORS::NotAllowedToUpdate => e
-      raise ERRORS::ValidationError.new(e.message)
-    end
-
-    def self.expand(params)
-      Skee::App::TrackingSpec::Validator.new(params).validate_expand_params
-      tracking_spec = Service.get(params)
-      expanded_events = ExpandTrackingSpecEvents.new(tracking_spec, params[:change_request_id]).perform
-      OpenStruct.new(
-        id: tracking_spec.id,
-        identifier: tracking_spec.identifier,
-        version: tracking_spec.version,
-        project_id: tracking_spec.project_id,
-        status: tracking_spec.status,
-        events: expanded_events
-      )
-    rescue ERRORS::RecordNotFoundException => e
-      raise ERRORS::ValidationError.new(e.message)
-    end
-  end
-end

data/integration_tests/minitest/grape_app/app/tracking_spec/expand_tracking_spec_events.rb

@@ -1,91 +0,0 @@
-require_relative '../../app/event/service'
-require_relative '../../app/property/service'
-
-module Skee::App::TrackingSpec
-  class ExpandTrackingSpecEvents
-    def initialize(tracking_spec, change_request_id)
-      @tracking_spec = tracking_spec
-      @change_request_id = change_request_id
-    end
-
-    def perform
-      expand_events
-    end
-
-    private
-
-    def event_snapshots
-      @tracking_spec.events.map do |event_id|
-        Skee::App::Event::Service.get(
-          id: event_id,
-          change_request_id: @change_request_id
-        ).versioned_entity_snapshot
-      end
-    end
-
-    def expand_events
-      event_snapshots.map do |snapshot|
-        event_payload = snapshot.payload
-        expanded_payload = event_payload.map do |key, value|
-          expanded_value = if value[:reference_entity_type] == :trackable_object
-            trackable_object_id = value[:reference_entity_id]
-            trackable_object_snapshot = get_trackable_object_snapshot(trackable_object_id)
-            property_ids = value[:selected_property_ids] & trackable_object_snapshot.property_ids
-            expand_trackable_object_properties(property_ids)
-          else
-            property_id = value[:reference_entity_id]
-            property_snapshot = get_property_snapshot(property_id)
-            expand_property(property_snapshot)
-          end
-          expanded_value = [expanqded_value] if value[:is_array]
-          [key, expanded_value]
-        end.to_h
-        {name: snapshot.name, description: snapshot.description, payload: expanded_payload}
-      end
-    end
-
-    def expand_trackable_object_properties(property_ids)
-      property_ids.map do |property_id|
-        property_snapshot = get_property_snapshot(property_id)
-        property_fields = expand_property(property_snapshot)
-
-        [property_snapshot.name, property_fields]
-      end.to_h
-
-    end
-
-    def expand_property(property_snapshot)
-      trackable_object_id = property_snapshot.trackable_object_id
-      if trackable_object_id
-        trackable_object_snapshot = get_trackable_object_snapshot(trackable_object_id)
-        property_ids = trackable_object_snapshot.property_ids
-        expanded_values = expand_trackable_object_properties(property_ids)
-        property_snapshot.is_array ? [expanded_values] : expanded_values
-      else
-        {
-          data_type: property_snapshot.data_type,
-          description: property_snapshot.description,
-          is_nullable: property_snapshot.is_nullable,
-          additional_instructions: property_snapshot.additional_instructions,
-          data_format_id: property_snapshot.data_format_id,
-          regex_validation: property_snapshot.regex_validation,
-          is_removed: property_snapshot.is_removed,
-        }
-      end
-    end
-
-    def get_trackable_object_snapshot(trackable_object_id)
-      Skee::App::TrackableObject::Service.get(
-        id: trackable_object_id,
-        change_request_id: @change_request_id
-      ).versioned_entity_snapshot
-    end
-
-    def get_property_snapshot(property_id)
-      Skee::App::Property::Service.get(
-        id: property_id,
-        change_request_id: @change_request_id
-      ).versioned_entity_snapshot
-    end
-  end
-end

data/integration_tests/minitest/grape_app/app/tracking_spec/service.rb

@@ -1,51 +0,0 @@
-require_relative '../../db/proto/tracking_spec'
-module Skee
-  module App
-    module TrackingSpec
-      class Service
-        DB = Skee::DB::Proto
-
-        def self.list
-          DB::TrackingSpec.all
-        end
-
-        def self.get(params)
-          DB::TrackingSpec.find(params[:id])
-        end
-
-        def self.find_by(params)
-          DB::TrackingSpec.where(params)
-        end
-
-        def self.create(params)
-          # add any validation or filtering logic here to
-          # derive fields from params
-          fields = {
-            version_identifier: params[:version_identifier],
-            change_request_id: params[:change_request_id],
-            project_id: params[:project_id],
-            event_ids: params[:event_ids]
-          }
-          DB::TrackingSpec.create(fields)
-        end
-
-        def self.update(params)
-          # send valid fields excluding id
-          fields = {
-            version_identifier: params[:version_identifier],
-            change_request_id: params[:change_request_id],
-            project_id: params[:project_id],
-            event_ids: params[:event_ids]
-          }
-          tracking_spec = DB::TrackingSpec.find(params[:id])
-          tracking_spec.update(fields)
-        end
-
-        def self.delete(params)
-          tracking_spec = DB::TrackingSpec.find(params[:id])
-          tracking_spec.delete
-        end
-      end
-    end
-  end
-end

data/integration_tests/minitest/grape_app/app/tracking_spec/validator.rb

@@ -1,61 +0,0 @@
-require_relative '../../app/change_request/service'
-module Skee
-  module App
-    module TrackingSpec
-      class Validator
-        def initialize(params)
-          @params = params
-        end
-
-        ERRORS = Utils::Errors
-
-        def validate_create_params
-          validate_unique_version_identifier
-          validate_event_ids_exist
-        end
-
-        def validate_update_params
-          validate_unique_version_identifier
-          validate_tracking_spec_exists
-          validate_event_ids_exist
-        end
-
-        def validate_expand_params
-          validate_change_request
-        end
-
-        private
-
-        def validate_unique_version_identifier
-          return unless @params[:version_identifier]
-          tracking_spec = Skee::App::TrackingSpec::Service.find_by(
-            version_identifier: @params[:version_identifier]
-          )
-          return unless tracking_spec
-          raise ERRORS::NotAllowedToUpdate.new('Invalid parameter: Version Identifier should be unique.')
-        end
-
-        def validate_tracking_spec_exists
-          tracking_spec = Skee::App::TrackingSpec::Service.get(id: @params[:id])
-          return if tracking_spec
-          raise ERRORS::RecordNotFoundException.new('Invalid parameter: Tracking spec does not exist')
-        end
-
-        def validate_event_ids_exist
-          return if @params[:event_ids].empty?
-          events = Skee::App::Event::Service.list(ids: @params[:event_ids])
-          return if (@params[:event_ids] - events.map(&:id)).empty?
-          raise ERRORS::NotAllowedToUpdate.new('Invalid parameter: Event IDs do not exist')
-        end
-
-        def validate_change_request
-          raise ERRORS::RecordNotFoundException.new('Invalid change request') unless change_request
-        end
-
-        def change_request
-          @change_request ||= Skee::App::ChangeRequest::Service.get(id: @params[:change_request_id])
-        end
-      end
-    end
-  end
-end

data/integration_tests/minitest/grape_app/app/utils/errors/api_exceptions.rb

@@ -1,10 +0,0 @@
-module Skee
-  module App
-    module Utils
-      module Errors
-        class ValidationError < StandardError;
-        end
-      end
-    end
-  end
-end

data/integration_tests/minitest/grape_app/app/utils/errors/service_exceptions.rb

@@ -1,12 +0,0 @@
-module Skee
-  module App
-    module Utils
-      module Errors
-        class UniquenessViolationException < StandardError; end
-        class RecordNotFoundException < StandardError; end
-        class NotAllowedToUpdate < StandardError; end
-        class NotAllowedToCancelChanges < StandardError; end
-      end
-    end
-  end
-end

data/integration_tests/minitest/grape_app/app/versioned_entity/entity.rb

@@ -1,110 +0,0 @@
-require_relative '../../app/change_request/service'
-module Skee
-  module App
-    module VersionedEntity
-      class Entity
-        def initialize(entity)
-          @entity = entity
-          @db = Skee::App::DB_MAPPING_ENTITY[@entity]
-        end
-
-        attr_accessor :versioned_entity, :versioned_entity_snapshot
-
-        def list(ids:, change_request_id:)
-          ids = @db.all.map(&:id) if ids.empty?
-          return_entities = ids.map{ |id| get({
-            id: id,
-            change_request_id: change_request_id
-            })
-          }
-        end
-
-        def get(params)
-          versioned_entity_id = params[:id]
-          versioned_entity = @db.find(versioned_entity_id)
-          if change_request = Skee::App::ChangeRequest::Service.get(id: params[:change_request_id])
-            if change_request.change_set[@entity][versioned_entity_id]
-              entity_snapshot_id = change_request.change_set[@entity][versioned_entity_id].values.first
-            else
-              entity_snapshot_id = versioned_entity.latest_snapshot_id
-            end
-          else
-            entity_snapshot_id = versioned_entity.latest_snapshot_id
-          end
-          entity_snapshot = Skee::App::VersionedEntitySnapshot::Entity.new(@entity).get(id: entity_snapshot_id)
-          self.versioned_entity = versioned_entity
-          self.versioned_entity_snapshot = entity_snapshot
-          self
-        end
-
-        def create(params)
-          versioned_entity_params = {
-            # may need to add more fields
-            # snapshot_mapping: {params[:change_request_id] => entity_snapshot.id
-          }
-          versioned_entity = @db.create(versioned_entity_params)
-          entity_snapshot_params = params.merge(parent_entity_id: versioned_entity.id)
-          entity_snapshot = Skee::App::VersionedEntitySnapshot::Entity.new(@entity).create(entity_snapshot_params)
-          update_change_request(params[:change_request_id], versioned_entity.id, nil, entity_snapshot.id)
-          self.versioned_entity = versioned_entity
-          self.versioned_entity_snapshot = entity_snapshot
-          self
-        end
-
-        def update(update_params)
-          versioned_entity_id = update_params[:id]
-          change_request = Skee::App::ChangeRequest::Service.get(id: update_params[:change_request_id])
-          change_request.change_set[@entity] ||= {}
-          entity_snapshot = if change_request.change_set[@entity][versioned_entity_id]
-            update_existing_snapshot(change_request, update_params) 
-          else
-            create_new_snapshot(update_params)
-          end
-          versioned_entity = @db.find(versioned_entity_id)
-          self.versioned_entity = versioned_entity
-          self.versioned_entity_snapshot = entity_snapshot
-          self
-        end
-
-        private
-
-        def update_existing_snapshot(change_request, update_params)
-          versioned_entity_id = update_params[:id]
-          entity_snapshot_id = change_request.change_set[@entity][versioned_entity_id].values.first
-          existing_entity_snapshot = Skee::App::VersionedEntitySnapshot::Entity.new(@entity).get(id: entity_snapshot_id)
-          update_params = update_params.select {|key, _| key != :id && key != "id"}
-          existing_entity_snapshot.update(update_params)
-        end
-
-        def create_new_snapshot(update_params)
-          versioned_entity_id = update_params[:id]
-          existing_entity = @db.find(versioned_entity_id)
-          entity_snapshot_id = existing_entity.latest_snapshot_id
-          current_entity_snapshot = Skee::App::VersionedEntitySnapshot::Entity.new(@entity).get(id: entity_snapshot_id)
-          current_entity_snapshot_params = current_entity_snapshot.to_h.select {|key, _| key != :id && key != "id"}
-          new_entity_snapshot_params = current_entity_snapshot_params.each do |key, _|
-            current_entity_snapshot_params[key] = update_params[key] if update_params.key?(key)
-          end
-          new_entity_snapshot_params[:previous_snapshot_id] = entity_snapshot_id
-          new_entity_snapshot_params[:is_removed] = true if update_params[:is_removed]
-          new_entity_snapshot = Skee::App::VersionedEntitySnapshot::Entity.new(@entity).create(new_entity_snapshot_params)
-          update_change_request(update_params[:change_request_id], versioned_entity_id, entity_snapshot_id, new_entity_snapshot.id)
-          new_entity_snapshot
-        end
-
-        def update_change_request(change_request_id, versioned_entity_id, current_entity_snapshot_id, new_entity_snapshot_id)
-          Skee::App::ChangeRequest::Service.update_change_set(
-            id: change_request_id,
-            changes: {
-              @entity => {
-                versioned_entity_id => {
-                  current_entity_snapshot_id => new_entity_snapshot_id
-                }
-              }
-            }
-          )
-        end
-      end
-    end
-  end
-end

data/integration_tests/minitest/grape_app/app/versioned_entity/service.rb

@@ -1,47 +0,0 @@
-require_relative 'validator'
-require_relative 'entity'
-require_relative '../versioned_entity_snapshot/entity'
-module Skee
-  module App
-    class VersionedEntityService
-      def self.list(ids: [], change_request_id: nil)
-        Skee::App::VersionedEntity::Entity.new(entity).list(ids: ids, change_request_id: change_request_id)
-      end
-
-      def self.get(params)
-        Skee::App::VersionedEntity::Entity.new(entity).get(params)
-      end
-
-      def self.create(params)
-        Skee::App::VersionedEntity::Validator.new(
-          params, entity
-        ).validate_create_params
-        create_fields = create_fields_keys.map do |key|
-          value = key == :prev_entity_id ? nil : params[key]
-          [key, value]
-        end.to_h
-        Skee::App::VersionedEntity::Entity.new(entity).create(create_fields)
-      end
-
-      def self.update(params)
-        Skee::App::VersionedEntity::Validator.new(
-          params, entity
-        ).validate_update_params
-        update_fields = params.slice(*update_fields_keys).compact
-        Skee::App::VersionedEntity::Entity.new(entity).update(update_fields)
-      end
-
-      def self.remove(params)
-        Skee::App::VersionedEntity::Validator.new(
-          params, entity
-        ).validate_remove_params
-        remove_fields = {
-          change_request_id: params[:change_request_id],
-          id: params[:id],
-          is_removed: true
-        }
-        Skee::App::VersionedEntity::Entity.new(entity).update(remove_fields)
-      end
-    end
-  end
-end