backframe 0.0.49 → 1.0.0

data/lib/backframe/response/adapter/csv.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module Backframe
+
+  class Response
+
+    module Adapter
+
+      class Csv
+
+        class << self
+
+          def render(collection, fields, separator = ",")
+            records = []
+            labels = []
+            fields.array.each do |field|
+              labels << field[:label]
+            end
+            records << labels.join(separator)
+            collection.records.each do |item|
+              serialized = ActiveModelSerializers::SerializableResource.new(item).serializable_hash
+              record = []
+              fields.array.each do |field|
+                record << Backframe::Response::Record.get_value(serialized, field[:key])
+              end
+              records << record.join(separator)
+            end
+            records.join("\n")
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/backframe/response/adapter/json.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Backframe
+
+  class Response
+
+    module Adapter
+
+      class Json
+
+        class << self
+
+          def render(collection, fields)
+            data = {
+              records: [],
+              total_records: collection.total_records,
+              current_page: collection.current_page,
+              total_pages: collection.total_pages
+            }
+            collection.records.each do |item|
+              serialized = ActiveModelSerializers::SerializableResource.new(item).serializable_hash
+              if fields.any?
+                record = {}
+                fields.array.each do |field|
+                  obj = record
+                  parts = field[:key].split(".")
+                  value = Backframe::Response::Record.get_value(serialized, field[:key])
+                  parts.each_with_index do |part, index|
+                    if index == parts.size - 1
+                      obj[part.to_sym] = value
+                    else
+                      obj[part.to_sym] ||= {}
+                      obj = obj[part.to_sym]
+                    end
+                  end
+                end
+                data[:records] << record
+              else
+                data[:records] << serialized
+              end
+            end
+            data
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/backframe/response/adapter/xlsx.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module Backframe
+
+  class Response
+
+    module Adapter
+
+      class Xlsx
+
+        class << self
+
+          def render(collection, fields)
+            filename = SecureRandom.hex(32).to_s.upcase[0,16]
+            workbook = WriteXLSX.new(filename)
+            worksheet = workbook.add_worksheet
+            fields.array.each_with_index do |field, i|
+              worksheet.write_string(0, i, field[:label])
+            end
+            collection.records.each_with_index do |item, i|
+              serialized = ActiveModelSerializers::SerializableResource.new(item).serializable_hash
+              fields.array.each_with_index do |field, j|
+                value = Backframe::Response::Record.get_value(serialized, field[:key])
+                worksheet.write_string((i + 1), j, value.to_s)
+              end
+            end
+            workbook.close
+            output = open(filename).read
+            File.unlink(filename)
+            output
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/backframe/response/adapter/xml.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Backframe
+
+  class Response
+
+    module Adapter
+
+      class Xml
+
+        class << self
+
+          def render(collection, fields)
+            output  = '<?xml version="1.0"?>'
+            output += "<records>"
+            collection.records.each do |item|
+              serialized = ActiveModelSerializers::SerializableResource.new(item).serializable_hash
+              output += "<record>"
+              fields.array.each do |field|
+                value = Backframe::Response::Record.get_value(serialized, field[:key])
+                output += "<#{field[:key]}>#{value}</#{field[:key]}>"
+              end
+              output += "</record>"
+            end
+            output += "</records>"
+            output
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/backframe/response/collection.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module Backframe
+
+  class Response
+
+    class Collection
+
+      def initialize(collection, page, per_page)
+        @collection = collection
+        @page = page
+        @per_page = per_page
+      end
+
+      def total_records
+        @collection.count
+      end
+
+      def total_pages
+        @page ? (total_records / @per_page.to_f).ceil : 1
+      end
+
+      def current_page
+        @page ? [total_pages, @page.to_i].min : 1
+      end
+
+      def limit
+        @page ? @per_page : total_records
+      end
+
+      def offset
+        @page ? limit * (@page - 1) : 0
+      end
+
+      def records
+        @page ? @collection.limit(limit).offset(offset) : @collection.all
+      end
+
+    end
+
+  end
+
+end

data/lib/backframe/response/fields.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module Backframe
+
+  class Response
+
+    class Fields
+
+      def initialize(collection, fields)
+        @collection = collection
+        @fields = fields
+      end
+
+      def any?
+        !@fields.nil?
+      end
+
+      def array
+        return @array if defined?(@array)
+        hash = ActiveModelSerializers::SerializableResource.new(@collection.first).serializable_hash
+        keys = keys(hash)
+        @array = []
+        if @fields.nil?
+          keys.each do |key|
+            @array << { label: key, key: key }
+          end
+        else
+          @fields.split(",").each do |token|
+            field = nil
+            if token =~ /([\w\s]*):([\w\s\.]*)/
+              field = { label: $1.strip, key: $2.strip }
+            elsif token =~ /([\w\s\.]*)/
+              field = { label: $1.strip, key: $1.strip }
+            end
+            if keys.include?(field[:key])
+              @array << field
+            end
+          end
+        end
+        @array
+      end
+
+      private
+
+      def keys(hash, prefix = '')
+        keys = []
+        hash.each do |key, value|
+          fullkey =  (!prefix.empty?) ? "#{prefix}.#{key}" : key
+          if value.is_a?(Hash)
+            keys.concat(keys(value, fullkey))
+          else
+            keys << fullkey.to_s
+          end
+        end
+        keys
+      end
+
+    end
+
+  end
+
+end

data/lib/backframe/response/record.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module Backframe
+
+  class Response
+
+    class Record
+
+      class << self
+
+        def get_value(record, path)
+          path = cast_path(path)
+          index = 0
+          length = path.length
+          while record != nil && index < length
+            record = record.with_indifferent_access[path[index]]
+            index += 1
+          end
+          record
+        end
+
+        def cast_path(path)
+          if path.is_a?(String)
+            path.split(".")
+          elsif path.is_a?(Symbol)
+            path.to_s.split(".")
+          elsif path.is_a?(Array)
+            path
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/backframe/service.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+module Backframe
+
+  class Service
+
+    class << self
+
+      def build(*args)
+        new(*args)
+      end
+
+      def perform(*args)
+        service = build(*args)
+
+        message = nil
+        errors = {}
+        result = nil
+
+        ActiveRecord::Base.transaction do
+          begin
+            result = service.perform
+          rescue StandardError => e
+            message = e.message
+            # errors = e.errors
+            service.before_rollback
+            raise ActiveRecord::Rollback
+          end
+          service.before_commit
+        end
+
+        if message.nil?
+          service.after_commit
+        else
+          service.after_rollback
+        end
+
+        return (message.present?) ? Result::Failure.new(message: message, errors: errors) : Result::Success.new(result)
+      end
+
+    end
+
+    def perform
+    end
+
+    def before_rollback
+    end
+
+    def after_rollback
+    end
+
+    def before_commit
+    end
+
+    def after_commit
+    end
+
+  end
+
+end

data/lib/backframe/service/result/base.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Backframe
+
+  class Service
+
+    module Result
+
+      class Base
+
+        def initialize(*args)
+          args[0].each do |key, val|
+            self.class.send(:attr_accessor, key)
+            self.instance_variable_set("@#{key}", val)
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/backframe/service/result/failure.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Backframe
+
+  class Service
+
+    module Result
+
+      class Failure < Base
+
+        def success?
+          false
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/backframe/service/result/success.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Backframe
+
+  class Service
+
+    module Result
+
+      class Success < Base
+
+        def success?
+          true
+        end
+
+      end
+
+    end
+
+  end
+
+end