hippo-fw 0.9.1

data/lib/hippo/api/default_routes.rb

@@ -0,0 +1,38 @@
+require_relative "handlers/asset.rb"
+
+module Hippo
+    API.routes.draw do
+        # WS endpoint must come first
+        get Hippo.config.api_path + '/ws' do
+            API::Cable.handle_request(request)
+        end
+
+        Extensions.each(reversed: true) do | ext |
+            ext.route(self)
+        end
+
+        put Hippo.config.api_path + '/hippo/system-settings.json',
+            &SystemSettings.update_handler
+
+        get Hippo.config.api_path + '/hippo/system-settings.json',
+            &SystemSettings.get_handler
+
+        post Hippo.config.api_path + Hippo.config.assets_path_prefix,
+             &API::Handlers::Asset.saver
+
+        get Hippo.config.api_path + Hippo.config.assets_path_prefix + '/*',
+            &API::Handlers::Asset.getter
+
+        get Hippo.config.api_path + Hippo.config.print_path_prefix + '/:template_id/:model_id.pdf',
+            &API::Handlers::Print.getter
+
+        post Hippo.config.api_path + '/dev-file-change.json' do
+            API::PubSub.publish("file-change", data)
+            "OK"
+        end
+
+    end
+
+    # API.set_root_view :hippo_root_view
+
+end

data/lib/hippo/api/error_formatter.rb

