office_clerk 0.0.1

data/app/controllers/purchases_controller.rb

@@ -0,0 +1,72 @@
+# encoding : utf-8
+class PurchasesController < AdminController
+
+  before_filter :load_purchase, :only => [:show, :edit, :update , :order , :receive , :inventory]
+
+  # Uncomment for check abilities with CanCan
+  #authorize_resource
+
+  def index
+    @q = Purchase.search params[:q]
+    @purchase_scope = @q.result(:distinct => true)
+    @purchases = @purchase_scope.includes(:basket => {:items => :product} ).paginate( :page => params[:page],:per_page => 20 ).to_a
+  end
+
+  def show
+  end
+
+  # order this from supplier
+  def order
+    @purchase.order!
+    redirect_to purchase_path(@purchase), :notice => t(:ordered)
+  end
+
+  # receive the stuff (ie add to inventory)
+  def receive
+    items = @purchase.receive!
+    redirect_to purchase_path(@purchase), :notice => [t(:received) ,items ,t(:items)].join(" ")
+  end
+
+  # receive the stuff (ie add to inventory)
+  def inventory
+    items = @purchase.inventory!
+    redirect_to purchase_path(@purchase), :notice => [t(:inventorized) ,items ,t(:items)].join(" ")
+  end
+
+  def new
+    @purchase = Purchase.new
+    render :edit
+  end
+
+  def edit
+
+  end
+
+  def create
+    @purchase = Purchase.create(params_for_model)
+    if @purchase.save
+      redirect_to purchase_path(@purchase), :notice => t(:create_success, :model => "purchase")
+    else
+      render :edit
+    end
+  end
+
+  def update
+    if @purchase.update_attributes(params_for_model)
+      redirect_to purchase_path(@purchase), :notice => t(:update_success, :model => "purchase")
+    else
+      render :action => :edit
+    end
+  end
+
+  private
+
+  def load_purchase
+    @purchase = Purchase.where( :id => params[:id]).includes( :basket => {:items => {:product => :supplier}} ).first
+  end
+
+  def params_for_model
+    params.require(:purchase).permit(:name,:ordered_on,:received_on,:basket_id)
+  end
+end
+

data/app/controllers/sessions_controller.rb

@@ -0,0 +1,46 @@
+class SessionsController < ApplicationController
+  layout "shop"
+
+  def new
+  end
+
+  def create
+    clerk = Clerk.where(:email => params[:email]).limit(1).first
+    if clerk && clerk.valid_password?(params[:password])
+      session[:clerk_email] = clerk.email
+      url = clerk.admin ?  baskets_url : root_url
+      redirect_to url , :notice => I18n.t(:signed_in)
+    else
+      render "new" , :notice => I18n.t(:sign_in_invalid)
+    end
+  end
+
+  def destroy
+    session[:clerk_email] = nil
+    redirect_to root_url, :notice => I18n.t(:signed_out)
+  end
+
+  def new_clerk
+    @clerk = Clerk.new
+  end
+
+  def update_clerk
+    @clerk = current_clerk
+    if @clerk.update_attributes(params[:clerk])
+      redirect_to root_url, :notice => I18n.t(:updated)
+    else
+      render :action => 'edit'
+    end
+  end
+  
+  def create_clerk
+    @clerk = Clerk.new(params[:clerk])
+    if @clerk.save
+      session[:clerk_email] = @clerk.email
+      redirect_to root_url, :notice => "Signed up!"
+    else
+      render "new"
+    end
+  end
+  
+end

data/app/controllers/shop_controller.rb

