jobshop 0.0.131 → 0.0.157

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d4ffcb8337b5be5554bd4cea94434f222066ae8
-  data.tar.gz: e8783e7dcea6eac31286535aeba6b23e2b150546
+  metadata.gz: cfebb1f31d1fcbb60de9a9b6d74d38cf33db9dd8
+  data.tar.gz: 06d074ee3efe7275a4a2704b0c4ad1a512853259
 SHA512:
-  metadata.gz: d1aac609e64912ccdeb7b2bb523080351be1810d2de82d0afaeb1b5e5d5e2df25341c2c6a86e63de1b3ddae799e9c0339495dc49afc6aafd17d1f3e55c6abda1
-  data.tar.gz: c862c37ce01afafeda6f538415d4b6a94ea6e31f2ced2388778789b8b3823975b8412e7bd638ebac6b7c2cf481b720305dea83d985bc3225f3f1a89250b5ee0f
+  metadata.gz: 342ba401730334f6e0b99959c2a90abb10b1f5a46dc5caf88c36df26515797d510944035742c133cd38e244f551df4235ed15bd6774cf0ac022594807be1f138
+  data.tar.gz: c6186e7da358301f38968e0a700bab329a4a98be4f57934163513b005cad73f31370184489f2ec10367a90cdfb0d0f6c5d74c100a437937b19aa3ab9ccd6f38d

data/README.md

@@ -1,6 +1,6 @@
 # Jobshop
 