@@ -0,0 +1,37 @@
+module Hippo
+    module API
+        module ErrorFormmater
+            extend self
+
+            def call(message, backtrace=nil, options=nil, env=nil)
+                {
+                 success: false, message: message,
+                 errors: { base: message }
+                }.to_json
+            end
+
+            def handle_exception(message, code, e)
+                Rack::Response.new([self.call(message)],
+                                   code, {"Content-type" => "application/json"}
+                                  ).finish
+                Hippo.logger.error e
+            end
+
+            def handle_fk_exception(e,model)
+                ( target, depends ) = e.message.scan(/on table \"(.*?)\"/).flatten.map do |table|
+                    table.gsub(/^hip_/, '').capitalize.singularize
+                end
+                Hippo::API::ErrorFormmater.handle_exception(
+                  "Unable to delete #{target}, still in use by #{depends}", 400, e
+                )
+            end
+
+            def handle_not_found_exception(e,model)
+                Hippo::API::ErrorFormmater.handle_exception(
+                  model.to_s.demodulize + " (or one of it's dependencies) was not found", 404, e
+                )
+            end
+
+        end
+    end
+end

data/lib/hippo/api/formatted_reply.rb

@@ -0,0 +1,62 @@
+module Hippo
+    module API
+        module FormattedReply
+            # json methods
+            # constructs a Hash with success, messages, and data keys and
+            # populates them appropriately
+
+            def std_api_reply(type, data, options = {})
+                json = {
+                    success: options[:success].nil? ? true : options[:success],
+                }
+                json[:errors] = options[:errors] if options[:errors]
+
+                if data.is_a?(ActiveRecord::Base)
+                    record_active_record_errors(data, json)
+                end
+                if options[:total_count]
+                    json[:total] = options.delete(:total_count)
+                end
+                json.merge(
+                    message: options[:message] || json_status_str(data, type.to_s.capitalize, json[:success]),
+
+                    data: json[:success] ? records_for_reply(data, type, options) : []
+                )
+            end
+
+            def record_active_record_errors(model, json = {})
+                return if model.errors.none?
+                json[:success] = false
+                json[:errors] ||= {}
+                model.errors.each{ | attr, message |
+                    json[:errors][attr] = message
+                }
+                json
+            end
+
+            # @return Array<Array> returns either an array of fields
+            def records_for_reply(data, type, options)
+                return [] if :destroy == type
+                if options[:format] == 'array'
+                    data.pluck(*requested_fields)
+                else
+                    data.as_json(options)
+                end
+            end
+
+            def json_status_str(record, type, success)
+                if success
+                    type + " succeeded"
+                elsif record
+                    msg = type + " failed"
+                    if record.is_a?(ActiveRecord::Base)
+                        msg += ": " + record.errors.full_messages.join("; ")
+                    end
+                else
+                    return "Record not found"
+                end
+            end
+
+        end
+    end
+end

data/lib/hippo/api/generic_controller.rb

@@ -0,0 +1,35 @@
+module Hippo
+    module API
+
+
+        class GenericController < ControllerBase
+
+            def show
+                perform_retrieval
+            end
+
+            def create
+                record  = model.from_attribute_data(data, current_user)
+                options = build_reply_options.merge(success: record.save)
+                std_api_reply(:create, record, options)
+            end
+
+            def update
+                if params[:id]
+                    perform_single_update
+                elsif data.is_a?(Array)
+                    perform_multiple_updates
+                end
+            end
+
+            def destroy
+                if params[:id]
+                    perform_single_destroy
+                elsif data.is_a?(Array)
+                    perform_multiple_destroy
+                end
+            end
+
+        end
+    end
+end

data/lib/hippo/api/handlers/asset.rb

@@ -0,0 +1,38 @@
+module Hippo::API::Handlers
+
+    class Asset
+
+        def self.saver
+            lambda do
+                model = params['owner_type'].underscore.camelize.constantize
+
+                authentication = Hippo::API::AuthenticationProvider.new(request)
+                authentication.wrap_model_access(model, self) do
+                    owner = model.find(params['owner_id'])
+                    asset = if params['id']
+                                ::Hippo::Asset.find(params['id'])
+                            else
+                                assoc = owner.class.reflections[
+                                    params['owner_association']
+                                ]
+                                if assoc.collection?
+                                    owner.send(params['owner_association']).build
+                                else
+                                    owner.send("build_#{params['owner_association']}")
+                                end
+                            end
+                    asset.file = params['file']
+                    json_reply std_api_reply asset.new_record? ? :update : :create,
+                                             asset, success: asset.save
+                end
+            end
+        end
+
+        def self.getter
+            root = Hippo::Extensions.controlling.root_path.join('public', 'files')
+            lambda do
+                send_file(root.join( params['splat'].first ).to_s)
+            end
+        end
+    end
+end

data/lib/hippo/api/handlers/print.rb

@@ -0,0 +1,15 @@
+module Hippo::API::Handlers
+
+    class Print
+        def self.getter
+            lambda do
+                template_klass = Hippo::Templates::Latex.for_identifier(params['template_id'])
+                status 404 and return if not template_klass
+
+                form = template_klass.new(params['model_id'])
+                content_type 'application/pdf'
+                form.as_pdf
+            end
+        end
+    end
+end

data/lib/hippo/api/handlers/user_session.rb

@@ -0,0 +1,42 @@
+require_relative '../../user'
+
+module Hippo::API::Handlers
+
+
+    module UserSession
+
+        def self.create
+            lambda do
+                wrap_reply(with_transaction: false) do
+                    user = Hippo::User.where(login: data['login']).first
+                    if user && user.authenticate(data['password'])
+                        { success: true, message: "Login succeeded",
+                          data: user.workspace_data.merge(token: user.jwt_token) }
+                    else
+                        { success: false, message: "Login failed", errors: { login: 'failed' }, data: {} }
+                    end
+                end
+            end
+        end
+
+
+        def self.check
+            lambda do
+                wrap_reply do
+                    user = Hippo::API::AuthenticationProvider.user_for_request(self)
+                    if user
+                        { success: true, message: "Login succeeded",
+                          data: user.workspace_data.merge(
+                              csrf: session[:csrf]
+                          )
+                        }
+                    else
+                        { success: true, message: "not logged in", errors: { login: 'none' }, data: {} }
+                    end
+                end
+            end
+        end
+
+    end
+
+end

data/lib/hippo/api/helper_methods.rb

@@ -0,0 +1,58 @@
+module Hippo
+    module API
+        module HelperMethods
+            def hippo_application_title
+                Extensions.controlling.title
+            end
+
+            def hippo_javascript_tags
+                []
+                # assets = API.webpack.assets.map do | k |
+                #     "<script src=\"http://localhost:#{API.webpack.port}/#{k}\"></script>"
+                # end
+                # assets.join("\n")
+
+                # "<script src=\"http://localhost:#{API.webpack.port}/hippo.js\"></script>"
+                # javascript_tag('hippo/vendor') + "\n" + javascript_tag('hippo')
+            end
+
+            def hippo_stylesheet_tags
+                # stylesheet_tag('hippo')
+            end
+
+            def client_bootstrap_data(mergedWith: {})
+                API.to_json(Extensions.client_bootstrap_data.merge(mergedWith))
+            end
+
+            def csrf_token
+                Rack::Csrf.csrf_token(env)
+            end
+
+            def hippo_api_url
+                Hippo.config.api_path
+            end
+
+            def error_as_json
+                Hippo.logger.warn request.env['sinatra.error']
+                API.to_json(
+                    success: false,
+                    errors:  { exception: request.env['sinatra.error'].message },
+                    message: request.env['sinatra.error'].message
+                )
+            end
+
+            def data
+                @json_data ||= Oj.load( request.body.read ) || {}
+            end
+
+            def request_origin
+                @request_origin ||= env['HTTP_ORIGIN']
+            end
+
+            def json_reply(response)
+                content_type 'application/json'
+                API.to_json(response)
+            end
+        end
+    end
+end

data/lib/hippo/api/pub_sub.rb

@@ -0,0 +1,36 @@
+require_relative 'cable'
+
+module Hippo
+    module API
+
+        class PubSub < Cable::Channel
+            PREFIX = 'ps:'
+
+            def on(data)
+                stream_from channel_prefix + data['channel']
+            end
+
+            def off(data)
+                channel = channel_prefix + data['channel']
+                cb = pubsub.instance_variable_get('@listener')
+                       .instance_variable_get('@subscribers')[channel].first
+                pubsub.unsubscribe(channel, cb)
+            end
+
+            def self.publish(channel, data)
+                channel = channel_prefix + channel
+           #     ActionCable.server.broadcast(channel, data.merge(channel: channel))
+            end
+
+            def self.channel_prefix
+                PREFIX
+            end
+
+            def channel_prefix
+                PREFIX
+            end
+
+        end
+
+    end
+end

data/lib/hippo/api/request_wrapper.rb

@@ -0,0 +1,105 @@
+module Hippo
+    module API
+
+        module RequestWrapper
+            class << self
+
+                def get(*args)
+                    make_handler(*args) do |controller|
+                        controller.show
+                    end
+                end
+
+                def post(*args)
+                    make_handler(*args) do |controller|
+                        controller.create
+                    end
+                end
+
+                def update(*args)
+                    make_handler(*args) do |controller|
+                        controller.update
+                    end
+                end
+
+                def delete(*args)
+                    make_handler(*args) do |controller|
+                        controller.destroy
+                    end
+                end
+
+                # @!visibility private
+                def make_handler(model, controller, options = {})
+                    lambda do
+                        authentication = Hippo::API::AuthenticationProvider.new(request)
+                        authentication.wrap_model_access(model, self, options) do
+                            if options[:parent_attribute]
+                              params[:nested_attribute] = Hash[ options[:parent_attribute],
+                                                               params[parent_attribute] ]
+                            end
+                            wrap_reply(options.reverse_merge(with_transaction: !request.get?)) do
+                                yield controller.new(model, authentication, params, data)
+                            end
+                        end
+                    end
+                end
+
+
+                # Ensure request is performed with a logged in user. The provided block will be called
+                # with |user, request|
+                #
+                # @param [options] options for additional checks
+                # @option options [String] :role A role name that the user must have
+                # @option opts [Boolean] :with_transaction rollback DB transaction if exceptions occur
+                #
+                def with_authenticated_user(options = {with_transaction: true})
+                    role = options[:role]
+                    lambda do
+                        authentication = Hippo::API::AuthenticationProvider.new(request)
+                        user = authentication.current_user
+                        if user && (role.nil? || user.roles.include?(role))
+                            wrap_reply(options) do
+                                yield authentication.current_user, self
+                            end
+                        else
+                            authentication.fail_request(self)
+                        end
+                    end
+                end
+            end
+
+            # Wraps a HTTP request in an optional DB transaction and converts yeilded data to JSON
+            #
+            # @param [options] options for additional checks
+            # @option opts [Boolean] :with_transaction rollback DB transaction if exceptions occur
+            def wrap_reply(options = {with_transaction: true})
+                response = { success: false, message: "No response was generated" }
+                log_request
+                if options[:with_transaction]
+                    Hippo::Model.transaction do
+                        response = yield || {success: false}
+                        # This is quite possibly a horrible idea.
+                        # It enables test specs to reset the db state after a request
+                        if !Hippo.env.production? && request.env['HTTP_X_ROLLBACK_AFTER_REQUEST']
+                            Hippo::Model.connection.rollback_db_transaction
+                        end
+                    end
+                else
+                    response = yield
+                end
+                if false == response[:success]
+                    status(406)
+                end
+                json_reply response
+            end
+
+            # Logs UserID and params for a request.  In non-production, the JSON payload is also logged
+            def log_request
+                Hippo.logger.info "UserID: #{session['user_id']}, Params: #{request.params}"
+                Hippo.logger.debug JSON.pretty_generate(data) unless Hippo.env.production? or data.nil?
+            end
+        end
+
+
+    end
+end