scaffold models

app/controllers/crm/customers_controller.rb

@@ -0,0 +1,74 @@
+class Crm::CustomersController < ApplicationController
+  before_action :set_crm_customer, only: [:show, :edit, :update, :destroy]
+
+  # GET /crm/customers
+  # GET /crm/customers.json
+  def index
+    @crm_customers = Crm::Customer.all
+  end
+
+  # GET /crm/customers/1
+  # GET /crm/customers/1.json
+  def show
+  end
+
+  # GET /crm/customers/new
+  def new
+    @crm_customer = Crm::Customer.new
+  end
+
+  # GET /crm/customers/1/edit
+  def edit
+  end
+
+  # POST /crm/customers
+  # POST /crm/customers.json
+  def create
+    @crm_customer = Crm::Customer.new(crm_customer_params)
+
+    respond_to do |format|
+      if @crm_customer.save
+        format.html { redirect_to @crm_customer, notice: 'Customer was successfully created.' }
+        format.json { render :show, status: :created, location: @crm_customer }
+      else
+        format.html { render :new }
+        format.json { render json: @crm_customer.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /crm/customers/1
+  # PATCH/PUT /crm/customers/1.json
+  def update
+    respond_to do |format|
+      if @crm_customer.update(crm_customer_params)
+        format.html { redirect_to @crm_customer, notice: 'Customer was successfully updated.' }
+        format.json { render :show, status: :ok, location: @crm_customer }
+      else
+        format.html { render :edit }
+        format.json { render json: @crm_customer.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /crm/customers/1
+  # DELETE /crm/customers/1.json
+  def destroy
+    @crm_customer.destroy
+    respond_to do |format|
+      format.html { redirect_to crm_customers_url, notice: 'Customer was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_crm_customer
+      @crm_customer = Crm::Customer.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def crm_customer_params
+      params.require(:crm_customer).permit(:name, :company, :contact_no, :email, :date_of_birth, :membership_id, :membership_type, :membership_authentication_code)
+    end
+end

app/controllers/settings/cashier_terminals_controller.rb

@@ -0,0 +1,74 @@
+class Settings::CashierTerminalsController < ApplicationController
+  before_action :set_settings_cashier_terminal, only: [:show, :edit, :update, :destroy]
+
+  # GET /settings/cashier_terminals
+  # GET /settings/cashier_terminals.json
+  def index
+    @settings_cashier_terminals = Settings::CashierTerminal.all
+  end
+
+  # GET /settings/cashier_terminals/1
+  # GET /settings/cashier_terminals/1.json
+  def show
+  end
+
+  # GET /settings/cashier_terminals/new
+  def new
+    @settings_cashier_terminal = Settings::CashierTerminal.new
+  end
+
+  # GET /settings/cashier_terminals/1/edit
+  def edit
+  end
+
+  # POST /settings/cashier_terminals
+  # POST /settings/cashier_terminals.json
+  def create
+    @settings_cashier_terminal = Settings::CashierTerminal.new(settings_cashier_terminal_params)
+
+    respond_to do |format|
+      if @settings_cashier_terminal.save
+        format.html { redirect_to @settings_cashier_terminal, notice: 'Cashier terminal was successfully created.' }
+        format.json { render :show, status: :created, location: @settings_cashier_terminal }
+      else
+        format.html { render :new }
+        format.json { render json: @settings_cashier_terminal.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /settings/cashier_terminals/1
+  # PATCH/PUT /settings/cashier_terminals/1.json
+  def update
+    respond_to do |format|
+      if @settings_cashier_terminal.update(settings_cashier_terminal_params)
+        format.html { redirect_to @settings_cashier_terminal, notice: 'Cashier terminal was successfully updated.' }
+        format.json { render :show, status: :ok, location: @settings_cashier_terminal }
+      else
+        format.html { render :edit }
+        format.json { render json: @settings_cashier_terminal.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /settings/cashier_terminals/1
+  # DELETE /settings/cashier_terminals/1.json
+  def destroy
+    @settings_cashier_terminal.destroy
+    respond_to do |format|
+      format.html { redirect_to settings_cashier_terminals_url, notice: 'Cashier terminal was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_settings_cashier_terminal
+      @settings_cashier_terminal = Settings::CashierTerminal.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def settings_cashier_terminal_params
+      params.require(:settings_cashier_terminal).permit(:name, :is_active, :is_currently_login, :auto_print_receipt, :printer_name, :header, :footer, :font, :font_size, :show_tax, :show_cashier, :show_guest_info)
+    end
+end

app/controllers/settings/lookups_controller.rb

@@ -0,0 +1,74 @@
+class Settings::LookupsController < ApplicationController
+  before_action :set_settings_lookup, only: [:show, :edit, :update, :destroy]
+
+  # GET /settings/lookups
+  # GET /settings/lookups.json
+  def index
+    @settings_lookups = Settings::Lookup.all
+  end
+
+  # GET /settings/lookups/1
+  # GET /settings/lookups/1.json
+  def show
+  end
+
+  # GET /settings/lookups/new
+  def new
+    @settings_lookup = Settings::Lookup.new
+  end
+
+  # GET /settings/lookups/1/edit
+  def edit
+  end
+
+  # POST /settings/lookups
+  # POST /settings/lookups.json
+  def create
+    @settings_lookup = Settings::Lookup.new(settings_lookup_params)
+
+    respond_to do |format|
+      if @settings_lookup.save
+        format.html { redirect_to @settings_lookup, notice: 'Lookup was successfully created.' }
+        format.json { render :show, status: :created, location: @settings_lookup }
+      else
+        format.html { render :new }
+        format.json { render json: @settings_lookup.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /settings/lookups/1
+  # PATCH/PUT /settings/lookups/1.json
+  def update
+    respond_to do |format|
+      if @settings_lookup.update(settings_lookup_params)
+        format.html { redirect_to @settings_lookup, notice: 'Lookup was successfully updated.' }
+        format.json { render :show, status: :ok, location: @settings_lookup }
+      else
+        format.html { render :edit }
+        format.json { render json: @settings_lookup.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /settings/lookups/1
+  # DELETE /settings/lookups/1.json
+  def destroy
+    @settings_lookup.destroy
+    respond_to do |format|
+      format.html { redirect_to settings_lookups_url, notice: 'Lookup was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_settings_lookup
+      @settings_lookup = Settings::Lookup.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def settings_lookup_params
+      params.require(:settings_lookup).permit(:lookup_type, :name, :value)
+    end
+end

app/controllers/settings/membership_settings_controller.rb

@@ -0,0 +1,74 @@
+class Settings::MembershipSettingsController < ApplicationController
+  before_action :set_settings_membership_setting, only: [:show, :edit, :update, :destroy]
+
+  # GET /settings/membership_settings
+  # GET /settings/membership_settings.json
+  def index
+    @settings_membership_settings = Settings::MembershipSetting.all
+  end
+
+  # GET /settings/membership_settings/1
+  # GET /settings/membership_settings/1.json
+  def show
+  end
+
+  # GET /settings/membership_settings/new
+  def new
+    @settings_membership_setting = Settings::MembershipSetting.new
+  end
+
+  # GET /settings/membership_settings/1/edit
+  def edit
+  end
+
+  # POST /settings/membership_settings
+  # POST /settings/membership_settings.json
+  def create
+    @settings_membership_setting = Settings::MembershipSetting.new(settings_membership_setting_params)
+
+    respond_to do |format|
+      if @settings_membership_setting.save
+        format.html { redirect_to @settings_membership_setting, notice: 'Membership setting was successfully created.' }
+        format.json { render :show, status: :created, location: @settings_membership_setting }
+      else
+        format.html { render :new }
+        format.json { render json: @settings_membership_setting.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /settings/membership_settings/1
+  # PATCH/PUT /settings/membership_settings/1.json
+  def update
+    respond_to do |format|
+      if @settings_membership_setting.update(settings_membership_setting_params)
+        format.html { redirect_to @settings_membership_setting, notice: 'Membership setting was successfully updated.' }
+        format.json { render :show, status: :ok, location: @settings_membership_setting }
+      else
+        format.html { render :edit }
+        format.json { render json: @settings_membership_setting.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /settings/membership_settings/1
+  # DELETE /settings/membership_settings/1.json
+  def destroy
+    @settings_membership_setting.destroy
+    respond_to do |format|
+      format.html { redirect_to settings_membership_settings_url, notice: 'Membership setting was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_settings_membership_setting
+      @settings_membership_setting = Settings::MembershipSetting.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def settings_membership_setting_params
+      params.require(:settings_membership_setting).permit(:membership_type, :is_active, :gateway_communication_type, :gateway_url, :auth_token, :merchant_account_id, :created_by)
+    end
+end

app/controllers/settings/menu_item_attributes_controller.rb

@@ -0,0 +1,74 @@
+class Settings::MenuItemAttributesController < ApplicationController
+  before_action :set_settings_menu_item_attribute, only: [:show, :edit, :update, :destroy]
+
+  # GET /settings/menu_item_attributes
+  # GET /settings/menu_item_attributes.json
+  def index
+    @settings_menu_item_attributes = Settings::MenuItemAttribute.all
+  end
+
+  # GET /settings/menu_item_attributes/1
+  # GET /settings/menu_item_attributes/1.json
+  def show
+  end
+
+  # GET /settings/menu_item_attributes/new
+  def new
+    @settings_menu_item_attribute = Settings::MenuItemAttribute.new
+  end
+
+  # GET /settings/menu_item_attributes/1/edit
+  def edit
+  end
+
+  # POST /settings/menu_item_attributes
+  # POST /settings/menu_item_attributes.json
+  def create
+    @settings_menu_item_attribute = Settings::MenuItemAttribute.new(settings_menu_item_attribute_params)
+
+    respond_to do |format|
+      if @settings_menu_item_attribute.save
+        format.html { redirect_to @settings_menu_item_attribute, notice: 'Menu item attribute was successfully created.' }
+        format.json { render :show, status: :created, location: @settings_menu_item_attribute }
+      else
+        format.html { render :new }
+        format.json { render json: @settings_menu_item_attribute.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /settings/menu_item_attributes/1
+  # PATCH/PUT /settings/menu_item_attributes/1.json
+  def update
+    respond_to do |format|
+      if @settings_menu_item_attribute.update(settings_menu_item_attribute_params)
+        format.html { redirect_to @settings_menu_item_attribute, notice: 'Menu item attribute was successfully updated.' }
+        format.json { render :show, status: :ok, location: @settings_menu_item_attribute }
+      else
+        format.html { render :edit }
+        format.json { render json: @settings_menu_item_attribute.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /settings/menu_item_attributes/1
+  # DELETE /settings/menu_item_attributes/1.json
+  def destroy
+    @settings_menu_item_attribute.destroy
+    respond_to do |format|
+      format.html { redirect_to settings_menu_item_attributes_url, notice: 'Menu item attribute was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_settings_menu_item_attribute
+      @settings_menu_item_attribute = Settings::MenuItemAttribute.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def settings_menu_item_attribute_params
+      params.require(:settings_menu_item_attribute).permit(:attribute_type, :name, :value)
+    end
+end

app/controllers/settings/menu_item_options_controller.rb

@@ -0,0 +1,74 @@
+class Settings::MenuItemOptionsController < ApplicationController
+  before_action :set_settings_menu_item_option, only: [:show, :edit, :update, :destroy]
+
+  # GET /settings/menu_item_options
+  # GET /settings/menu_item_options.json
+  def index
+    @settings_menu_item_options = Settings::MenuItemOption.all
+  end
+
+  # GET /settings/menu_item_options/1
+  # GET /settings/menu_item_options/1.json
+  def show
+  end
+
+  # GET /settings/menu_item_options/new
+  def new
+    @settings_menu_item_option = Settings::MenuItemOption.new
+  end
+
+  # GET /settings/menu_item_options/1/edit
+  def edit
+  end
+
+  # POST /settings/menu_item_options
+  # POST /settings/menu_item_options.json
+  def create
+    @settings_menu_item_option = Settings::MenuItemOption.new(settings_menu_item_option_params)
+
+    respond_to do |format|
+      if @settings_menu_item_option.save
+        format.html { redirect_to @settings_menu_item_option, notice: 'Menu item option was successfully created.' }
+        format.json { render :show, status: :created, location: @settings_menu_item_option }
+      else
+        format.html { render :new }
+        format.json { render json: @settings_menu_item_option.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /settings/menu_item_options/1
+  # PATCH/PUT /settings/menu_item_options/1.json
+  def update
+    respond_to do |format|
+      if @settings_menu_item_option.update(settings_menu_item_option_params)
+        format.html { redirect_to @settings_menu_item_option, notice: 'Menu item option was successfully updated.' }
+        format.json { render :show, status: :ok, location: @settings_menu_item_option }
+      else
+        format.html { render :edit }
+        format.json { render json: @settings_menu_item_option.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /settings/menu_item_options/1
+  # DELETE /settings/menu_item_options/1.json
+  def destroy
+    @settings_menu_item_option.destroy
+    respond_to do |format|
+      format.html { redirect_to settings_menu_item_options_url, notice: 'Menu item option was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_settings_menu_item_option
+      @settings_menu_item_option = Settings::MenuItemOption.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def settings_menu_item_option_params
+      params.require(:settings_menu_item_option).permit(:name, :value)
+    end
+end

app/controllers/settings/payment_method_settings_controller.rb

@@ -0,0 +1,74 @@
+class Settings::PaymentMethodSettingsController < ApplicationController
+  before_action :set_settings_payment_method_setting, only: [:show, :edit, :update, :destroy]
+
+  # GET /settings/payment_method_settings
+  # GET /settings/payment_method_settings.json
+  def index
+    @settings_payment_method_settings = Settings::PaymentMethodSetting.all
+  end
+
+  # GET /settings/payment_method_settings/1
+  # GET /settings/payment_method_settings/1.json
+  def show
+  end
+
+  # GET /settings/payment_method_settings/new
+  def new
+    @settings_payment_method_setting = Settings::PaymentMethodSetting.new
+  end
+
+  # GET /settings/payment_method_settings/1/edit
+  def edit
+  end
+
+  # POST /settings/payment_method_settings
+  # POST /settings/payment_method_settings.json
+  def create
+    @settings_payment_method_setting = Settings::PaymentMethodSetting.new(settings_payment_method_setting_params)
+
+    respond_to do |format|
+      if @settings_payment_method_setting.save
+        format.html { redirect_to @settings_payment_method_setting, notice: 'Payment method setting was successfully created.' }
+        format.json { render :show, status: :created, location: @settings_payment_method_setting }
+      else
+        format.html { render :new }
+        format.json { render json: @settings_payment_method_setting.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /settings/payment_method_settings/1
+  # PATCH/PUT /settings/payment_method_settings/1.json
+  def update
+    respond_to do |format|
+      if @settings_payment_method_setting.update(settings_payment_method_setting_params)
+        format.html { redirect_to @settings_payment_method_setting, notice: 'Payment method setting was successfully updated.' }
+        format.json { render :show, status: :ok, location: @settings_payment_method_setting }
+      else
+        format.html { render :edit }
+        format.json { render json: @settings_payment_method_setting.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /settings/payment_method_settings/1
+  # DELETE /settings/payment_method_settings/1.json
+  def destroy
+    @settings_payment_method_setting.destroy
+    respond_to do |format|
+      format.html { redirect_to settings_payment_method_settings_url, notice: 'Payment method setting was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_settings_payment_method_setting
+      @settings_payment_method_setting = Settings::PaymentMethodSetting.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def settings_payment_method_setting_params
+      params.require(:settings_payment_method_setting).permit(:payment_method, :is_active, :gateway_communication_type, :gateway_url, :auth_token, :merchant_account_id)
+    end
+end

app/controllers/settings/zones_controller.rb

@@ -0,0 +1,74 @@
+class Settings::ZonesController < ApplicationController
+  before_action :set_settings_zone, only: [:show, :edit, :update, :destroy]
+
+  # GET /settings/zones
+  # GET /settings/zones.json
+  def index
+    @settings_zones = Zone.all
+  end
+
+  # GET /settings/zones/1
+  # GET /settings/zones/1.json
+  def show
+  end
+
+  # GET /settings/zones/new
+  def new
+    @settings_zone = Zone.new
+  end
+
+  # GET /settings/zones/1/edit
+  def edit
+  end
+
+  # POST /settings/zones
+  # POST /settings/zones.json
+  def create
+    @settings_zone = Zone.new(settings_zone_params)
+
+    respond_to do |format|
+      if @settings_zone.save
+        format.html { redirect_to @settings_zone, notice: 'Zone was successfully created.' }
+        format.json { render :show, status: :created, location: @settings_zone }
+      else
+        format.html { render :new }
+        format.json { render json: @settings_zone.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /settings/zones/1
+  # PATCH/PUT /settings/zones/1.json
+  def update
+    respond_to do |format|
+      if @settings_zone.update(settings_zone_params)
+        format.html { redirect_to @settings_zone, notice: 'Zone was successfully updated.' }
+        format.json { render :show, status: :ok, location: @settings_zone }
+      else
+        format.html { render :edit }
+        format.json { render json: @settings_zone.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /settings/zones/1
+  # DELETE /settings/zones/1.json
+  def destroy
+    @settings_zone.destroy
+    respond_to do |format|
+      format.html { redirect_to settings_zones_url, notice: 'Zone was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_settings_zone
+      @settings_zone = Zone.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def settings_zone_params
+      params.require(:settings_zone).permit(:name, :is_active, :created_by)
+    end
+end