-Real-time production tracking and process evaluation in the cloud - or under your own roof.
+Real-time production tracking and process evaluation, under your own roof.
 
 [![Gem Version](https://badge.fury.io/rb/jobshop.svg)](https://badge.fury.io/rb/jobshop)
 [![Code Climate](https://codeclimate.com/github/jobshop/jobshop/badges/gpa.svg)](https://codeclimate.com/github/jobshop/jobshop)

data/Rakefile

@@ -1,12 +1,9 @@
-#!/usr/bin/env rake
-
 begin
   require "bundler/setup"
 rescue LoadError
   puts "You must `gem install bundler` and `bundle install` to run rake tasks"
 end
 
-require "rails/version"
 require "rdoc/task"
 
 RDoc::Task.new(:rdoc) do |rdoc|
@@ -18,17 +15,27 @@ RDoc::Task.new(:rdoc) do |rdoc|
 end
 
 require "jobshop/dummy_app"
+load "rails/tasks/statistics.rake"
 
 APP_RAKEFILE = Jobshop::DummyApp.rakefile
+require "bundler/gem_tasks"
 
 load "rails/tasks/engine.rake" if File.exist?(APP_RAKEFILE)
-load "rails/tasks/statistics.rake"
 
-namespace :jobshop do
-  desc "Create dummy app"
-  task :dummy do
-    Jobshop::DummyApp.new
+Bundler::GemHelper.install_tasks
+
+require "rspec/core"
+require "rspec/core/rake_task"
+
+desc "Verify that all FactoryBot factories are valid"
+task lint: :environment do
+  DatabaseCleaner.cleaning do
+    FactoryBot.definition_file_paths = Jobshop::DummyApp.factory_paths
+    FactoryBot.find_definitions
+    FactoryBot.lint traits: true
   end
 end
 
-Bundler::GemHelper.install_tasks
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/app/controllers/concerns/jobshop/authentication_handler.rb

@@ -0,0 +1,15 @@
+module Jobshop
+  module AuthenticationHandler
+    extend ActiveSupport::Concern
+
+    class InvalidCredentials < StandardError; end
+
+    included do
+      rescue_from AuthenticationHandler::InvalidCredentials, with: :unauthorized
+    end
+
+    private def unauthorized(e)
+      render({ json: { message: "Invalid credentials #{e.message}" } }, :unauthorized)
+    end
+  end
+end

data/app/controllers/concerns/jobshop/authorization_handler.rb

@@ -0,0 +1,29 @@
+module Jobshop
+  module AuthorizationHandler
+    extend ActiveSupport::Concern
+
+    class TokenMissing < StandardError; end
+    class TokenInvalid < StandardError; end
+
+    included do
+      before_action :authorize_request
+
+      rescue_from Jobshop::AuthorizationHandler::TokenMissing, with: :four_twenty_two
+      rescue_from Jobshop::AuthorizationHandler::TokenInvalid, with: :four_twenty_two
+      rescue_from ActiveRecord::RecordInvalid, with: :four_twenty_two
+      rescue_from ActiveRecord::RecordNotFound do |e|
+        render({ json: { message: e.message } }, :not_found)
+      end
+
+      attr_reader :current_user
+    end
+
+    private def four_twenty_two(e)
+      render({ json: { message: e.message } }, :unprocessable_entity)
+    end
+
+    private def authorize_request
+      @current_user = (AuthorizationService.new(request.headers).perform)[:user]
+    end
+  end
+end

data/app/controllers/jobshop/application_controller.rb

@@ -1,37 +1,10 @@
-# Parts of this class borrowed from:
-# https://gist.github.com/josevalim/fb706b1e933ef01e4fb6
-# Thank you Jose Valim!
-
 module Jobshop
-  class ApplicationController < ActionController::Base
-    layout :layout_for_application
-
-    protect_from_forgery
-
-    before_action EmailTokenValidation
-    before_action :authenticate_user!
-
-    def after_sign_in_path_for(resource_or_scope)
-      if !resource_or_scope.onboard?
-        welcome_path
-      else
-        super
-      end
-    end
-
-    private
-
-    def current_team
-      @current_team ||= current_user && current_user.team
-    end; helper_method :current_team
+  class ApplicationController < ActionController::API
+    include Jobshop::AuthorizationHandler
+    include Jobshop::AuthenticationHandler
 
-    def layout_for_application
-      if devise_controller? && controller_name == "sessions" ||
-          controller_path == "jobshop/teams/lookups"
-        "jobshop/unauthenticated"
-      else
-        "jobshop/application"
-      end
+    def current_organization
+      @current_organization ||= current_user && current_user.organization
     end
   end
 end

data/app/controllers/jobshop/organizations/lookups_controller.rb

@@ -0,0 +1,18 @@
+require_dependency "jobshop/application_controller"
+
+module Jobshop
+  class Organizations::LookupsController < ApplicationController
+    def show
+      @lookup = Jobshop::User.new
+    end
+
+    def create
+      emails = params[:user][:email].split(",").map(&:strip).take(5)
+      Jobshop::Organization.grouped_by_email(emails).each_pair do |email, organizations|
+        Jobshop::OrganizationsMailer.found_organizations(email, organizations).deliver_now
+      end
+
+      redirect_to organizations_lookup_path
+    end
+  end
+end

data/app/controllers/jobshop/places_controller.rb

@@ -7,6 +7,6 @@ module Jobshop
 
     private def session_activations
       current_user.session_activations
-    end; helper_method :session_activations
+    end
   end
 end

data/app/controllers/jobshop/{welcome/registrations_controller.rb → registrations_controller.rb}

@@ -1,15 +1,10 @@
 require_dependency "jobshop/application_controller"
 
 module Jobshop
-  class Welcome::RegistrationsController < ApplicationController
-    skip_before_action :authenticate_user!
-
-    before_action RegistrationTokenValidation
-
-    layout "jobshop/unauthenticated"
-
+  class RegistrationsController < ApplicationController
     def new
       @registration = ::Jobshop::Registration.new(params)
+      render json: @registration
     end
 
     def create

data/app/controllers/jobshop/session_activations_controller.rb

@@ -8,6 +8,6 @@ module Jobshop
 
     private def revoked_session
       @revoked_session ||= current_user.session_activations.find(params[:id])
-    end; helper_method :revoked_session
+    end
   end
 end

data/app/controllers/jobshop/sessions_controller.rb

@@ -1,6 +1,20 @@
 require_dependency "jobshop/application_controller"
 
 module Jobshop
-  class SessionsController < Devise::SessionsController
+  class SessionsController < ApplicationController
+    skip_before_action :authorize_request, only: :new
+
+    def new
+      token = AuthenticationService.new(
+        session_params[:email],
+        session_params[:password]
+      ).perform
+
+      render(json: { auth_token: token })
+    end
+
+    private def session_params
+      params.permit(:email, :password)
+    end
   end
 end

data/app/controllers/jobshop/users_controller.rb

@@ -0,0 +1,9 @@
+require_dependency "jobshop/application_controller"
+
+module Jobshop
+  class UsersController < ApplicationController
+    def current
+      render(json: Jobshop::TestUserSerializer.new(current_user))
+    end
+  end
+end

data/app/mailers/jobshop/application_mailer.rb

@@ -1,8 +1,8 @@
 module Jobshop
   class ApplicationMailer < ActionMailer::Base
-    default from: "jobshop-teams-lookup@example.com"
+    default from: "jobshop-lookup@example.com"
 
-    layout "jobshop/mailer"
+    layout "mailer"
   end
 end
 

data/app/models/jobshop/ability.rb

@@ -0,0 +1,7 @@
+module Jobshop
+  class Ability < ApplicationRecord
+    belongs_to :organization, class_name: "Jobshop::Organization"
+    has_many :role_abilities, -> (object) { where(organization_id: object.organization_id) }
+    has_many :roles, through: :role_abilities
+  end
+end

data/app/models/jobshop/collection.rb

@@ -0,0 +1,22 @@
+module Jobshop
+  class Collection < ApplicationRecord
+    self.primary_keys = [ :organization_id, :collection_id ]
+
+    after_create do
+      self.class.connection.clear_query_cache
+      fresh_collection = self.class.unscoped {
+        self.class.find_by!(organization: organization, name: name)
+      }
+      @attributes = fresh_collection.instance_variable_get(:@attributes)
+      @new_record = false
+      self
+    end
+
+    belongs_to :organization, inverse_of: :collections
+    has_many :things, inverse_of: :collection,
+      foreign_key: [ :organization_id, :collection_id ]
+
+    validates :name, presence: true,
+      uniqueness: { scope: :organization_id, case_sensitive: false }
+  end
+end

data/app/models/jobshop/company.rb

@@ -0,0 +1,22 @@
+module Jobshop
+  class Company < ApplicationRecord
+    self.primary_keys = [ :organization_id, :company_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: :companies
+    belongs_to :created_by, class_name: "Jobshop::User",
+      foreign_key: [ :organization_id, :created_by_id ]
+    has_many :orders, inverse_of: :company,
+      foreign_key: [ :organization_id, :company_id ]
+
+    validates :name, presence: true
+  end
+end

data/app/models/jobshop/dashboard.rb

@@ -1,5 +1,5 @@
 module Jobshop
   class Dashboard < ApplicationRecord
-    belongs_to :team
+    belongs_to :organization
   end
 end

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

@@ -0,0 +1,44 @@
+module Jobshop
+  class Inspection::BooleanCriterion < ApplicationRecord
+    self.primary_keys = [ :organization_id, :report_id, :criterion_id, :criterion_type ]
+
+    after_initialize do
+      self[:criterion_id] ||= SecureRandom.uuid if new_record?
+    end
+
+    belongs_to :organization
+    has_one :criterion, as: :criterion, autosave: true, dependent: :destroy,
+      foreign_key: [ :organization_id, :report_id, :criterion_id, :criterion_type ]
+    belongs_to :report, class_name: "Jobshop::Inspection::Report",
+      foreign_key: [ :organization_id, :report_id ], inverse_of: :criteria
+
+    alias_method :criterion_without_build, :criterion
+    def criterion_with_build
+      criterion_without_build || build_criterion(criterion_id: criterion_id, report: report)
+    end; alias_method :criterion, :criterion_with_build
+
+    delegate :name, :name=, :position, :position=, to: :criterion
+
+    def specification
+      @specification ||= "#{condition}\nPASS/FAIL"
+    end
+
+    def tolerance
+      @tolerance ||= condition
+    end
+
+    def unit
+      "boolean".freeze
+    end
+
+    def pass?(value)
+      ![ false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF" ].include?(value)
+    end
+
+    # Generate a random value that has a 90% chance of being in spec.
+    # TODO: This needs to go in the tests somewhere, not really in the model.
+    def random
+      rand(100) < 10
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Jobshop
+  class Inspection::Criterion < ApplicationRecord
+    self.primary_keys = [ :organization_id, :report_id, :criterion_id, :criterion_type ]
+
+    after_create do
+      self.class.connection.clear_query_cache
+      @attributes = self.class.unscoped {
+        self.class.find_by!(organization: organization, criterion_id: criterion_id)
+      }.instance_variable_get(:@attributes)
+      @new_record = false
+      self
+    end
+
+    belongs_to :organization
+    belongs_to :criterion, polymorphic: true, optional: true, dependent: :destroy,
+      foreign_key: [ :organization_id, :report_id, :criterion_id, :criterion_type ]
+    belongs_to :report, class_name: "Jobshop::Inspection::Report",
+      foreign_key: [ :organization_id, :report_id ], inverse_of: :criteria
+
+    delegate :ascii, :pass?, :random, :unit, to: :criterion
+  end
+end

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

@@ -0,0 +1,112 @@
+module Jobshop
+  class Inspection::DeviationCriterion < ApplicationRecord
+    self.primary_keys = [ :organization_id, :report_id, :criterion_id, :criterion_type ]
+
+    after_initialize do
+      self.criterion_id ||= SecureRandom.uuid if new_record?
+    end
+
+    belongs_to :organization
+    belongs_to :report, class_name: "Jobshop::Inspection::Report",
+      foreign_key: [ :organization_id, :report_id ], inverse_of: :criteria
+    has_one :criterion, as: :criterion, autosave: true, dependent: :destroy,
+      foreign_key: [ :organization_id, :report_id, :criterion_id, :criterion_type ]
+
+    alias_method :criterion_without_build, :criterion
+    def criterion_with_build
+      criterion_without_build || build_criterion
+    end; alias_method :criterion, :criterion_with_build
+
+    delegate :name, :name=, :position, :position=, to: :criterion
+
+    validates :nominal, presence: true
+    validates :lower, presence: true
+    validates :upper, presence: true
+
+    validate :lower_less_than_upper
+
+    def mean
+      ((nominal + lower) + (nominal + upper)) / 2
+    end
+
+    def nominal
+      self[:nominal] && Unitwise(self[:nominal].truncate(4), self[:unit])
+    end
+
+    def lower
+      self[:lower] && Unitwise(self[:lower].truncate(4), self[:unit])
+    end
+
+    def lower=(value)
+      self[:lower] = if value.respond_to?(:unit)
+        value.convert_to(self[:unit]).value
+      else
+         value
+      end
+    end
+
+    def upper
+      self[:upper] && Unitwise(self[:upper].truncate(4), self[:unit])
+    end
+
+    def upper=(value)
+      self[:upper] = if value.respond_to?(:unit)
+        value.convert_to(self[:unit]).value
+      else
+        value
+      end
+    end
+
+    def lower_less_than_upper
+      return unless lower && upper
+      if lower > upper
+        errors[:base] << "minimum must be less than maximum"
+      end
+    end
+
+    def specification
+      @specfication ||= if symmetric?
+        "#{nominal}±#{abs(upper)}"
+      else
+        "#{nominal}\n#{lower}/#{upper}"
+      end
+    end
+
+    def symmetric?
+      @symmetrical ||= lower == upper * -1
+    end
+
+    def pass?(value)
+      !undersize?(value) && !oversize?(value)
+    end
+
+    # Generate a random value that has a 90% chance of being in spec.
+    # TODO: This needs to go in the tests somewhere, not really in the model.
+    def random
+      rand_lower = nominal.to_f + lower.to_f * 1.1
+      rand_upper = nominal.to_f + upper.to_f * 1.1
+      value = rand(rand_lower..rand_upper)
+      Unitwise(value.truncate(4), self[:unit])
+    end
+
+    private def oversize?(value)
+      value = if value.respond_to?(:unit)
+        value.convert_to(self[:unit])
+      else
+        Unitwise(value, self[:unit])
+      end
+
+      value > upper || false
+    end
+
+    private def undersize?(value)
+      value = if value.respond_to?(:unit)
+        value.convert_to(self[:unit])
+      else
+        Unitwise(value, self[:unit])
+      end
+
+      value < nominal - lower || false
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+module Jobshop
+  class Inspection::LimitCriterion < ApplicationRecord
+    self.primary_keys = [ :organization_id, :report_id, :criterion_id, :criterion_type ]
+
+    after_initialize do
+      self.criterion_id = SecureRandom.uuid if new_record?
+    end
+
+    belongs_to :organization
+    has_one :criterion, as: :criterion, autosave: true, dependent: :destroy, inverse_of: :criterion,
+      foreign_key: [ :organization_id, :report_id, :criterion_id, :criterion_type ]
+    belongs_to :report, class_name: "Jobshop::Inspection::Report",
+      foreign_key: [ :organization_id, :report_id ], inverse_of: :criteria
+
+    def criterion
+      super || build_criterion
+    end
+
+    delegate :name, :name=, :position, :position=, to: :criterion
+
+    validate :minimum_or_maximum_or_both,
+      :minimum_less_than_maximum
+
+    def minimum
+      self[:minimum] && Unitwise(self[:minimum].truncate(4), self[:unit])
+    end
+
+    def minimum=(value)
+      if value && value.respond_to?(:unit)
+        self[:minimum] = value.value
+        self[:unit] = value.unit
+      else
+        self[:minimum] = value
+      end
+    end
+
+    def maximum
+      self[:maximum] && Unitwise(self[:maximum].truncate(4), self[:unit])
+    end
+
+    def maximum=(value)
+      if value && value.respond_to?(:unit)
+        self[:maximum] = value.value
+        self[:unit] = value.unit
+      else
+        self[:maximum] = value
+      end
+    end
+
+    def specification
+      @specification ||= [
+        qualifier, [ minimum, maximum ].compact.join("/")
+      ].compact.join("\n")
+    end
+
+    def qualifier
+      @qualifier ||= if minimum && !maximum
+        "Minimum"
+      elsif maximum && !minimum
+        "Maximum"
+      else
+        nil
+      end
+    end
+
+    def unbound?
+      !minimum ^ !maximum
+    end
+
+    def bound?
+      !unbound?
+    end
+
+    def pass?(value)
+      !undersize?(value) && !oversize?(value)
+    end
+
+    private def oversize?(value)
+      value = Unitwise(value, self[:unit]) unless value.respond_to?(:unit)
+      maximum && value > maximum || false
+    end
+
+    private def undersize?(value)
+      value = Unitwise(value, self[:unit]) unless value.respond_to?(:unit)
+      minimum && value < minimum || false
+    end
+
+    # Generate a random value that has a 90% chance of being in spec.
+    # TODO: This needs to go in the tests somewhere, not really in the model.
+    def random
+      value = if bound?
+        rand(self[:minimum].to_f..self[:maximum].to_f) * 1.1
+      elsif maximum
+        rand(self[:maximum].to_f) * 1.1
+      elsif minimum
+        rand((self[:minimum].to_f * 0.8)..(self[:minimum].to_f * 2.0))
+      end
+
+      Unitwise(value, self[:unit])
+    end
+
+    private def minimum_or_maximum_or_both
+      unless minimum || maximum
+        errors[:base] << "must specify minimum, maximum or both"
+      end
+    end
+
+    private def minimum_less_than_maximum
+      if(minimum && maximum && minimum > maximum)
+        errors[:base] << "minimum must be less than maximum"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Jobshop
+  class Inspection::Report < ApplicationRecord
+    self.primary_keys = [ :organization_id, :report_id ]
+
+    after_initialize do
+      self.report_id ||= SecureRandom.uuid if new_record?
+    end
+
+    after_create do
+      self.class.connection.clear_query_cache
+      @attributes = self.class.unscoped {
+        self.class.find_by!(organization: organization, report_id: report_id)
+      }.instance_variable_get(:@attributes)
+      @new_record = false
+      self
+    end
+
+    belongs_to :organization
+    has_many :criteria, -> { includes(:criterion).order(:position) },
+      foreign_key: [ :organization_id, :report_id ], inverse_of: :report
+    has_many :tuples, -> { order(:position) },  inverse_of: :report,
+      foreign_key: [ :organization_id, :report_id ]
+
+    def ascii
+      require "terminal-table"
+      table = Terminal::Table.new do |t|
+        t.title = "Inspection Report"
+        t << [ "Feature" ].concat(criteria.map(&:criterion).map(&:name))
+        t << [ "Specification" ].concat(criteria.map(&:criterion).map(&:specification))
+        tuples.each do |tuple|
+          results = criteria.map do |criterion|
+            tuple.results.find_by(criterion: criterion)
+          end
+          t << [ tuple.position ].concat(results.map(&:value))
+        end
+      end
+
+      puts table
+    end
+  end
+end