flutter 0.1.0.pre.2

data/integration_tests/minitest/grape_app/api/routes/user/api.rb

@@ -0,0 +1,22 @@
+require_relative '../api_helpers'
+require_relative './response_entity'
+require 'ostruct'
+
+module Skee::API::Routes::User
+  class API < Grape::API
+    helpers Skee::API::Routes::APIHelpers
+
+    resource :users do
+      desc 'Authenticate a user'
+      params do
+        requires :username, type: String, desc: 'username of the user'
+        requires :password, type: String, desc: 'password of the user'
+      end
+      post ':authenticate' do
+        response = OpenStruct.new({ username: params[:username], access_token: '123' })
+        present response,
+          with: Skee::API::Routes::User::ResponseEntity
+      end
+    end
+  end
+end

data/integration_tests/minitest/grape_app/api/routes/user/response_entity.rb

@@ -0,0 +1,12 @@
+module Skee
+  module API
+    module Routes
+      module User
+        class ResponseEntity < Grape::Entity
+          expose :username, documentation: {type: 'String', desc: 'Username of the user'}
+          expose :access_token, documentation: {type: 'String', desc: 'AccessToken for the user'}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require_relative './utils/errors/api_exceptions'
+require_relative './utils/errors/service_exceptions'
+
+require_relative '../db/proto/project'
+require_relative '../db/proto/change_request'
+
+require_relative '../db/proto/event'
+require_relative '../db/proto/event_snapshot'
+require_relative '../db/proto/trackable_object'
+require_relative '../db/proto/trackable_object_snapshot'
+require_relative '../db/proto/property'
+require_relative '../db/proto/property_snapshot'
+
+module Skee
+  module App
+    DB = Skee::DB::Proto
+    DB_MAPPING_ENTITY = {
+      change_request: Skee::DB::Proto::ChangeRequest,
+      event: Skee::DB::Proto::Event,
+      project: Skee::DB::Proto::Project,
+      trackable_object: Skee::DB::Proto::TrackableObject,
+      property: Skee::DB::Proto::Property,
+    }.freeze
+    DB_MAPPING_ENTITY_SNAPSHOT = {
+      event: Skee::DB::Proto::EventSnapshot,
+      trackable_object: Skee::DB::Proto::TrackableObjectSnapshot,
+      property: Skee::DB::Proto::PropertySnapshot,
+    }.freeze
+  end
+end

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

@@ -0,0 +1,24 @@
+require_relative './service'
+module Skee::App::ChangeRequest
+  class Endpoint
+    def self.list
+      Service.list
+    end
+
+    def self.get(params)
+      Service.get(params)
+    end
+
+    def self.create(params)
+      Service.create(params)
+    end
+
+    def self.update(params)
+      Service.update(params)
+    end
+
+    def self.delete(params)
+      Service.delete(params)
+    end
+  end
+end

data/integration_tests/minitest/grape_app/app/change_request/generate_system_changes.rb

