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

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

@@ -1,24 +0,0 @@
-module Skee
-  module API
-    module Routes
-      module TrackableObject
-        class ResponseEntity < Grape::Entity
-          class VersionedEntity < Grape::Entity
-            expose :id, documentation: { type: 'String', desc: 'Unique ID of a trackable_object.' }
-          end
-          class EntitySnapshot < Grape::Entity
-            expose :id, as: :snapshot_id, documentation: { type: 'String', desc: 'Unique ID of a trackable_object.' }
-            expose :name, documentation: { type: 'String', desc: 'Name of the trackable object.' }
-            expose :change_request_id, documentation: { type: 'String', desc: 'Change request ID for the trackable object.' }
-            expose :previous_snapshot_id, documentation: { type: 'String', desc: 'Trackable object ID of the previous version of this trackable object.' }
-            expose :is_removed, safe: true, documentation: { type: 'String', desc: 'Marker to specify that trackable object is removed from the tracking spec.' }
-            expose :property_ids, documentation: { type: 'Array', desc: 'Property IDs of a trackable object.' }
-          end
-
-          expose :versioned_entity, merge: true, using: ResponseEntity::VersionedEntity
-          expose :versioned_entity_snapshot, merge: true, using: ResponseEntity::EntitySnapshot
-        end
-      end
-    end
-  end
-end

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

@@ -1,88 +0,0 @@
-require_relative '../api_helpers'
-require_relative './response_entity'
-require_relative './spec_response'
-require_relative '../../../app/tracking_spec/endpoint'
-
-module Skee::API::Routes::TrackingSpec
-  class API < Grape::API
-    helpers Skee::API::Routes::APIHelpers
-
-    resource :tracking_specs do
-      desc 'List all Tracking Specs.'
-      get do
-        tracking_specs = Skee::App::TrackingSpec::Endpoint.list
-        present tracking_specs,
-          with: Skee::API::Routes::TrackingSpec::ResponseEntity
-      end
-
-      desc 'Retrieve a Tracking Spec.'
-      params do
-        requires :id, type: String, desc: 'Tracking Spec ID.'
-      end
-      get ':id' do
-        tracking_spec = Skee::App::TrackingSpec::Endpoint.get(whitelisted_params)
-        present tracking_spec,
-          with: Skee::API::Routes::TrackingSpec::ResponseEntity
-      end
-
-      desc 'Generate a full Tracking Spec.'
-      params do
-        requires :id, type: String, desc: 'Tracking Spec ID.'
-      end
-      get ':id/full_spec' do
-        full_spec = Skee::App::TrackingSpec::Endpoint.full_spec(whitelisted_params)
-        present full_spec,
-          with: Skee::API::Routes::TrackingSpec::SpecResponse
-      end
-
-      desc 'Create a Tracking Spec.'
-      params do
-        requires :name, type: String, desc: 'Name of the Tracking Spec.'
-        optional :version_identifier, type: String, desc: 'Identifier of a Tracking Spec.'
-        optional :project_id, type: String, desc: 'Project in which Tracking Spec created.'
-        optional :change_request_id, type: String, desc: 'Change request from which Tracking Spec was created.'
-        optional :status, type: String, desc: 'Status of a Tracking Spec.'
-        optional :event_ids, type: Array[String], desc: 'Array of event IDs.'
-      end
-      post do
-        new_tracking_spec = Skee::App::TrackingSpec::Endpoint.create(whitelisted_params)
-        present new_tracking_spec,
-          with: Skee::API::Routes::TrackingSpec::ResponseEntity
-      end
-
-      desc 'Update a Tracking Spec.'
-      params do
-        requires :id, type: String, desc: 'Tracking Spec ID.'
-        optional :name, type: String, desc: 'Name of the Tracking Spec.'
-        optional :version_identifier, type: String, desc: 'Identifier of a Tracking Spec.'
-        optional :project_id, type: String, desc: 'Project in which Tracking Spec created.'
-        optional :change_request_id, type: String, desc: 'Change request from which Tracking Spec was created.'
-        optional :status, type: String, desc: 'Status of a Tracking Spec.'
-        optional :event_ids, type: Array[String], desc: 'Array of event IDs.'
-      end
-      post ':id' do
-        updated_tracking_spec = Skee::App::TrackingSpec::Endpoint.update(whitelisted_params)
-        present updated_tracking_spec,
-          with: Skee::API::Routes::TrackingSpec::ResponseEntity
-      end
-
-      desc 'Delete a Tracking Spec.'
-      params do
-        requires :id, type: String, desc: 'Tracking Spec ID.'
-      end
-      delete ':id' do
-        Skee::App::TrackingSpec::Endpoint.delete(whitelisted_params)
-        status 200
-      end
-
-      desc 'Expand a Tracking Spec'
-      params do
-        requires :id, type: String, desc: 'Tracking Spec ID.'
-        requires :change_request_id, type: String, desc: 'Change request from which Tracking Spec was created.'
-      end
-      get ':id/expand' do
-        Skee::App::TrackingSpec::Endpoint.expand(whitelisted_params)
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-module Skee
-  module API
-    module Routes
-      module TrackingSpec
-        class ResponseEntity < Grape::Entity
-          expose :id, documentation: { type: 'String', desc: 'Unique ID of a Tracking Spec.' }
-          expose :version_identifier, documentation: { type: 'String', desc: 'Identifier of a Tracking Spec.' }
-          expose :project_id, documentation: { type: 'String', desc: 'Project in which Tracking Spec created.' }
-          expose :change_request_id, documentation: { type: 'String', desc: 'Change request from which Tracking Spec was created.' }
-          expose :status, documentation: { type: 'String', desc: 'Status of a Tracking Spec.' }
-          expose :name, documentation: { type: 'String', desc: 'Name of the Tracking Spec.' }
-          expose :event_ids, documentation: { type: 'String', desc: 'Dictionary with list of IDs of all entities comprising the tracking spec.' }
-        end
-      end
-    end
-  end
-end

data/integration_tests/minitest/grape_app/api/routes/tracking_spec/spec_response.rb

@@ -1,19 +0,0 @@
-require_relative '../event/response_entity'
-require_relative '../trackable_object/response_entity'
-require_relative '../property/response_entity'
-
-module Skee
-  module API
-    module Routes
-      module TrackingSpec
-        class SpecResponse < Grape::Entity
-          expose :id, documentation: { type: 'String', desc: 'Unique ID of a tracking spec.' }
-          expose :version_identifier, documentation: { type: 'String', desc: 'Identifier of a Tracking Spec.' }
-          expose :name, documentation: { type: 'String', desc: 'Name of the tracking spec.' }
-          expose :change_request_id, documentation: { type: 'String', desc: 'Change request ID for the tracking spec.' }
-          expose :events, with: Skee::API::Routes::Event::ResponseEntity
-        end
-      end
-    end
-  end
-end

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

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

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

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

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

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

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

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

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

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

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

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