automation-api 0.3.0

data/config/starter.yml

@@ -0,0 +1,11 @@
+:account_owner:
+  :first_name: Test
+  :last_name: Starter
+  :phone: '9736928048'
+# Default: Here for reference
+# :entitlements:
+#   :activate:
+#     - pocket
+#     - freemium_care
+#     - freemium
+#     - billing_management

data/docker-compose.yml

@@ -0,0 +1,12 @@
+version: '3'
+
+services:
+  test:
+    build: .
+    environment:
+      - CODECLIMATE_REPO_TOKEN
+      - COVERAGE
+      - GIT_COMMIT
+      - GIT_BRANCH
+    command: >
+      bash -c "rspec --format progress --format RspecJunitFormatter --out /usr/artifacts/rspec.xml && bundle exec codeclimate-test-reporter && bundle exec rake pact:publish"

data/exe/store-gen

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'automation/api'
+
+Automation::API::CLI.start

data/lib/automation/api.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'automation/api/cli'
+require 'automation/api/client'
+require 'automation/api/version'
+
+module Automation
+  # Automation::API
+  module API
+    # Your code here
+    ROOT = File.expand_path('../../', __dir__)
+
+    def self.root
+      ROOT
+    end
+  end
+end

data/lib/automation/api/cli.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'thor'
+require 'yaml'
+require 'securerandom'
+
+module Automation
+  module API
+    # Automation::API::CLI
+    class CLI < Thor
+      DEFAULT_PROFILE = 'starter'
+      PROFILE_PATH    = "#{File.expand_path('../../../', __dir__)}/config"
+      PROFILE_EXAMPLE = "#{PROFILE_PATH}/profile.yml.example"
+
+      ARCHETYPES = %w[
+        complex
+        coffee_shop
+        empty
+      ].freeze
+
+      PROCESSORS = %w[
+        tgate_dev
+        tgate_prod
+        tgate_mock
+        clover
+        freedompay_uat
+        tgate_emulator_uat
+        broken
+        none
+      ].freeze
+
+      desc 'create [PROFILE]', 'Create store of using specified profile'
+
+      method_option :archetype,
+                    enum: ARCHETYPES,
+                    aliases: '-a',
+                    default: 'empty',
+                    desc: 'Store archetype - the base upon which the profile is built'
+
+      method_option :license_count,
+                    type: :numeric,
+                    aliases: '-l',
+                    default: 100,
+                    desc: 'Number of register license available'
+
+      method_option :subdomain,
+                    aliases: '-s',
+                    default: "test-auto-thor-#{SecureRandom.hex(4)}",
+                    desc: 'Store subdomain - randomly generated if not given'
+
+      method_option :email,
+                    aliases: '-e',
+                    desc: 'Email address associated with account - randomly generated if not given'
+
+      method_option :password,
+                    aliases: '-p',
+                    default: 'password',
+                    desc: 'Password for account owner'
+
+      method_option :time_zone,
+                    aliases: '-t',
+                    default: 'Eastern Time (US & Canada)',
+                    desc: 'Store time zone'
+
+      method_option :sk_expert,
+                    aliases: '-x',
+                    desc: "I'm not entirly sure what this is"
+
+      method_option :sk_employee,
+                    aliases: '-e',
+                    desc: "I'm not entirly sure what this is"
+
+      method_option :processor,
+                    enum: PROCESSORS,
+                    aliases: '-c',
+                    default: 'tgate_dev',
+                    desc: 'Credit card processor'
+
+      method_option :profile_path,
+                    aliases: '--path',
+                    default: PROFILE_PATH,
+                    desc: 'Specify a path to the directory containing the profile configuration'
+
+      def create(profile = DEFAULT_PROFILE)
+        @saved  = {}
+        @client = Automation::API::Client.create(options)
+
+        file_path = File.expand_path("#{profile}.yml", options[:profile_path])
+
+        raise 'Store profile not found' unless File.exist?(file_path)
+
+        configuration = YAML.load_file(file_path)
+
+        configuration.each do |key, value|
+          next unless private_methods.include?(key)
+
+          send(key, value)
+        end
+      end
+
+      desc 'list', 'List of predifined store profiles'
+
+      method_option :profile_path,
+                    aliases: '--path',
+                    default: PROFILE_PATH,
+                    desc: 'Specify a path to the directory containing the profile configuration'
+
+      def list
+        regex      = %r{([^\/]*).yml$}x
+        file_paths = Dir["#{options[:profile_path]}/*"]
+
+        file_paths.map { |file| file.match(regex) }
+                  .compact
+                  .map { |match| match[1] }
+                  .sort
+                  .each { |profile| puts profile }
+      end
+
+      desc 'view [PROFILE]', 'View config file for requested profile'
+
+      method_option :config_path,
+                    aliases: '--path',
+                    default: PROFILE_PATH,
+                    desc: 'Specify a path to the directory containing the profile configuration'
+
+      def view(store_type = DEFAULT_STORE_TYPE)
+        path = "#{options[:config_path]}/#{store_type}.yml"
+
+        if File.exist?(path)
+          puts File.read(path)
+        else
+          puts 'No configuration file found'
+        end
+      end
+
+      desc 'new_profile [NAME]', 'Start creating a new custom profile'
+
+      method_option :profile_path,
+                    aliases: '--path',
+                    default: Dir.pwd,
+                    desc: 'Specify a path to the directory where profile configuration will be saved'
+
+      def new_profile(name = 'custom_profile')
+        dest = File.expand_path("#{name}.yml", options[:profile_path])
+
+        FileUtils.cp(PROFILE_EXAMPLE, dest)
+      end
+
+      private
+
+      def account_owner(config)
+        print 'Updating account owner information'
+
+        @client.update_account_owner(config)
+
+        puts '...done'
+      end
+
+      def loyalty_provisioned(provision)
+        print "#{provision ? 'P' : 'Dep'}rovisioning loyalty"
+
+        provision ? @client.provision : @client.deprovison
+
+        puts '...done'
+      end
+
+      def location_preferences(config)
+        print 'Updating location preferences'
+
+        @client.update_location_preferences(config)
+
+        puts '...done'
+      end
+
+      def entitlements(params)
+        print 'Updating entitlements'
+
+        @client.update_entitlements(params)
+
+        puts '...done'
+      end
+
+      def features(params)
+        print 'Updating features'
+
+        @client.update_features(params)
+
+        puts '...done'
+      end
+
+      def settings(config)
+        print 'Updating settings'
+
+        @client.update_settings(config)
+
+        puts '...done'
+      end
+
+      def burn_first_register(burn)
+        return unless burn
+
+        print 'Burning first register'
+
+        @client.create_register
+
+        puts '...done'
+      end
+
+      def departments(config)
+        @saved[:departments] = []
+
+        config.each do |dept|
+          print "Creating department: #{dept[:name]}"
+
+          @saved[:departments] << @client.create_department(department: dept)
+
+          puts '...done'
+        end
+      end
+
+      def categories(config)
+        @saved[:categories] = []
+
+        config.each do |category|
+          print "Creating category: #{category[:name]}"
+
+          dept = @saved[:departments].find { |d| d.name == category[:department] }
+
+          @saved[:categories] << @client.create_category(department_id: dept.id, category: category)
+
+          puts '...done'
+        end
+      end
+
+      def sales_restrictions(config)
+        @saved[:sales_restrictions] = []
+
+        config.each do |restriction|
+          print "Creating sales restriction: #{restriction[:name]}"
+
+          dept = @saved[:departments].find { |d| d.name == restriction[:department] }
+          ctgy = @saved[:categories].find { |c| c.name == restriction[:category] }
+
+          @saved[:sales_restrictions] << @client.create_sales_restriction(department_id: dept.id, category_id: ctgy.id, sales_restriction: restriction)
+
+          puts '...done'
+        end
+      end
+
+      def stock_items(config)
+        @saved[:stock_items] = []
+
+        config.each do |item|
+          print "Creating stock item: #{item[:description]}"
+
+          dept = @saved[:departments].find { |d| d.name == item[:department] }
+          ctgy = @saved[:categories].find { |c| c.name == item[:category] }
+
+          item_params = item.merge(department_id: dept.id, category_id: ctgy.id)
+
+          @saved[:stock_items] << @client.create_stock_item(stock_item: item_params)
+
+          puts '...done'
+        end
+      end
+
+      def button_pages(pages)
+        @saved[:button_pages] = []
+
+        pages.each do |page|
+          print "Creating button page: #{page[:name]}"
+
+          @saved[:button_pages] << @client.create_button_page(button_page: page)
+
+          puts '...done'
+        end
+      end
+
+      def buttons(config)
+        @saved[:buttons] = []
+
+        config.each do |button|
+          print "Creating button for: #{button[:item]}"
+
+          page = @saved[:button_pages].find { |pg| pg.name == button[:page] }
+          item = @saved[:stock_items].find { |i| i.description == button[:item] }
+
+          butt = @client.create_button(button_page_id: page.id,
+                                       button: button.merge(item_id: item.id))
+
+          @saved[:buttons] << butt
+
+          puts '...done'
+        end
+      end
+
+      def online_ordering(_thing)
+        puts 'Online Ordering requires a active register. Please activate a register before continuing'
+
+        @client.enable_online_ordering if user_confirmation
+      end
+
+      def user_confirmation
+        puts '[Enter] to continue or [S] to skip'
+
+        answer = STDIN.gets.chomp.upcase
+
+        case answer
+        when ''
+          true
+        when 'S'
+          false
+        else
+          user_confirmation
+        end
+      end
+    end
+  end
+end