@@ -0,0 +1,25 @@
+module Skee
+  module App
+    module ChangeRequest
+      class GenerateSystemChanges
+        def initialize(change_request)
+          @change_request = change_request
+        end
+
+        def call
+
+        end
+
+        private
+
+        def create_new_change
+
+        end
+
+        def update_existing_change
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+require_relative '../../db/proto/change_request'
+module Skee
+  module App
+    module ChangeRequest
+      class Service
+        DB = Skee::DB::Proto
+
+        def self.list
+          DB::ChangeRequest.all
+        end
+
+        def self.get(params)
+          DB::ChangeRequest.find(params[:id])
+        end
+
+        def self.create(params)
+          # add any validation or filtering logic here to
+          # derive fields from params
+          fields = {
+            identifier: params[:identifier],
+            project_id: params[:project_id],
+            base_tracking_spec_id: params[:base_tracking_spec_id],
+            status: params[:status],
+            name: params[:name],
+            description: params[:description],
+            change_set: params[:change_set]
+          }
+          DB::ChangeRequest.create(fields)
+        end
+
+        def self.update(params)
+          # send valid fields excluding id
+          fields = {
+            identifier: params[:identifier],
+            project_id: params[:project_id],
+            base_tracking_spec_id: params[:base_tracking_spec_id],
+            status: params[:status],
+            name: params[:name],
+            description: params[:description],
+            change_set: params[:change_set]
+          }.compact
+          change_request = DB::ChangeRequest.find(params[:id])
+          change_request.update(fields)
+        end
+
+        def self.update_change_set(params)
+          change_request = DB::ChangeRequest.find(params[:id])
+          existing_change_set = change_request.change_set
+          params[:changes].each do |entity, change_hash|
+            existing_change_set[entity] ||= {}
+            change_hash.each do |prev_id, new_id|
+              if prev_id
+                existing_change_set[entity][prev_id] = new_id
+              else
+                existing_change_set[entity][nil] ||= []
+                existing_change_set[entity][nil] << new_id
+              end
+            end
+          end
+        end
+
+        def self.remove_from_change_set(id:, entity:, entity_id:)
+          change_request = DB::ChangeRequest.find(id)
+          existing_change_set = change_request.change_set
+          if existing_change_set[entity].values.include?(entity_id)
+            existing_change_set[entity].delete_if {|_,value| value == entity_id}
+          elsif existing_change_set[entity][nil].include?(entity_id)
+            existing_change_set[entity][nil].delete(entity_id)
+          end
+        end
+
+        def self.delete(params)
+          change_request = DB::ChangeRequest.find(params[:id])
+          change_request.delete
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+require_relative './service'
+module Skee::App::Event
+  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(formatted_params(params))
+    rescue ERRORS::RecordNotFoundException,
+      ERRORS::NotAllowedToUpdate,
+      ERRORS::UniquenessViolationException => e
+      raise ERRORS::ValidationError.new(e.message)
+    end
+
+    def self.update(params)
+      Service.update(formatted_params(params))
+    rescue ERRORS::RecordNotFoundException,
+      ERRORS::NotAllowedToUpdate,
+      ERRORS::UniquenessViolationException => e
+      raise ERRORS::ValidationError.new(e.message)
+    end
+
+    def self.update_payload_keys(params)
+      Service.update_payload_keys(formatted_params(params))
+    rescue ERRORS::RecordNotFoundException,
+      ERRORS::NotAllowedToUpdate,
+      ERRORS::UniquenessViolationException => e
+      raise ERRORS::ValidationError.new(e.message)
+    end
+
+    def self.remove_payload_keys(params)
+      Service.remove_payload_keys(formatted_params(params))
+    rescue ERRORS::RecordNotFoundException,
+      ERRORS::NotAllowedToUpdate,
+      ERRORS::UniquenessViolationException => e
+      raise ERRORS::ValidationError.new(e.message)
+    end
+
+    def self.add_payload_keys(params)
+      Service.add_payload_keys(formatted_params(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
+
+    private
+
+    def self.formatted_params(params)
+      existing_payload = params[:payload]
+      return params unless existing_payload
+
+      new_payload = existing_payload.map do |payload|
+        key = payload[:key]
+        payload.delete(:key)
+        [key, payload]
+      end.to_h
+      params[:payload] = new_payload
+      params
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require_relative '../../app/versioned_entity/service'
+require_relative 'validator'
+module Skee
+  module App
+    module Event
+      class Service < Skee::App::VersionedEntityService
+        def self.entity
+          :event
+        end
+
+        def self.create_fields_keys
+          %i(
+            change_request_id
+            previous_snapshot_id
+            is_removed
+            name
+            description
+            payload
+          )
+        end
+
+        def self.update_fields_keys
+          %i(
+            id
+            change_request_id
+            is_removed
+            name
+            description
+            payload
+          )
+        end
+
+        def self.create(params)
+          Skee::App::Event::Validator.new(params).validate_create_params
+          super(params)
+        end
+
+        def self.add_payload_keys(params)
+          Skee::App::Event::Validator.new(params).validate_add_payload_key_params
+          event = Skee::App::Event::Service.get(id: params[:id])
+          new_payload = event.versioned_entity_snapshot.payload.merge(params[:payload])
+          params[:payload] = new_payload
+          update(params)
+        end
+
+        def self.update_payload_keys(params)
+          Skee::App::Event::Validator.new(params).validate_update_payload_key_params
+          event = Skee::App::Event::Service.get(id: params[:id])
+          new_payload = event.versioned_entity_snapshot.payload.merge(params[:payload])
+          params[:payload] = new_payload
+          update(params)
+        end
+
+        def self.remove_payload_keys(params)
+          Skee::App::Event::Validator.new(params).validate_remove_payload_key_params
+          event = Skee::App::Event::Service.get(id: params[:id])
+          keys_for_removal = params[:payload_keys]
+          new_payload = event.versioned_entity_snapshot.payload.map { |key, value|
+            [key, value] unless keys_for_removal.include?(key)
+          }.compact.to_h
+          params[:payload] = new_payload
+          params.delete(:payload_keys)
+          update(params)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+require_relative '../../app/change_request/service'
+require_relative '../../app/tracking_spec/service'
+module Skee
+  module App
+    module Event
+      class Validator
+        def initialize(params)
+          @params = params
+        end
+
+        ERRORS = Utils::Errors
+
+        def validate_create_params
+          validate_change_request_status
+          validate_payload
+        end
+
+        def validate_add_payload_key_params
+          validate_change_request_status
+          validate_non_duplicate_keys
+          validate_payload
+        end
+
+        def validate_update_payload_key_params
+          validate_change_request_status
+          validate_key_exists(@params[:payload].keys)
+          validate_payload
+        end
+
+        def validate_remove_payload_key_params
+          validate_change_request_status
+          validate_key_exists(@params[:payload_keys])
+        end
+
+        private
+
+        def validate_payload
+          payload = @params[:payload]
+          return unless payload
+
+          payload.each do |_, value|
+            validate_reference_entity_and_type(value)
+            validate_properties_exist_on_trackable_object(value)
+            validate_selected_property_ids_exist(value)
+          end
+        end
+
+        def validate_reference_entity_and_type(payload_value)
+          reference_entity_id = payload_value[:reference_entity_id]
+          reference_entity_type = payload_value[:reference_entity_type]
+
+          reference_entity = if reference_entity_type == 'trackable_object'
+            Skee::App::TrackableObject::Service.get(id: reference_entity_id, change_request_id: @params[:change_request_id])
+          else
+            Skee::App::Property::Service.get(id: reference_entity_id, change_request_id: @params[:change_request_id])
+          end
+          return if reference_entity
+
+          raise ERRORS::NotAllowedToUpdate.new('Invalid parameter: Reference entity does not exist')
+        end
+
+        def validate_properties_exist_on_trackable_object(payload_value)
+          return if payload_value[:reference_entity_type] != 'trackable_object'
+          trackable_object = Skee::App::TrackableObject::Service.get(id: payload_value[:reference_entity_id], change_request_id: @params[:change_request_id])
+          return if (payload_value[:selected_property_ids] - trackable_object.versioned_entity_snapshot.property_ids).empty?
+          raise ERRORS::NotAllowedToUpdate.new('Invalid parameter: Selected properties not present on trackable object')
+        end
+
+        def validate_selected_property_ids_exist(payload_value)
+          selected_property_ids = payload_value[:selected_property_ids]
+          selected_properties = Skee::App::Property::Service.list(ids: selected_property_ids, change_request_id: @params[:change_request_id])
+          return if (selected_properties.map{|property| property.versioned_entity.id} - selected_property_ids).empty?
+          raise ERRORS::NotAllowedToUpdate.new('Invalid parameter: Selected properties do not exist')
+        end
+
+        def validate_non_duplicate_keys
+          # check that key is unique
+          # check that reference_entity_id exists for the corresponding reference_entity_type
+          # check that selected_property_ids exist
+          common_keys = event.versioned_entity_snapshot.payload.keys & @params[:payload].keys
+          return if common_keys.empty?
+          raise ERRORS::NotAllowedToUpdate.new("Invalid keys: Keys #{common_keys.join(',')} already exist")
+        end
+
+        def validate_key_exists(payload_keys)
+          existing_keys = event.versioned_entity_snapshot.payload.keys
+          payload_keys.each do |key|
+            next if existing_keys.include?(key)
+            raise ERRORS::NotAllowedToUpdate.new("Invalid keys: Not allowed to update non-existent key #{key}")
+          end
+        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 event
+          @event ||= Skee::App::Event::Service.get(id: @params[:id], change_request_id: @params[:change_request_id])
+        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/project/endpoint.rb

@@ -0,0 +1,24 @@
+require_relative './service'
+module Skee::App::Project
+  class Endpoint
+    def self.list
+      Service.list
+    end
+
+    def self.get(params)
+      Service.get(params)
+    end
+
+    def self.create(params)
+      Service.create(params)
+    end
+
+    def self.update(params)
+      Service.update(params)
+    end
+
+    def self.delete(params)
+      Service.delete(params)
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require_relative '../../db/proto/project'
+module Skee
+  module App
+    module Project
+      class Service
+        DB = Skee::DB::Proto
+    
+        def self.list
+          DB::Project.all
+        end
+    
+        def self.get(params)
+          DB::Project.find(params[:id])
+        end
+    
+        def self.create(params)
+          # add any validation or filtering logic here to
+          fields = {
+            name: params[:name],
+            description: params[:description]
+          }
+          DB::Project.create(fields)
+        end
+    
+        def self.update(params)
+          # send valid fields excluding id
+          fields = {
+            name: params[:name],
+            description: params[:description]
+          }
+          project = DB::Project.find(params[:id])
+          project.update(fields)
+        end
+    
+        def self.delete(params)
+          project = DB::Project.find(params[:id])
+          project.delete
+        end
+      end
+    end
+  end
+end

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

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

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

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