Merge branch 'staging'

Author: Chris Smith

.gitignore

@@ -42,3 +42,6 @@ bower.json
 
 #ignore docs
 /doc/app
+
+.generators
+.idea

app/assets/javascripts/views/sub_batch.coffee

@@ -30,7 +30,7 @@ class Mixtio.Views.SubBatch extends Backbone.View
   render: () ->
     @$el.html(JST['batches/sub_batch'](
       sub_batch: @model
-      quantity: @model.get("quantity")
+      size: @model.get("quantity") ? @model.get("size")
       volume: @model.get("volume")
       selected_unit: @model.get("unit") # string representation eg "mL"
       units: Mixtio.Bootstrap.Units

app/assets/stylesheets/layout.scss

@@ -125,11 +125,9 @@ form[data-behavior="batch-form"] {
   border-top: 2px solid grey;
 }
 
-.float-top-right {
-  position: absolute;
-  top: 0; right: 0;
-  padding-right: 15px;
-  margin-top: 30px;
+div.batch-index-buttons {
+  text-align: right;
+  padding-top: 20px;
 }
 
 @media (min-width: 768px) {

app/assets/templates/batches/sub_batch.jst.ejs

@@ -1,5 +1,5 @@
 <td>
-  <input class="form-control" type="number" value="<%= quantity == 0 ? null : quantity %>"
+  <input class="form-control" type="number" value="<%= size == 0 ? null : size %>"
          name="mixable[sub_batches][][quantity]" id="mixable_sub_batches__quantity" />
 </td>
 <td>

app/controllers/batches/print_controller.rb

@@ -0,0 +1,42 @@
+class Batches::PrintController < ApplicationController
+
+  # Save the label type ID when printing so it can be shown as default choice later
+  before_action :save_label_id, :current_resource, only: [:create]
+
+  # Disable editing once the batch has been printed
+  after_action :set_editable_false, only: [:create]
+
+  def create
+    print_job = PrintJob.new(print_params)
+
+    if print_job.execute!
+      flash[:notice] = ["Your labels have been printed"]
+    else
+      flash[:error] = ["Your labels could not be printed"]
+      print_job.errors.to_a.each do |error|
+        flash[:error] << error
+      end
+    end
+
+    redirect_to batch_path(current_resource)
+  end
+
+private
+
+  def current_resource
+    @batch ||= Batch.find(params[:id])
+  end
+
+  def print_params
+    params.permit(:label_template_id, :printer).merge(batch: current_resource)
+  end
+
+  def save_label_id
+    current_resource.consumable_type.update_column(:last_label_id, params[:label_template_id].to_i)
+  end
+
+  def set_editable_false
+    current_resource.update_column(:editable, false)
+  end
+
+end

app/controllers/batches/support_controller.rb

@@ -0,0 +1,8 @@
+class Batches::SupportController < ApplicationController
+
+  def show
+    @batch_id = params[:id]
+    @support_email = Rails.configuration.support_email
+  end
+
+end

app/controllers/batches_controller.rb

@@ -1,104 +1,76 @@
 class BatchesController < ApplicationController
 
   before_action :authenticate!, except: [:index]
-  before_action :current_resource, only: [:show, :print, :edit]
-
-  # Save the label type ID when printing so it can be shown as default choice later
-  before_action :save_label_id, only: [:print]
-
-  # Disable editing once the batch has been printed
-  after_action :set_editable_false, only: [:print]
+  before_action :current_resource, only: [:show, :update, :edit]
 
   def index
     @view_model = Batches::Index.new(filter_params)
   end
 
   def edit
-    @batch_form = BatchForm.new(current_resource.attributes.symbolize_keys.merge(edit_batch_params.merge(sub_batches: current_resource.sub_batches)))
-    unless current_resource.editable
+    @batch_form = BatchForm.new
+    unless current_resource.editable?
       redirect_to batches_path
       flash[:error] = "This batch has already been printed, so can't be modified."
     end
   end
 
   def update
-    @batch_form = BatchForm.new(batch_params.merge(current_user: current_user))
-    if @batch_form.update(current_resource)
-      redirect_to batch_path, notice: "Reagent batch successfully updated!"
+    @batch_form = BatchForm.new(params: BatchFormParameters.new(update_batch_params))
+    @batch = @batch_form.batch
+
+    if @batch_form.save
+      redirect_to batch_path(@batch), notice: "Reagent batch successfully updated!"
     else
       render :edit
     end
   end
 
   def create
-    @batch_form = BatchForm.new(batch_params.merge(current_user: current_user))
-    if @batch_form.create
-      redirect_to batch_path(@batch_form.batch), notice: "Reagent batch successfully created"
+    @batch_form = BatchForm.new(params: BatchFormParameters.new(batch_params))
+    @batch = @batch_form.batch
+
+    if @batch_form.save
+      redirect_to batch_path(@batch), notice: "Reagent batch successfully created"
     else
       render :new
     end
   end
 
   def new
-    batch = Batch.new_with_sub_batch
-    @batch_form = BatchForm.new(batch.attributes.symbolize_keys.merge(sub_batches: batch.sub_batches))
+    @batch = Batch.new.tap { |b| b.sub_batches.build }
+    @batch_form = BatchForm.new
   end
 
   def show
   end
 
-  def support
-    @batch_id = params[:id]
-    @support_email = Rails.configuration.support_email
-  end
-
-  def print
-    print_job = PrintJob.new(print_params.merge(:batch => current_resource))
-
-    if print_job.execute!
-      flash[:notice] = ["Your labels have been printed"]
-    else
-      flash[:error] = ["Your labels could not be printed"]
-      print_job.errors.to_a.each do |error|
-          flash[:error] << error
-      end
-    end
-
-    redirect_to batch_path(@batch)
-  end
-
 protected
 
-  def batch_params
-    params.require(:mixable)
-          .permit(:consumable_type_id, :consumable_name, :expiry_date, :single_barcode,
-                  mixture_criteria: [:consumable_type_id, :number, :kitchen_id, :quantity, :unit_id],
-                  sub_batches: [:quantity, :volume, :unit, :barcode_type, :project_id]
-          )
+  def current_resource
+    @batch ||= Batch.find(params[:id])
   end
 
-  def edit_batch_params
-    { mixture_criteria: @batch.mixture_criteria }
+  def batch_params
+    @batch_params ||= params.require(:mixable)
+      .permit(:consumable_type_id, :expiry_date,
+              mixture_criteria: [:consumable_type_id, :number, :kitchen_id, :quantity, :unit_id],
+              sub_batches: [:quantity, :volume, :unit, :barcode_type, :project_id]
+      )
+      .merge(user: current_user.user, action: params[:action])
+      .tap do |batch_params|
+        batch_params[:mixture_criteria] ||= []
+        batch_params[:sub_batches] ||= []
+        batch_params[:mixture_params] = batch_params[:mixture_criteria].map { |mxc| MixtureParameters.new(mxc) }
+      end
   end
 
-  def print_params
-    params.permit(:label_template_id, :printer)
+  def update_batch_params
+    batch_params.merge(batch: current_resource)
   end
 
   def filter_params
     params.permit(:consumable_type_id, :created_after, :created_before, :page)
   end
 
-  def current_resource
-    @batch = Batch.find(params[:id])
-  end
-
-  def save_label_id
-    @batch.consumable_type.update_column(:last_label_id, params[:label_template_id].to_i)
-  end
-
-  def set_editable_false
-    @batch.update_column(:editable, false)
-  end
-
 end

app/forms/batch_form.rb

@@ -1,122 +1,65 @@
+# Responsible for creating a new Batch, along with its SubBatches and Mixtures
 class BatchForm
+  include ActiveModel::Model
 
-  extend ActiveModel::Naming
-  include ActiveModel::Conversion
-  include ActiveModel::Validations
-  include MixableForm
+  attr_accessor :params
 
-  attr_accessor :consumable_type_id, :expiry_date, :current_user, :sub_batches
+  validates :params, valid: true
 
-  def initialize(attributes = {})
-    attributes.each do |attribute, value|
-      send("#{attribute}=", value) if respond_to?("#{attribute}=")
-    end
-  end
-
-  def persisted?
-    false
-  end
+  def save
+    begin
+      ActiveRecord::Base.transaction do
+        batch.assign_attributes(batch_attributes)
 
-  validates :consumable_type_id, :expiry_date, :current_user, presence: true
+        return false if invalid?
 
-  validate do
-    if sub_batches.nil?
-      errors[:batch] << "must contain at least 1 sub-batch"
-    else
-      sub_batches.each do |sub_batch|
-        errors["Sub-Batch"] << "aliquots can't be empty" if sub_batch[:quantity].empty?
-        errors["Sub-Batch"] << "aliquots must be at least 1" if sub_batch[:quantity].to_i < 1 && sub_batch[:quantity].present?
+        # Clear the SubBatches before using #build to build new ones
+        # Can't do `batch.sub_batches = new_sub_batches` because it immediately throws an unhelpful error
+        # if the new_sub_batches aren't valid
+        batch.sub_batches.clear
+        batch.sub_batches.build(params.sub_batches)
 
-        errors["Sub-Batch"] << "volume can't be empty" if sub_batch[:volume].empty?
-        errors["Sub-Batch"] << "volume must be positive" if sub_batch[:volume].to_f <= 0 && sub_batch[:volume].present?
+        # Always create new mixtures
+        batch.mixtures = build_mixtures
 
-        errors["Sub-Batch"] << "project can't be empty" if sub_batch[:project_id].nil?
+        batch.save!
+        batch.create_audit(user: params.user, action: params.action)
       end
+      true
+    rescue => e
+      # Put whatever the errors were on the Batch onto the BatchForm
+      promote_errors(batch.errors)
+      Rails.logger.error(([e.message] + e.backtrace).join("\n    "))
+      false
     end
-
-    errors[:expiry_date] << "can't be in the past" if expiry_date.present? && expiry_date.to_date < Date.today
   end
 
+  # Batch will be either the one passed in on params or a new one
+  # @return [Batch]
   def batch
-    @batch ||= Batch.new(consumable_type_id: consumable_type_id, expiry_date: expiry_date,
-                         mixtures: mixtures, kitchen: current_user.team,
-                         user: current_user.user)
+    @batch ||= (params.batch.nil?) ? Batch.new : params.batch
   end
 
-  def create
-    return false unless valid?
-
-    begin
-      ActiveRecord::Base.transaction do
-        batch.save!
-        # Create the consumables for each sub-batch
-        sub_batches.each do |sub_batch|
-          sub_batch_record = create_sub_batch(batch, sub_batch)
-
-          create_consumables(sub_batch_record, sub_batch[:quantity].to_i, {sub_batch_id: sub_batch_record.id})
-          if sub_batch[:barcode_type] == "single"
-            generate_single_barcode(sub_batch_record.consumables)
-          end
-        end
+private
 
-        batch.create_audit(user: current_user, action: 'create')
-      end
-    rescue => e
-      errors[:exception] << e.to_s
-      Rails.logger.error ([e.message] + e.backtrace).join("\n    ")
-      return false
-    end
+  def batch_attributes
+    {
+      consumable_type_id: params.consumable_type_id,
+      expiry_date: params.expiry_date,
+      user: params.user,
+      kitchen: params.kitchen,
+      mixture_criteria: params.mixture_criteria
+    }
   end
 
-  def update(batch)
-    return false unless valid?
-
-    begin
-      ActiveRecord::Base.transaction do
-        # Delete all existing consumables for the batch
-        batch.sub_batches.each do |old_sub_batch|
-          old_sub_batch.consumables.destroy_all
-        end
-        batch.sub_batches.destroy_all
-
-        # Update attributes for the batch record
-        batch.update_attributes!(consumable_type_id: consumable_type_id,
-            expiry_date: expiry_date, mixtures: mixtures,
-            kitchen: current_user.team, user: current_user.user)
-
-        # Create the consumables for each sub-batch
-        sub_batches.each do |sub_batch|
-          sub_batch_record = create_sub_batch(batch, sub_batch)
-          create_consumables(sub_batch_record, sub_batch[:quantity].to_i, {sub_batch_id: sub_batch_record.id})
-          if sub_batch[:barcode_type] == "single"
-            generate_single_barcode(sub_batch_record.consumables)
-          end
-        end
-
-        batch.create_audit(user: current_user, action: 'update')
-      end
-    rescue => e
-      errors[:exception] << e.to_s
-      Rails.logger.error ([e.message] + e.backtrace).join("\n    ")
-      return false
-    end
+  def build_mixtures
+    params.mixture_params.map { |mixture_param| Mixture.from_params(mixture_param) }
   end
 
-  private
-    def create_sub_batch(batch, sub_batch)
-      batch.sub_batches.create!(sub_batch.except(:barcode_type, :quantity))
-    end
-
-    def create_consumables(sub_batch, quantity, attributes)
-      sub_batch.consumables.create!(Array.new(quantity, attributes))
-    end
-
-    def generate_single_barcode(sub_batch_consumables)
-      barcode = sub_batch_consumables.first.barcode
-      sub_batch_consumables.each do |consumable|
-        consumable.barcode = barcode
-        consumable.save!
-      end
+  def promote_errors(child_errors)
+    child_errors.each do |attribute, message|
+      errors.add(attribute, message)
     end
+  end
 
 end