jobshop 0.0.131 → 0.0.157

data/app/models/jobshop/inspection/result.rb

@@ -0,0 +1,42 @@
+module Jobshop
+  class Inspection::Result < ApplicationRecord
+    FALSE_VALUES = [false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"]
+
+    self.primary_keys = [ :organization_id, :report_id, :criterion_id, :criterion_type, :position ]
+
+    belongs_to :organization
+    belongs_to :report, class_name: "Jobshop::Inspection::Report",
+      foreign_key: [ :organization_id, :report_id ]
+    belongs_to :criterion, polymorphic: true, optional: true, dependent: :destroy,
+      foreign_key: [ :organization_id, :report_id, :criterion_id, :criterion_type ]
+    belongs_to :tuple, class_name: "Jobshop::Inspection::Tuple",
+      foreign_key: [ :organization_id, :report_id, :position ]
+
+    def value
+      if self[:unit] == "boolean"
+        !!self[:value]
+      else
+#        binding.pry
+        self[:value] && Unitwise(self[:value].truncate(4), self[:unit])
+      end
+    end
+
+    def value=(value)
+      if criterion.unit == "boolean"
+        self[:value] = value
+        self[:unit] = "boolean"
+      else
+        if value.respond_to?(:unit)
+          self[:value] = value.value
+          self[:unit] = value.unit
+        else
+          self[:value] = value
+        end
+      end
+    end
+
+    def in_spec?
+      criterion.pass?(self[:value])
+    end
+  end
+end

data/app/models/jobshop/inspection/tuple.rb

@@ -0,0 +1,13 @@
+module Jobshop
+  class Inspection::Tuple < ApplicationRecord
+    self.primary_keys = [ :organization_id, :report_id, :position ]
+
+    belongs_to :organization
+    belongs_to :report, class_name: "Jobshop::Inspection::Report", inverse_of: :tuples,
+      foreign_key: [ :organization_id, :report_id ]
+    has_many :results, class_name: "Jobshop::Inspection::Result", inverse_of: :tuple,
+      foreign_key: [ :organization_id, :report_id, :position ]
+
+    has_many :criteria, through: :results
+  end
+end

data/app/models/jobshop/inspection.rb

@@ -0,0 +1,13 @@
+module Jobshop
+  module Inspection
+    def self.table_name_prefix
+      "jobshop_inspection_"
+    end
+
+    CRITERION_TYPES = [
+      :inspection_boolean_criterion,
+      :inspection_limit_criterion,
+      :inspection_deviation_criterion
+    ].freeze
+  end
+end

data/app/models/jobshop/order.rb

@@ -0,0 +1,41 @@
+module Jobshop
+  class Order < ApplicationRecord
+    self.primary_keys = [ :organization_id, :order_id ]
+
+    after_create do
+      self.class.connection.clear_query_cache
+      @attributes = self.class.unscoped {
+        self.class.find_by!(organization: organization, number: number)
+      }.instance_variable_get(:@attributes)
+      @new_record = false
+      self
+    end
+
+    belongs_to :organization, inverse_of: :orders
+    belongs_to :created_by, class_name: "Jobshop::User",
+      foreign_key: [ :organization_id, :created_by_id ]
+    belongs_to :company, inverse_of: :orders,
+      foreign_key: [ :organization_id, :company_id ]
+    has_many :order_lines, inverse_of: :order,
+      foreign_key: [ :organization_id, :order_id ]
+
+    around_save :notify_on_save
+
+    def add_listener(listener)
+      (@listeners ||= []) << listener
+    end
+
+    def notify_listeners(event_name, *args)
+      @listeners && @listeners.each do |listener|
+        if listener.respond_to?(event_name)
+          listener.public_send(event_name, self, *args)
+        end
+      end
+    end
+
+    def notify_on_save
+      yield
+      notify_listeners(:on_save)
+    end
+  end
+end

data/app/models/jobshop/order_line.rb

@@ -0,0 +1,13 @@
+module Jobshop
+  class OrderLine < ApplicationRecord
+    self.primary_keys = [ :organization_id, :order_id, :order_line_id]
+
+    belongs_to :organization
+    belongs_to :created_by, class_name: "Jobshop::User",
+      foreign_key: [ :organization_id, :created_by_id ]
+    belongs_to :order, inverse_of: :order_lines,
+      foreign_key: [ :organization_id, :order_id ]
+    belongs_to :product,
+      foreign_key: [ :organization_id, :product_id ]
+  end
+end

data/app/models/jobshop/organization.rb

@@ -0,0 +1,34 @@
+module Jobshop
+  class Organization < ApplicationRecord
+    self.primary_key = :organization_id
+
+    has_many :users, inverse_of: :organization,
+      dependent: :restrict_with_exception
+    has_many :roles, inverse_of: :organization,
+      dependent: :restrict_with_exception
+    has_many :places, inverse_of: :organization,
+      dependent: :restrict_with_exception
+    has_many :collections, inverse_of: :organization,
+      dependent: :restrict_with_exception
+    has_many :things, inverse_of: :organization,
+      dependent: :restrict_with_exception
+    has_many :orders, inverse_of: :organization,
+      dependent: :restrict_with_exception
+    has_many :companies, inverse_of: :organization,
+      dependent: :restrict_with_exception
+    has_many :products, inverse_of: :organization,
+      dependent: :restrict_with_exception
+    has_many :routing_processes, inverse_of: :organization,
+      dependent: :restrict_with_exception
+
+    scope :grouped_by_email, ->(email_addresses) {
+      Jobshop::User
+        .where(email: email_addresses)
+        .joins(:organization)
+        .includes(:organization)
+        .each_with_object({}) { |user, organizations|
+          (organizations[user.email] ||= []) << user.organization
+        }
+    }
+  end
+end

data/app/models/jobshop/place.rb

@@ -1,9 +1,11 @@
 module Jobshop
   class Place < ApplicationRecord
-    belongs_to :team
+    self.primary_keys = [ :organization_id, :place_id ]
 
-    validates(:name,
-              uniqueness: { scope: :team_id, case_sensitive: false },
-              presence: true)
+    belongs_to :organization, inverse_of: :places
+
+    validates :name,
+      presence: true,
+      uniqueness: { scope: :organization_id, case_sensitive: false }
   end
 end

data/app/models/jobshop/product.rb

@@ -0,0 +1,23 @@
+module Jobshop
+  class Product < ApplicationRecord
+    self.primary_keys = [ :organization_id, :product_id ]
+
+    after_create do
+      self.class.connection.clear_query_cache
+      @attributes = self.class.unscoped {
+        self.class.find_by!(organization: organization, name: name)
+      }.instance_variable_get(:@attributes)
+      @new_record = false
+      self
+    end
+
+    belongs_to :organization, inverse_of: :products
+    belongs_to :created_by, class_name: "Jobshop::User",
+      foreign_key: [ :organization_id, :created_by_id ]
+    has_one :routing_process, inverse_of: :product,
+      foreign_key: [ :organization_id, :product_id ]
+    has_many :routing_steps, through: :routing_process
+
+    validates :name, presence: true
+  end
+end

data/app/models/jobshop/registration.rb

@@ -1,11 +1,17 @@
 module Jobshop
   class Registration < VirtualRecord
-    memo_attr(:user) { team.users.build(user_params) }
-    memo_attr(:team) {
-      record = ::Jobshop::Team.find(params[:team_id])
-
-      record.assign_attributes(team_params)
+    memo_attr(:user) {
+      record = organization.users.build(user_params)
+      record.singleton_class.class_eval do
+        validates :forename, presence: true
+        validates :surname, presence: true
+      end
+      record
+    }
 
+    memo_attr(:organization) {
+      record = ::Jobshop::Organization.find(params[:organization_id])
+      record.assign_attributes(organization_params)
       record.singleton_class.class_eval do
         validates :name, presence: true, on: :update, if: :name_changed?
       end
@@ -18,9 +24,7 @@ module Jobshop
 
       result = ActiveRecord::Base.transaction do
         user.save!
-        team.update!(owner: user,
-                     registration_token: nil,
-                     registration_token_sent_at: nil)
+        organization.register_to(user)
       end
 
       result != false
@@ -32,8 +36,8 @@ module Jobshop
       params.fetch(:registration, ActionController::Parameters.new)
     end
 
-    def team_params
-      registration_params.fetch(:team, ActionController::Parameters.new)
+    def organization_params
+      registration_params.fetch(:organization, ActionController::Parameters.new)
         .permit(:name)
     end
 

data/app/models/jobshop/role.rb

@@ -0,0 +1,24 @@
+module Jobshop
+  class Role < ApplicationRecord
+    self.primary_keys = [ :organization_id, :role_id ]
+
+    after_create do
+      self.class.connection.clear_query_cache
+
+      fresh_record = self.class.unscoped {
+        self.class.find_by!(organization: organization, name: name) }
+
+      @attributes = fresh_record.instance_variable_get(:@attributes)
+      @new_record = false
+      self
+    end
+
+    belongs_to :organization, inverse_of: :roles,
+               primary_key: [ :organization_id, :role_id ]
+
+    has_many :role_assignments, inverse_of: :role,
+             foreign_key: [ :organization_id, :role_id ]
+
+    validates :name, presence: true
+  end
+end

data/app/models/jobshop/role_ability.rb

@@ -0,0 +1,7 @@
+module Jobshop
+  class RoleAbility < ApplicationRecord
+    belongs_to :organization
+    belongs_to :role
+    belongs_to :ability
+  end
+end

data/app/models/jobshop/role_assignment.rb

@@ -0,0 +1,7 @@
+module Jobshop
+  class RoleAssignment < ApplicationRecord
+    belongs_to :organization
+    belongs_to :user, foreign_key: [ :organization_id, :user_id ]
+    belongs_to :role, foreign_key: [ :organization_id, :role_id ]
+  end
+end

data/app/models/jobshop/routing_process.rb

@@ -0,0 +1,20 @@
+module Jobshop
+  class RoutingProcess < ApplicationRecord
+    self.primary_keys = [ :organization_id, :routing_process_id ]
+
+    after_create do
+      self.class.connection.clear_query_cache
+      @attributes = self.class.unscoped {
+        self.class.find_by!(organization: organization, product_id: product_id)
+      }.instance_variable_get(:@attributes)
+      @new_record = false
+      self
+    end
+
+    belongs_to :organization, inverse_of: :routing_processes
+    belongs_to :product, inverse_of: :routing_process,
+      foreign_key: [ :organization_id, :product_id ]
+    has_many :routing_steps, inverse_of: :routing_process,
+      foreign_key: [ :organization_id, :routing_process_id ]
+  end
+end

data/app/models/jobshop/routing_step.rb

@@ -0,0 +1,11 @@
+module Jobshop
+  class RoutingStep < ApplicationRecord
+    self.primary_keys = [ :organization_id, :routing_step_id ]
+
+    belongs_to :organization
+    belongs_to :routing_process, inverse_of: :routing_steps,
+      foreign_key: [ :organization_id, :routing_process_id ]
+
+    validates :name, presence: true
+  end
+end

data/app/models/jobshop/thing.rb

@@ -1,9 +1,35 @@
 module Jobshop
   class Thing < ApplicationRecord
-    belongs_to :team
+    self.primary_keys = [ :organization_id, :thing_id ]
 
-    validates(:identifier,
-              uniqueness: { scope: :team_id, case_sensitive: false },
-              presence: true)
+    after_create do
+      self.class.connection.clear_query_cache
+      fresh_thing = self.class.unscoped {
+        self.class.find_by!(organization: organization, collection: collection, name: name)
+      }
+      @attributes = fresh_thing.instance_variable_get(:@attributes)
+      @new_record = false
+      self
+    end
+
+    belongs_to :organization, inverse_of: :things
+    belongs_to :collection, inverse_of: :things,
+      foreign_key: [ :organization_id, :collection_id ]
+
+    validates :name, presence: true,
+      uniqueness: { scope: :organization_id, case_sensitive: false }
+
+    validates :custom_fields, json: { message: -> (errors) { errors },
+                                      schema: -> { my_schema },
+                                      options: { errors_as_objects: true } }
+
+    def my_schema
+      # TODO: Because shoulda-matchers doesn't properly recreate the test
+      # subject this has the return {} when collection is nil. Collection will
+      # only ever be nil during this test. Once the proper fk constraint is
+      # added to the db, the test in question will raise an exception and a new
+      # solution will need to be found.
+      collection && collection.schema || {}
+    end
   end
 end

data/app/models/jobshop/user.rb

@@ -1,34 +1,39 @@
 module Jobshop
   class User < ApplicationRecord
-    # Include default devise modules. Others available are:
-    # :confirmable, :lockable, :timeoutable and :omniauthable
-    devise :database_authenticatable, :recoverable, :rememberable
+    self.primary_keys = :organization_id, :user_id
 
-    belongs_to :team
-    has_one :default_dashboard, class_name: "Jobshop::Dashboard", through: :team
-    has_many :session_activations, dependent: :destroy
+    has_secure_password
+
+    after_create do
+      self.class.connection.clear_query_cache
+      @attributes = self.class.unscoped {
+        self.class.find_by!(organization: organization, email: email)
+      }.instance_variable_get(:@attributes)
+      @new_record = false
+      self
+    end
+
+    belongs_to :organization, inverse_of: :users
+    has_many :role_assignments, inverse_of: :user,
+      foreign_key: [ :organization_id, :user_id ]
+    has_many :roles, through: :role_assignments
+    has_many :sessions, inverse_of: :user, dependent: :destroy,
+      foreign_key: [ :organization_id, :user_id ]
 
     validates :email,
       presence:   { if: :email_required? },
       format:     { if: :email_required?, with: /\A[^@\s]+@[^@\s]+\z/ },
-      uniqueness: { if: :email_changed?, scope: :team_id }
+      uniqueness: { if: :email_changed?, scope: :organization_id, case_sensitive: false }
+
+    validates :password_digest, presence: true
 
     validates :password,
       presence:     { if: :password_required? },
       confirmation: { if: :password_required? }
 
-    def self.find_for_authentication(warden_conditions)
-      where(email:   warden_conditions[:email],
-            team_id: warden_conditions[:team_id]).first
-    end
 
-    def onboard?
-      # TODO: Implement this correctly.
-      false
-    end
-
-    def full_name
-      @full_name = [ forename, surname ].join(" ")
+    def name
+      @name = [ forename, surname ].join(" ")
     end
 
     def activate_session
@@ -44,13 +49,6 @@ module Jobshop
     end
 
   private
-    def generate_email_authentication_token
-      loop do
-        token = Devise.friendly_token
-        break token unless Jobshop::User.where(email_authentication_token: token).first
-      end
-    end
-
     def password_required?
       !persisted? || !password.nil? || !password_confirmation.nil?
     end

data/app/serializers/jobshop/test_user_serializer.rb

@@ -0,0 +1,10 @@
+module Jobshop
+  class TestUserSerializer
+    include FastJsonapi::ObjectSerializer
+    attributes :email, :forename, :surname, :job_title
+
+    attribute :organization_name do |object|
+      object.organization.name
+    end
+  end
+end

data/app/services/jobshop/authentication_service.rb

@@ -0,0 +1,20 @@
+module Jobshop
+  class AuthenticationService
+    attr_reader :email, :password
+
+    def initialize(email, password)
+      @email = email
+      @password = password
+    end
+
+    def perform
+      Jobshop::JWTService.encode(user_id: user.id) if user
+    end
+
+    private def user
+      user = User.find_by(email: email)
+      user && user.authenticate(password) ||
+        raise(AuthenticationHandler::InvalidCredentials)
+    end
+  end
+end

data/app/services/jobshop/authorization_service.rb

@@ -0,0 +1,30 @@
+module Jobshop
+  class AuthorizationService
+    attr_reader :headers
+
+    def initialize(headers = {})
+      @headers = headers
+    end
+
+    def perform
+      { user: user }
+    end
+
+    private def user
+      @user ||= Jobshop::User.find(decoded_auth_token[:user_id]) if decoded_auth_token
+    rescue ActiveRecord::RecordNotFound => e
+      raise(AuthorizationHandler::TokenInvalid, e.message)
+    end
+
+    private def decoded_auth_token
+      @decoded_auth_token ||= JWTService.decode(http_auth_header)
+    end
+
+    private def http_auth_header
+      if headers["Authorization"].present?
+        return headers["Authorization"].split(" ").last
+      end
+      raise(AuthorizationHandler::TokenMissing)
+    end
+  end
+end

data/app/services/jobshop/jwt_service.rb

@@ -0,0 +1,17 @@
+module Jobshop
+  class JWTService
+    HMAC_SECRET = "fixme"
+
+    def self.encode(payload, exp = 24.hours.from_now)
+      payload[:exp] = exp.to_i
+      JWT.encode(payload, HMAC_SECRET)
+    end
+
+    def self.decode(token)
+      body = JWT.decode(token, HMAC_SECRET)[0]
+      HashWithIndifferentAccess.new body
+    rescue JWT::DecodeError => e
+      raise AuthorizationHandler::TokenInvalid, e.message
+    end
+  end
+end

data/config/routes.rb

@@ -1,45 +1,4 @@
 Jobshop::Engine.routes.draw do
-  devise_for :users, class_name: "Jobshop::User", module: "devise",
-    skip: :sessions
-
-  unauthenticated do
-    devise_scope :user do
-      get  "/sign_in/:team_id", to: "sessions#new",    as: :new_user_session
-      post "/sign_in/:team_id", to: "sessions#create", as: :user_session
-    end
-
-    get  "/teams/lookup", to: "teams/lookups#show", as: :teams_lookup
-    post "/teams/lookup", to: "teams/lookups#create"
-
-    namespace :welcome do
-      resource :registration, except: %w(edit destroy show update)
-    end
-
-    get "/", to: "dashboards#show"
-  end
-
-  authenticated do
-    devise_scope :user do
-      delete "/sign_out", to: "sessions#destroy", as: :destroy_user_session
-      delete "/revoke/:id",
-        to: "session_activations#destroy", as: :revoke_session
-    end
-
-    namespace :welcome do
-      resource :things, except: %w(destroy show) do
-        get "/", action: :index
-      end
-
-      resource :places, except: %w(destroy show) do
-        get "/", action: :index
-      end
-    end
-
-    get "/welcome", to: "welcome#index"
-    get "/logins", to: "places#show"
-
-    root to: "dashboards#show"
-  end
-
-  get "/about" => redirect("https://github.com/jobshop/jobshop"), as: :about
+  post "/signin", to: "sessions#new"
+  get "/current-user", to: "users#current"
 end

data/db/migrate/20170311194758_initialize_jobshop.rb

@@ -1,111 +1,6 @@
-class InitializeJobshop < ActiveRecord::Migration[5.0]
+class InitializeJobshop < ActiveRecord::Migration[5.1]
   def change
     enable_extension "pgcrypto" unless extension_enabled? "pgcrypto"
     enable_extension "citext"   unless extension_enabled? "citext"
-
-    create_table(:jobshop_users, id: :uuid,
-                 default: -> { "gen_random_uuid()" }) do |t|
-      ## Database authenticatable
-      t.string :email,              null: false, default: ""
-      t.string :encrypted_password, null: false, default: ""
-
-      ## Recoverable
-      t.string   :reset_password_token
-      t.datetime :reset_password_sent_at
-
-      ## Rememberable
-      t.datetime :remember_created_at
-
-      ## Trackable
-      # t.integer  :sign_in_count, default: 0, null: false
-      # t.datetime :current_sign_in_at
-      # t.datetime :last_sign_in_at
-      # t.string   :current_sign_in_ip
-      # t.string   :last_sign_in_ip
-
-      ## Confirmable
-      # t.string   :confirmation_token
-      # t.datetime :confirmed_at
-      # t.datetime :confirmation_sent_at
-      # t.string   :unconfirmed_email # Only if using reconfirmable
-
-      ## Lockable
-      # t.integer  :failed_attempts, default: 0, null: false # Only if lock strategy is :failed_attempts
-      # t.string   :unlock_token # Only if unlock strategy is :email or :both
-      # t.datetime :locked_at
-
-      t.uuid     :team_id, null: false
-      t.string   :forename
-      t.string   :surname
-      t.string   :email_authentication_token
-      t.datetime :email_authentication_token_sent_at, :datetime
-      t.timestamps
-    end
-
-    add_index :jobshop_users, [ :email, :team_id ],  unique: true
-    add_index :jobshop_users, :reset_password_token, unique: true
-    # add_index :jobshop_users, :confirmation_token,   unique: true
-    # add_index :jobshop_users, :unlock_token,         unique: true
-
-    create_table(:jobshop_teams, id: :uuid,
-                 default: -> { "gen_random_uuid()" }) do |t|
-      t.string   :name
-      t.uuid     :owner_id
-      t.string   :registration_token
-      t.datetime :registration_token_sent_at
-      t.timestamps
-    end
-
-    add_check :jobshop_teams, <<~CHECK, name: :check_owner_id_on_jobshop_teams
-      ((owner_id IS NULL AND registration_token IS NOT NULL AND registration_token_sent_at IS NOT NULL) OR
-       (owner_id IS NOT NULL AND registration_token IS NULL AND registration_token_sent_at IS NULL))
-    CHECK
-
-    add_index :jobshop_teams, [ "registration_token" ], unique: true
-
-    add_foreign_key :jobshop_users,
-        :jobshop_teams, column: "team_id", on_delete: :cascade
-
-    add_foreign_key :jobshop_teams,
-        :jobshop_users, column: "owner_id", on_delete: :restrict
-
-    create_table(:jobshop_dashboards, id: :uuid,
-                 default: -> { "gen_random_uuid()" }) do |t|
-      t.uuid :team_id
-      t.timestamps
-    end
-
-    add_foreign_key :jobshop_dashboards,
-        :jobshop_teams, column: "team_id", on_delete: :cascade
-
-    create_table(:jobshop_session_activations, id: :uuid,
-                 default: -> { "gen_random_uuid()" }) do |t|
-      t.uuid   :user_id,          null: false
-      t.string :activation_token, null: false
-      t.timestamps
-    end
-
-    add_index :jobshop_session_activations, :user_id
-    add_index :jobshop_session_activations, :activation_token, unique: true
-
-    create_table(:jobshop_things, id: :uuid,
-                 default: -> { "gen_random_uuid()" }) do |t|
-      t.uuid :team_id,       null: false
-      t.citext :identifier
-
-      t.timestamps
-    end
-
-    add_index :jobshop_things, [ :identifier, :team_id ], unique: true
-
-    create_table(:jobshop_places, id: :uuid,
-                 default: -> { "gen_random_uuid()" }) do |t|
-      t.uuid :team_id, null: false
-      t.citext :name
-
-      t.timestamps
-    end
-
-    add_index :jobshop_places, [ :name, :team_id ], unique: true
   end
 end