shoperb-theme-editor 0.8.0

data/lib/shoperb_theme_editor/mounter/server/routes.rb

@@ -0,0 +1,366 @@
+module Shoperb module Theme module Editor
+  module Mounter
+    class Server
+      module Routes
+        Editor.autoload_all self, "mounter/server/routes"
+
+        mattr_accessor :app
+
+        class << self
+          delegate :register, to: :app
+          delegate :get, to: :app
+          delegate :post, to: :app
+          delegate :patch, to: :app
+          delegate :put, to: :app
+          delegate :delete, to: :app
+          delegate :not_found, to: :app
+        end
+
+        def self.registered(app)
+          self.app = app
+          register_modules
+
+          get "/?:locale?/categories" do
+            scope = Model::Category.where
+            if params[:parent_id].present?
+              params[:parent_id] = Model::Category.find_by(handle: params[:parent_id]).id if params[:parent_id].to_i.eql?(0)
+              scope = scope.where(parent_id: params[:parent_id].to_i)
+            end
+            respond_to do |f|
+              f.json{
+                locals, registers = registers_and_locals
+                context = Liquid::Context.build(registers: registers)
+                children = params[:include].to_s.split("|").include?("children")
+                json scope.map{|el| el.to_liquid(context).as_json(incl_children: children) }
+              }
+              f.html{
+                respond :categories, categories: scope.map(&:to_liquid)
+              }
+            end
+          end
+
+          get "/?:locale?/categories/*" do
+            params[:id] = params[:splat][0]
+            drop = ShoperbLiquid::CategoryDrop.new(request.env[:current_category] = Model::Category.find_by(permalink: params[:id]))
+            @category = drop.record
+            respond :category, category: drop, meta: drop
+          end
+
+          get "/?:locale?/products/:id" do
+            product      = ShoperbLiquid::ProductDrop.new(record = Model::Product.find_by(permalink: params[:id])||Model::Product.new(name: "Product not found!", id: -1))
+            category     = product.category
+            template     = record.template.presence || :product
+            respond template.to_sym, product: product, category: category, meta: product
+          end
+
+          # params:
+          # * ids - to filter by variant ids
+          # * product_id - to filter by product_id
+          # * attrributes - hash to filter by attributes {not_translated_key: not_translated_value,..}
+          post "/?:locale?/variants" do
+            pars  = JSON.parse(request.body.string,symbolize_names: true)
+            scope = Model::Variant
+            scope = scope.where(id: pars[:ids].map(&:to_i)) if pars[:ids].present?
+            scope = scope.where(product_id: pars[:product_id].to_i) if pars[:product_id].present?
+
+            if pars[:attributes].present?
+              # for now lets just return some variants
+            end
+            pagy, scope = scope.paginate(pars[:page]||1, 10)
+            arr   = scope.to_a || []
+            arr   = arr.map{|i| i.to_liquid.as_json }.shuffle
+            resp  = {
+              variants: arr,
+              page: {
+                page:  pagy.page,
+                total: pagy.items,
+                pages: pagy.pages
+              }
+            }
+
+            if pars[:product_id].present? && pars.has_key?(:left_options)
+              # resp[:left_options] = left_options(params[:product_id])
+              v_ids = Model::Variant.
+                  where(product_id: pars[:product_id].to_i).
+                  available.
+                  map(&:id)
+              resp[:left_options] = {}
+
+              Model::VariantAttribute.
+                  where(variant_id: v_ids).
+                  each do |attr|
+                    # doing = true
+                    # pars[:attributes].to_h.each{|k,v|
+                    #   doing=false if attr.name == k.to_s && attr.value == v
+                    # }
+                    # if doing
+                    resp[:left_options][attr.name] ||= []
+                    resp[:left_options][attr.name] |= [attr.value]
+                    # end
+              end
+            end
+
+            json resp
+          end
+
+          get "/?:locale?/product-filters" do
+            products = Model::Product.where
+            if params[:category].present?
+              obj      = Model::Category.find_by(handle: params[:category])
+              products = products.where(category_id: obj.self_and_descendants.map(&:id))
+            end
+            if params[:collection].present?
+              obj      = Model::Collection.find_by(handle: params[:collection])
+              products = products.where(id: obj.product_ids)
+            end
+
+            context = OpenStruct.new(products: products.map(&:to_liquid))
+            tag     = ShoperbLiquid::ProductsFilterTag.send(:new,"","",OpenStruct.new)
+            json tag.facets(context)[params[:attribute]].to_h["values"].to_h
+          end
+
+          get "/?:locale?/products/:id/reviews" do
+            product  = ShoperbLiquid::ProductDrop.new(record = Model::Product.find_by(permalink: params[:id]))
+            category = product.category
+            reviews  = product.reviews
+            respond :reviews, product: product, category: category, meta: product, reviews: reviews
+          end
+
+          get "/?:locale?/cart" do
+            respond :cart
+          end
+
+          get "/?:locale?/" do
+            respond [:home, :index, :frontpage]
+          end
+
+          get "/?:locale?/login" do
+            respond :login
+          end
+
+          post "/?:locale?/login" do
+            respond :login
+          end
+
+          get "/?:locale?/signup" do
+            respond :signup
+          end
+
+          get "/?:locale?/recover" do
+            respond :password_request
+          end
+
+          get "/?:locale?/reset" do
+            respond :password_change
+          end
+
+          get "/?:locale?/account" do
+            respond :account
+          end
+
+
+          get "/?:locale?/account/billing/payment-methods" do
+            respond :billing_payment_methods, payment_methods: [Model::PaymentCard.first.to_liquid]
+          end
+          get "/?:locale?/account/billing/payment-methods/add" do
+            meth     = Model::PaymentCard.new.to_liquid
+            provider = Model::PaymentProvider.first.to_liquid
+            respond :billing_payment_method, payment_method: meth, providers: [provider]
+          end
+          post "/?:locale?/account/billing/payment-methods" do # create action
+            redirect "/account/billing/payment-methods"
+          end
+          get "/?:locale?/account/billing/payment-methods/:id" do
+            respond :billing_payment_method, payment_method: Model::PaymentCard.first.to_liquid
+          end
+          get "/?:locale?/account/billing/payment-methods/:id/delete" do
+            redirect "/account/billing/payment-methods"
+          end
+
+          get "/?:locale?/account/subscriptions" do
+            respond :billing_subscriptions, subscriptions: ShoperbLiquid::CollectionDrop.new(Model::CustomerSubscription.all.map{|e| ShoperbLiquid::SubscriptionDrop.new(e)})
+          end
+          get "/?:locale?/account/subscriptions/plans" do
+            respond :billing_subscription_plans, subscription: ShoperbLiquid::Subscription.new(Model::CustomerSubscription.all.detect(&:active?))
+          end
+          get "/?:locale?/account/subscriptions/create/?:plan_id?" do
+            subscription = Model::CustomerSubscription.new
+            subscription.plan_id       = params[:plan_id]
+            subscription.instance_variable_set(:@attributes,
+              subscription.attributes.merge(params.fetch(:subscription,{}).slice(:qty))
+            )
+            subscription.customer      = current_customer
+
+            flash[:notice] = "subscription.error_occured"
+            respond :billing_subscription, subscription: subscription, payment_methods: [Model::PaymentCard.first], providers: [Model::PaymentProvider.first.to_liquid]
+          end
+          get "/?:locale?/account/subscriptions/:id/delete" do
+            flash[:notice] = "subscription.deleted"
+            redirect_to "/account/subscriptions/plans"
+          end
+
+          get "/?:locale?/reset/:token" do
+            respond :password_change
+          end
+
+          not_found do
+            respond :not_found
+          end
+
+          get "/?:locale?/brands" do
+            respond :brands
+          end
+
+          get "/?:locale?/brands/:id" do
+            drop = ShoperbLiquid::VendorDrop.new(Model::Vendor.find(id: params[:id]))
+            respond :brand, vendor: drop, brand: drop, meta: drop
+          end
+
+          get "/?:locale?/blog" do
+            respond :blog_posts, posts: ShoperbLiquid::CollectionDrop.new(Model::BlogPost.active)
+          end
+
+          get "/?:locale?/blog/:id" do
+            post = Model::BlogPost.find_by(permalink: params[:id])
+            template = post.template.presence || :blog_post
+            respond template, post: post, meta: post
+          end
+
+          get "/?:locale?/order-returns" do
+            respond :order_returns, order_returns: ShoperbLiquid::OrderReturnsDrop.new(Model::OrderReturn.dataset)
+          end
+          post "/?:locale?/order-returns" do
+            redirect "/order-returns"
+          end
+          get "/?:locale?/order-returns/new" do
+            respond :order_return, order_return: Model::OrderReturn.new.to_liquid, orders: ShoperbLiquid::OrdersDrop.new(Model::Order.all.to_a[0..10])
+          end
+          get "/?:locale?/order-returns/:id" do
+            respond :order_return, order_return: Model::OrderReturn.find(id: params[:id])&.to_liquid
+          end
+          post "/?:locale?/order-returns/:id/generate-parcel" do
+            respond :order_return, order_return: Model::OrderReturn.find(id: params[:id])&.to_liquid
+          end
+
+          get "/?:locale?/addresses/new" do
+            respond :address, address: ShoperbLiquid::AddressDrop.new(Model::Address.new)
+          end
+
+          post "/?:locale?/addresses" do
+            respond :address, address: ShoperbLiquid::AddressDrop.new(Model::Address.new(params[:address]))
+          end
+
+          patch "/?:locale?/addresses/:id" do
+            respond :address, address: ShoperbLiquid::AddressDrop.new(current_customer.addresses.detect { |address| address.id.to_s == params[:id].to_s })
+          end
+
+          put "/?:locale?/addresses/:id" do
+            respond :address, address: ShoperbLiquid::AddressDrop.new(current_customer.addresses.detect { |address| address.id.to_s == params[:id].to_s })
+          end
+
+          get "/?:locale?/addresses/:id/delete" do
+            redirect_to "/addresses"
+          end
+
+          get "/?:locale?/emails" do
+            out  = "<p>You have next templates:</p>"
+            out += "<ul>"
+            Dir["emails/*"].each do |file|
+              url  = file.sub(".liquid","")
+              out += %Q{<li><a href="#{url}">#{url}</a></li>}
+            end
+            out + "</ul>"
+          end
+
+          get "/?:locale?/emails/:template" do
+            entities = {}
+            order = if params[:order_id]
+              Model::Order.find(id: params[:order_id])
+            else
+              Model::Order.first
+            end
+            entities.merge!(order: ShoperbLiquid::OrderDrop.new(order))
+            customer = if order
+              order.customer
+            elsif params[:customer_id]
+              Model::Customer.find(id: params[:order_id])
+            else
+              Model::Customer.last
+            end
+            entities.merge!(customer: ShoperbLiquid::CustomerDrop.new(customer))
+            tpl = params[:template]
+
+            content_type "text/plain" if tpl.end_with?(".text")
+            respond_email tpl, entities
+          end
+
+          post "/?:locale?/reviews" do
+            redirect "/products/#{params['review']['product_id']}"
+          end
+
+          append_paths
+        end
+
+        private
+
+        def self.register_modules
+          register Assets
+          register Defaults
+          register Locale
+          register Pages
+          register Cart
+          register Search
+          register Server::Renderer
+        end
+
+        def self.append_paths
+          resource Model::Collection do
+            ShoperbLiquid::ProductCollectionDrop.new(Model::Collection.find_by(permalink: params[:id]))
+          end
+
+          resources Model::Collection do
+            ShoperbLiquid::CollectionDrop.new(Model::Collection.all)
+          end
+
+          resource Model::Order do
+            ShoperbLiquid::OrderDrop.new(Model::Order.find(id: params[:id]) || Model::Order.find(number: params[:id]))
+          end
+
+          resources Model::Order do
+            ShoperbLiquid::CollectionDrop.new(Model::Order.all)
+          end
+
+          resources Model::Product do
+            ShoperbLiquid::ProductsDrop.new(Model::Product.active)
+          end
+
+          resources Model::Address do
+            ShoperbLiquid::CollectionDrop.new(current_customer.addresses)
+          end
+
+          resource Model::Address do
+            ShoperbLiquid::AddressDrop.new(current_customer.addresses.detect { |address| address.id.to_s == params[:id].to_s })
+          end
+        end
+
+        def self.resource collection, &block
+          name = collection.to_s.demodulize.underscore
+          get "/?:locale?/#{name.pluralize}/:id" do
+            drop = instance_exec(&block)
+            instance_variable_set("@#{name}", drop.record)
+
+            respond name, name => drop, :meta => drop
+          end
+        end
+
+        def self.resources collection, &block
+          name = collection.to_s.demodulize.underscore.pluralize
+          get "/?:locale?/#{name}" do
+            respond name, name => instance_exec(&block)
+          end
+        end
+
+      end
+    end
+  end
+end end end

data/lib/shoperb_theme_editor/mounter/server/routes_helper.rb

@@ -0,0 +1,278 @@
+module Shoperb module Theme module Editor
+  module Mounter
+    class Server
+      module RoutesHelper
+        extend self
+
+        def store_root_path(**_)
+          "/"
+        end
+
+        def store_signup_path(**_)
+          "/signup"
+        end
+
+        def store_login_path(**_)
+          "/login"
+        end
+
+        def store_new_login_path(**_)
+          "/login"
+        end
+
+        def store_logout_path(**_)
+          "/logout"
+        end
+
+        def store_recover_password_path(**_)
+          "/recover"
+        end
+
+        def store_new_recover_password_path(**_)
+          "/recover"
+        end
+
+        def store_reset_password_path(**_)
+          "/reset"
+        end
+
+        def store_upd_reset_password_path(**_)
+          "/reset"
+        end
+
+        def store_account_path(**_)
+          "/account"
+        end
+
+        def add_store_account_billing_payment_methods_path(**_)
+          "/account/billing/payment-methods/add"
+        end
+
+        def store_account_billing_payment_methods_path(**_)
+          "/account/billing/payment-methods"
+        end
+
+        def store_account_billing_payment_method_path(id, **_)
+          "/account/billing/payment-methods/#{id}"
+        end
+
+        def delete_store_account_billing_payment_method_path(id, **_)
+          "/account/billing/payment-methods/#{id}/delete"
+        end
+
+        def store_account_subscriptions_path(**_)
+          "/account/subscriptions"
+        end
+
+        def store_account_subscription_plans_path(**_)
+          "/account/subscriptions/plans"
+        end
+
+        def store_account_create_subscription_path(plan_id = nil,**_)
+          str  = "/account/subscriptions/create"
+          str += "/#{plan_id}" if plan_id
+          str
+        end
+
+        def store_account_delete_subscription_path(id,**_)
+          "/account/subscriptions/#{id}/delete"
+        end
+
+        def store_address_path(obj, **_)
+          id = get_id(obj)
+          "/addresses/#{id}"
+        end
+
+        def new_store_address_path(**_)
+          "/addresses/new"
+        end
+
+        def store_addresses_path(**_)
+          "/addresses"
+        end
+
+
+        def delete_store_address_path(id,**_)
+          "/addresses/#{id}/delete"
+        end
+
+        def store_brand_path(obj, **_)
+          id = get_id(obj)
+          "/brands/#{id}"
+        end
+
+        def store_brands_path(**_)
+          "/brands"
+        end
+
+        def store_category_path(obj, **_)
+          id = get_id(obj)
+          "/categories/#{id}"
+        end
+
+        def store_categories_path(**_)
+          "/categories"
+        end
+
+        def store_checkout_order_url(obj, **_)
+          id = get_id(obj)
+          "/checkout/#{id}"
+        end
+
+        def store_collection_path(obj, **_)
+          id = get_id(obj)
+          "/collections/#{id}"
+        end
+
+        def store_collections_path(**_)
+          "/collections"
+        end
+
+        def store_order_path(obj, **_)
+          id = get_id(obj)
+          "/orders/#{id}"
+        end
+
+        def store_orders_path(**_)
+          "/orders"
+        end
+
+        def store_page_path(obj, **_)
+          id = get_id(obj)
+          "/pages/#{id}"
+        end
+
+        def store_pages_path(**_)
+          "/pages"
+        end
+
+        def store_product_path(obj, **_)
+          id = get_id(obj)
+          "/products/#{id}"
+        end
+
+        def store_product_url(obj, **_)
+          "https://#{shop.domain}/#{Translations.locale}/products/#{get_id(obj)}"
+        end
+
+        def reviews_store_product_path(obj, **_)
+          "/products/#{get_id(obj)}/reviews"
+        end
+
+        def store_products_path(**_)
+          "/products"
+        end
+
+        def store_variants_path(**_)
+          "/variants"
+        end
+
+        def store_reviews_path(**_)
+          "/reviews"
+        end
+
+        def store_subscribers_add_path(**_)
+          "/subscribers/add"
+        end
+
+        def store_search_path(**_)
+          "/search"
+        end
+
+        def store_blog_post_path(obj, **_)
+          id = get_id(obj)
+          "/blog/#{id}"
+        end
+
+        def store_blog_posts_path(**_)
+          "/blog"
+        end
+
+        def store_cart_path(**_)
+          "/cart"
+        end
+        def store_carts_path(**_)
+          "/carts"
+        end
+
+        def add_store_cart_path(**_)
+          "/cart/add"
+        end
+
+        def update_store_cart_path(**_)
+          "/cart/update"
+        end
+
+        def checkout_store_cart_path(**_)
+          "/cart/checkout"
+        end
+
+        def add_store_multi_cart_path(obj,**_)
+          "/cart/#{get_id(obj)}/add"
+        end
+
+        def update_store_multi_cart_path(obj,**_)
+          "/cart/#{get_id(obj)}/update"
+        end
+
+        def checkout_store_multi_cart_path(obj,**_)
+          "/cart/#{get_id(obj)}/checkout"
+        end
+
+        def store_order_returns_path(**_)
+          "/order-returns"
+        end
+
+        def new_store_order_return_path(**_)
+          "/order-returns/new"
+        end
+
+        def store_order_return_path(id, **_)
+          "/order-returns/#{id}"
+        end
+
+        def store_order_return_generate_parcel_path(id, **_)
+          "/order-returns/#{id}/generate-parcel"
+        end
+
+        def recognize_path(**args)
+          url_for(**args)
+        end
+
+        def url_for(**args)
+        end
+
+        private
+
+        def get_id(obj)
+          case obj
+          when Numeric then obj
+          when String then obj
+          when NilClass then raise StandardError.new("missing argument for building path")
+          else
+            obj.try(:permalink) || obj.try(:to_param) || obj.try(:id)
+          end
+        end
+
+        def self.after(*names)
+          names.each do |name|
+            m = instance_method(name)
+            define_method(name) do |*args, &block|
+              res = m.bind(self).(*args, &block)
+              yield(res, *args)
+            end
+          end
+        end
+
+        after(*instance_methods) do |res, **args|
+          if res.try(:start_with?, "http")
+            res
+          else
+            locale = args.symbolize_keys[:locale] || Translations.locale
+            "/#{locale}#{res}"
+          end
+        end
+      end
+    end
+  end
+end end end

data/lib/shoperb_theme_editor/mounter/server.rb

@@ -0,0 +1,66 @@
+Sinatra.autoload :Flash, "sinatra/flash"
+Sinatra.autoload :RespondWith,"sinatra/respond_with"
+
+Tilt::Template.class_eval do
+  def require_template_library(name)
+    # Silence the warning
+    require name
+  end
+end
+
+module Shoperb module Theme module Editor
+  module Mounter
+    class Server < Sinatra::Base
+      Editor.autoload_all self, "mounter/server"
+
+      include Server::RoutesHelper
+
+      set :root, Dir.pwd
+      set :environment, :development
+
+      use ExceptionHandler
+      register Renderer
+      register Routes
+
+      helpers do
+        def current_cart
+          Model::Cart.first || Model::Cart.new
+        end
+
+        def current_carts
+          current_cart.id ? Model::Cart.all : []
+        end
+
+        def shop
+          Model::Shop.first || raise(Error.new("No data has been synced."))
+        end
+
+        def current_customer
+          if (id = params[:customer_id].to_i) > 0
+            Model::Customer.find(id: id)
+          else
+            Model::Customer.first || Model::Customer.new(first_name: "No customer", last_name: "in customers.yml")
+          end
+        end
+
+        def current_settings
+          Editor.theme_settings
+        end
+
+        # so far in liquid it's used to replace locale only
+        # theme setting link, but we will skip it for now.
+        # just minimum required implementation.
+        def url_for(*args_main, **args)
+          args_main.each do |arg|
+            arg.each{|k,v| args[k] = v}
+          end
+          request.fullpath.gsub(/\A(?=#{shop.all_languages.map{|s|"/#{s}"}.join("|")}|)\/(.*)/, "/#{args[:locale]}/\\1") if args[:locale]
+        end
+
+        def form_authenticity_token
+          "token"
+        end
+      end
+    end
+  end
+end end end