@@ -0,0 +1,90 @@
+class ShopController < ApplicationController
+  before_action :load
+
+  layout "shop"
+
+  def welcome
+    @groups = Category.online.where( :category_id => nil )
+    render :layout => false
+  end
+
+  def product
+    @product = Product.shop_products.where(:link => params[:link]).first
+    unless @product
+      redirect_to :action => :group 
+      return
+    end
+    @group = @product.category
+    #error handling
+#    @group = Category.find(@product.category_id)
+  end
+
+  # the checkout page creates an order upon completion. So before a checkout the basket is attached to the session
+  # and by filling out all data an order is created with the basket and the session zeroed
+  def checkout
+    @order = Order.new :ordered_on => Date.today
+    @order.basket = current_basket
+    if(request.get?)
+      @order.email = current_clerk.email if current_clerk
+      @order.shipment_type = "pickup" # price is 0 automatically
+    else
+      order_ps = params.require(:order).permit( :email,:name , :street , :city , :phone , :shipment_type )
+      if @order.update_attributes(order_ps)
+        new_basket
+        redirect_to shop_order_path(@order), :notice => t(:thanks)
+        return
+      end
+    end
+  end
+
+  def order
+    if( params[:id])
+      @order = Order.find( params[:id] )
+    else
+      raise "last order of logged person"
+    end
+  end
+
+  def add
+    prod = Product.find( params[:id]) # no id will raise which in turn will show home page
+    current_basket.add_product(prod)
+    if request.get?
+      redirect_to shop_checkout_path
+    else
+      redirect_to shop_group_path(prod.category.link), :notice => "#{t(:product_added)}: #{prod.name}"
+    end
+  end
+  def remove
+    prod = Product.find( params[:id]) # no id will raise which in turn will show home page
+    current_basket.add_product(prod , -1)
+    redirect_to shop_checkout_path
+  end
+
+  def group
+    @group = Category.online.where(:link => params[:link]).first 
+    if @group
+      @products = @group.shop_products
+      template = "product_list"
+      @groups = @group.categories.online
+    else
+      @groups = Category.online.where( :category_id => nil )
+      template = "main_group"
+    end
+    render template
+  end
+
+  def page
+    @products = Product.shop_products.limit(50)
+    template = params[:id]
+    template = "tuotteista" if template.blank?
+    render template
+  end
+  private
+    def load
+      @menu =  {"/page/kotisivu" => "KOTISIVU" ,
+                "/group/start" => "VERKKOKAUPPA" ,
+                "/page/tuotteista" => "TUOTTEISTA",
+                "/page/toimitusehdot" => "TOIMITUSEHDOT" ,
+                "/page/liike" => "LIIKKEEMME" }
+    end
+end

data/app/controllers/suppliers_controller.rb

@@ -0,0 +1,63 @@
+# encoding : utf-8
+
+# A Supplier spupplies inventory for products.
+# The object itself only has an address, it's main function is to be the owner of purchase orders
+# In other words the supplier is to the Purchase what the User is to an order.
+#
+class SuppliersController < AdminController
+
+  before_filter :load_supplier, :only => [:show, :edit, :update, :destroy]
+
+  # Uncomment for check abilities with CanCan
+  # authorize_resource
+
+  def index
+    @q = Supplier.search(params[:q])
+    @supplier_scope = @q.result(:distinct => true)
+    @suppliers = @supplier_scope.paginate(:page => params[:page], :per_page => 20).to_a
+  end
+
+  def show
+  end
+
+  def new
+    @supplier = Supplier.new
+    render :edit
+  end
+
+  def edit
+  end
+
+  def create
+    @supplier = Supplier.create(params_for_supplier)
+    if @supplier.save
+      redirect_to supplier_path(@supplier), :notice => t(:create_success, :model => :supplier)
+    else
+      render :edit
+    end
+  end
+
+  def update
+    @supplier.update_attributes params_for_supplier
+    if @supplier.save
+      redirect_to supplier_path(@supplier), :notice => t(:update_success, :model => :supplier)
+    else
+      render :action => :edit
+    end
+  end
+
+  def destroy
+    #    @supplier.deleted_at = Time.now
+    redirect_to suppliers_url
+  end
+
+  private
+
+  def load_supplier
+    @supplier = Supplier.find(params[:id])
+  end
+
+  def params_for_supplier
+    params.require(:supplier).permit!
+  end
+end

data/app/helpers/admin_helper.rb

@@ -0,0 +1,28 @@
+# encoding : utf-8
+module AdminHelper
+
+  def basket_edit_link basket , options = {}
+    return "---" unless basket
+    return "" unless request.url.include?("basket")
+    text = t(:edit) + " "
+    link = edit_basket_path(basket)
+    case basket.kori_type
+    when "Order"
+      text += I18n.t(:order)
+      link = order_path(basket.kori) rescue ""
+    when "Purchase"
+      text += I18n.t(:purchase)
+      link = purchase_path(basket.kori) rescue ""
+    end
+    return link_to text , link , options 
+  end
+  
+  def sorting_header(model_name, attribute_name, namespace)
+    attribute_name
+  end
+
+  def sort_date key
+    return "" unless params[:q]
+    params[:q][key] || ""
+  end
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+module ApplicationHelper
+  
+  def markdown text
+    return "" if text.blank?
+    return sanitize Kramdown::Document.new(text).to_html
+  end
+
+  def euros price
+    price ? number_to_currency(price , :precision => 2 , :unit => "€") : 0.0
+  end
+
+  def date d
+    return "" unless d
+    I18n.l d
+  end
+
+  # change the default link renderer for will_paginate and add global options
+  def paginate(collection , options = {})
+    #options = options.merge defaults
+    options[:renderer] = BootstrapPagination::Rails
+    will_paginate collection, options
+  end
+
+end