data/lib/automation/api/client.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'automation/api/requests'
+require 'json'
+require 'pp'
+require 'rest-client'
+require 'stringio'
+require 'zlib'
+require 'base64'
+
+module Automation
+  module API
+    # Automation::API::Client
+    class Client
+      include Requests::AccountOwner
+      include Requests::AppSync
+      include Requests::ButtonPages
+      include Requests::Buttons
+      include Requests::Categories
+      include Requests::Customers
+      include Requests::Departments
+      include Requests::Employees
+      include Requests::Entitlements
+      include Requests::Features
+      include Requests::LocationPreferences
+      include Requests::LoyaltyProvisioning
+      include Requests::MatrixProducts
+      include Requests::Modifiers
+      include Requests::NamedDiscounts
+      include Requests::OnlineOrders
+      include Requests::Registers
+      include Requests::Sales
+      include Requests::SalesRestrictions
+      include Requests::Settings
+      include Requests::StockItems
+      include Requests::Taxes
+      include Requests::TaxRateServiceTaxes
+      include Requests::Tenders
+
+      LOCAL_URL  = 'http://admin.127.0.0.1.xip.io:3000'
+      MOCK_URL   = 'http://localhost:1234'
+      URL        = 'https://api.getshopkeep.com'
+      USERNAME   = '8ec7225ad7aead3ef09265456f8de02c'
+      PASSWORD   = 'X'
+      AUTH_TOKEN = 'OGVjNzIyNWFkN2FlYWQzZWYwOTI2NTQ1NmY4ZGUwMmM6WA=='
+
+      CONTENT_HEADERS = { content_type: :json, accept: :json }.freeze
+
+      DEFAULT_ARCHETYPE = 'complex'
+      DEFAULT_PROCESSOR = 'tgate_dev'
+
+      DEFAULT_OPTIONS = { archetype: DEFAULT_ARCHETYPE,
+                          processor: DEFAULT_PROCESSOR }.freeze
+
+      def self.create(options = DEFAULT_OPTIONS)
+        store_data = generate_store(options)
+
+        pp store_data
+
+        store_settings(subdomain: store_data['subdomain'],
+                       processor: options['processor'])
+
+        new(uuid: store_data['uuid'])
+      end
+
+      def self.generate_store(options)
+        response = RestClient.post("#{URL}/dev/test/generate_store",
+                                   options.to_json,
+                                   content_type: :json,
+                                   accept: :json,
+                                   authorization: "Basic #{AUTH_TOKEN}")
+
+        JSON.parse(response.body)
+      end
+
+      def self.store_settings(settings)
+        response = RestClient.post("#{URL}/dev/test/store_settings",
+                                   settings.to_json,
+                                   content_type: :json,
+                                   accept: :json,
+                                   authorization: "Basic #{AUTH_TOKEN}")
+
+        JSON.parse(response.body)
+      end
+
+      attr_reader :uuid, :store, :login, :password
+
+      def initialize(uuid:, store: '', login: '', password: '', url: URL)
+        @uuid     = uuid
+        @store    = store
+        @login    = login
+        @password = password
+        @base_uri = "#{url}/dev/test/store/#{uuid}"
+        @trs_uri  = "#{url}/tax-rates-service/stores/#{uuid}"
+      end
+
+      def dev_headers
+        @dev_headers ||= CONTENT_HEADERS.merge(authorization: "Basic #{AUTH_TOKEN}")
+      end
+
+      def jwt_headers
+        @jwt_headers ||= CONTENT_HEADERS.merge(authorization: "Token token=#{jwt_token}")
+      end
+
+      private
+
+      def jwt_token
+        header, payload, sig = *decompress_token
+
+        encoded_header  = Base64.strict_encode64(header).match(/^[^=]*/)
+        encoded_payload = Base64.strict_encode64(payload).match(/^[^=]*/)
+
+        "#{encoded_header}.#{encoded_payload}.#{sig}"
+      end
+
+      def decompress_token
+        raw = Base64.decode64(auth_token)
+        gz  = Zlib::GzipReader.new(StringIO.new(raw))
+
+        JSON.parse(gz.read)
+      end
+
+      def auth_token
+        url  = 'https://api.getshopkeep.com/auth'
+        data = { store_name: store, password: password, login: login }.to_json
+
+        RestClient.post(url, data, content_type: :json) do |response, _, _|
+          response.cookies.fetch('_sk_oidc_auth_token')
+        end
+      end
+    end
+  end
+end