flutter 0.1.0.pre.2

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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,47 @@
+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

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

@@ -0,0 +1,61 @@
+require_relative '../../app/change_request/service'
+module Skee
+  module App
+    module VersionedEntity
+      class Validator
+        def initialize(params, entity_type)
+          @params = params
+          @entity_type = entity_type
+        end
+
+        ERRORS = Utils::Errors
+
+        def validate_create_params
+          validate_change_request_status
+          validate_uniqueness_by_name
+        end
+
+        def validate_update_params
+          validate_versioned_entity_present
+          validate_change_request_status
+          validate_uniqueness_by_name
+        end
+
+        def validate_remove_params
+          validate_versioned_entity_present
+          validate_change_request_status
+          validate_uniqueness_by_name
+        end
+
+        private
+
+        def validate_versioned_entity_present
+          entity_instance = Skee::App::DB_MAPPING_ENTITY[@entity_type].find(@params[:id])
+          raise ERRORS::RecordNotFoundException.new('Resource not found') unless entity_instance
+        end
+
+        def validate_change_request_status
+          raise ERRORS::RecordNotFoundException.new('Invalid change request') unless change_request
+          raise ERRORS::NotAllowedToUpdate.new('Invalid change request') if change_request.status != 'open'
+        end
+
+        def validate_uniqueness_by_name
+          # todo: fix this when we know structure of tracking spec
+          # tracking_spec = Skee::App::TrackingSpec::Service.get(id: change_request.source_tracking_spec_id)
+          # existing_entity_ids = tracking_spec.entity_set[@entity_type]
+          # new_entity_change_set = change_request.change_set[@entity_type]
+          # return unless new_entity_change_set
+          # new_entity_ids = new_entity_change_set.values.flatten
+          # non_unique_name = Skee::App::DB_MAPPING_ENTITY[@entity_type].find_all(ids: (new_entity_ids + existing_entity_ids)).any? do |entity|
+          #   entity.name == @params[:name]
+          # end
+          # raise ERRORS::UniquenessViolationException.new('Invalid name') if non_unique_name
+        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/versioned_entity_snapshot/entity.rb

@@ -0,0 +1,32 @@
+require_relative '../../app/change_request/service'
+module Skee
+  module App
+    module VersionedEntitySnapshot
+      class Entity
+        def initialize(entity)
+          @entity = entity
+          @db = Skee::App::DB_MAPPING_ENTITY_SNAPSHOT[@entity]
+        end
+
+        def list(ids:)
+          return @db.all if ids.empty?
+          @db.find_all(ids: ids)
+        end
+
+        def get(params)
+          # add validator, to reject if nil, or does not exist.
+          @db.find(params[:id])
+        end
+
+        def create(params)
+          @db.create(params)
+        end
+
+        def update(update_params)
+          snapshot = @db.find(update_params[:id])
+          snapshot.update(update_params)
+        end
+      end
+    end
+  end
+end

data/integration_tests/minitest/grape_app/config/boot.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'grape'
+require 'grape-entity'
+require 'pry'
+require 'dotenv'
+
+require_relative '../app/app'
+require_relative '../api/api'
+

data/integration_tests/minitest/grape_app/config.ru

@@ -0,0 +1,3 @@
+require_relative './config/boot'
+
+run Skee::API::API

data/integration_tests/minitest/grape_app/db/proto/change_request.rb

@@ -0,0 +1,10 @@
+require_relative './common/doc'
+module Skee
+  module DB
+    module Proto
+      class ChangeRequest < Proto::Common::Doc
+        @all_docs = []
+      end
+    end
+  end
+end