data/app/helpers/baskets_helper.rb

@@ -0,0 +1,4 @@
+# encoding : utf-8
+require "admin_helper"
+module BasketsHelper
+end

data/app/helpers/categories_helper.rb

@@ -0,0 +1,4 @@
+# encoding : utf-8
+require "admin_helper"
+module CategoriesHelper
+end

data/app/helpers/orders_helper.rb

@@ -0,0 +1,4 @@
+# encoding : utf-8
+require "admin_helper"
+module OrdersHelper
+end

data/app/helpers/products_helper.rb

@@ -0,0 +1,4 @@
+# encoding : utf-8
+require "admin_helper"
+module ProductsHelper
+end

data/app/helpers/purchases_helper.rb

@@ -0,0 +1,4 @@
+# encoding : utf-8
+require "admin_helper"
+module PurchasesHelper
+end

data/app/helpers/shop_helper.rb

@@ -0,0 +1,17 @@
+module ShopHelper
+  def parents(group)
+    parents = []
+    while group
+      parents << group
+      group = group.category
+    end
+    parents.reverse
+  end
+  def in_group( product , get = 4)
+    group = product.category
+    return [] unless group
+    prods = group.shop_products.to_a
+    prods.delete(product)
+    prods.sample(get)
+  end
+end

data/app/helpers/suppliers_helper.rb

@@ -0,0 +1,4 @@
+# encoding : utf-8
+require "admin_helper"
+module SuppliersHelper
+end

data/app/models/basket.rb

@@ -0,0 +1,114 @@
+class Basket < ActiveRecord::Base
+
+  default_scope { order('created_at DESC') }
+
+  belongs_to :kori, polymorphic: true  #kori is basket in finnish
+
+  has_many :items, autosave: true
+  before_save :cache_total
+
+  accepts_nested_attributes_for :items
+
+  def quantity
+    items.sum(:quantity)
+  end
+
+  def empty?
+    self.items.empty?
+  end
+
+  def cache_total
+    self.total_price = items.to_a.sum{ |i| i.total }
+    self.total_tax =  items.to_a.sum{ |i| i.tax_amount}
+  end
+  
+  def touch
+    cache_total
+    super
+    save!
+  end
+
+  #return a hash of rate => amount
+  def taxes
+    taxes = Hash.new(0.0)
+    items.each do |item|
+      taxes[item.tax] += item.tax_amount
+    end
+    taxes
+  end
+
+  # receiving the goods means that the item quantity is added to the stock (product.inventory)
+  # also we change the price to the products cost price
+  # locks the basket so receiving or deductiing becomes an error.
+  def receive!
+    raise "Locked since #{self.locked}" if self.locked
+    sum = 0
+    self.items.each do |item|
+      prod = item.product
+      prod.inventory = prod.inventory + item.quantity
+      prod.save!
+      sum += item.quantity
+      item.price = item.product.cost
+#      item.save!
+    end
+    self.locked = Date.today
+    self.save!
+    sum
+  end
+
+  # locks the basket so receiving or deducting becomes an error.
+  # deduct the items from inventory, change affects immediately in the products 
+  def deduct!
+    raise "Locked since #{self.locked}" if self.locked
+    sum = 0
+    self.items.each do |item|
+      prod = item.product
+      prod.inventory = prod.inventory - item.quantity
+      sum += item.quantity
+      prod.save!
+    end
+    self.locked = Date.today
+    self.save!
+    sum
+  end
+
+  #inventoying the basket means setting the item quantity as the stock
+  #we actually change the basket for it to be a relative change (so as to look like a receive)
+  def inventory!
+    self.items.each { |item| item.quantity -= item.product.inventory  }
+    self.receive!
+  end
+
+  def isa typ
+    return typ == :cart  if self.kori_type == nil
+    self.kori_type.downcase == typ.to_s.downcase
+  end
+
+  def suppliers
+    ss = items.collect{|i| i.product.supplier if i.product}
+    ss.uniq!
+    ss.delete(nil)
+    ss
+  end
+  
+  #when adding a product (with quantity) we ensure there is only one item for each product
+  def add_product prod , quant = 1
+    return unless prod
+    return unless quant != 0
+    raise "Locked since #{self.locked}" if self.locked
+    exists = items.where(:product_id => prod.id ).limit(1).first
+    if exists
+      exists.quantity += quant
+    else
+      exists = items.new :quantity => quant , :product => prod , :price => prod.price , 
+                         :tax => prod.tax , :name => prod.full_name
+    end
+    if( exists.quantity == 0)
+      exists.delete
+      touch
+    else
+      exists.save!
+    end
+    reload
+  end
+end