sinatra-hexacta 0.0.2 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acbebd0dade426417f396054c4d2e277402fc59cbad3b7e27c248a193e59859d
-  data.tar.gz: beaf9fcfffa445c4b7f39e49be20132bf8103199dc972b4b1235d89280e6c4b6
+  metadata.gz: a6fb503a8966bb24d1526acd9e44a6b8f798967193f7b5c465c61b86c4eb4d76
+  data.tar.gz: 1896cd47708d90de659d4e7d5253d3588331fd2372234c7c1bc152783bbd75ff
 SHA512:
-  metadata.gz: 9b374e1e2f8106c23168de0312034f4dab4669d11582f51e935ed436eab1b7f1965fd1963f3fc64a39de16f199c19ad3948655de3f04fb1b77d8c64a17aac186
-  data.tar.gz: 268e659e4ae71122214d640c33a4c5e3a2cc6a5f1338aa6659633a18673671278ec1752d19ecd9febc1988ba632c7d836d751915544811c11fec8e4f64e72bfa
+  metadata.gz: 2cbd2de133ebff3475d3d8f398d6588d264d6d310194b150e45a061a7d094f03dfe7288ef5b27bc1d9cecf663504fd793e0d0da9c9d47852ce327f04c5fc1e0b
+  data.tar.gz: ff26fc925028c9a03ca3af480c9292ed8a6ba6f463180d39625fb5a6ed896d13570f41e786a9d4038235ddfd950234e0e1ef402ee8be17085e8a8eb3670319c4

data/lib/sinatra/extensions/antiquity.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+class Antiquity
+
+  def initialize(periods)
+    @periods = periods.sort { |a,b| a.start_date <=> b.start_date }
+  end
+
+  def days
+    @periods.inject(0) { |total, period| total + period.days }
+  end
+
+  def months
+    @periods.inject(0) { |total, period| total + period.months }
+  end
+
+  def years
+    months.divmod(12).first
+  end
+
+  def to_s
+    date = (@periods.last && @periods.last.end_date) || Date.today
+    result = ""
+    return result if @periods.empty?
+    if date >= @periods.first.start_date
+      result += years > 1 ? "#{years} años" : "#{years} año" unless years == 0
+      result += ", " if years >= 1 && !(months.modulo(12).eql?(0))
+      result += months.modulo(12) > 1 ? "#{months.modulo(12)} meses" : "#{months.modulo(12)} mes" unless months.modulo(12) == 0
+      result += "#{(date - @periods.last.start_date).to_i} dias" if months.modulo(12) == 0 && years == 0 && date > @periods.last.start_date
+      result += "Hoy!" if months.modulo(12) == 0 && date == @periods.last.start_date
+    end
+    result += "En unos días..." if date < @periods.first.start_date
+    result
+  end
+end

data/lib/sinatra/extensions/date.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+class Date
+
+  def self.year(year=Date.today.year)
+    Date.new(year)
+  end
+
+  def january(day=nil)
+    day.nil?? self.change(month: 1) : self.change(month: 1, day: day)
+  end
+
+  def october(day=nil)
+    day.nil?? self.change(month: 10) : self.change(month: 10, day: day)
+  end
+
+  def december(day=nil)
+    day.nil?? self.change(month: 12) : self.change(month: 12, day: day)
+  end
+
+  def monday
+    self - (self.wday - 1) % 7
+  end
+
+  def weekend?
+    self.wday == 0 || self.wday == 6
+  end
+
+  def display
+    "#{Configuration::DAYS[self.wday]} #{self.day} de #{Configuration::MONTHS[self.month-1]} #{self.year == Date.today.year ? '' : self.year}"
+  end
+
+  def short_display
+    self.strftime('%d/%m/%Y')
+  end
+
+  def next_working_date
+    add_working_days(1)
+  end
+
+  def prev_working_date
+    add_working_days(-1)
+  end
+
+  def first_monday_before
+    return self if self.monday?
+    (self - 1).first_monday_before
+  end
+
+end

data/lib/sinatra/extensions/generalmail.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+class GeneralMail < Mail
+  
+  def initialize(args)
+    super(args)
+    @subject = args[:subject]
+    @description = args[:description]
+    @link = args[:link]
+  end
+
+  def template
+    'general'
+  end
+
+  def subject
+    @subject
+  end
+
+  def values
+    data = {}
+    data["{description}"] = @description
+    data["{link}"] = @link
+    data
+  end
+
+end

data/lib/sinatra/extensions/init.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+require_relative 'date'
+require_relative 'antiquity'
+require_relative 'notification'
+require_relative 'mailsender'
+require_relative 'mail'
+require_relative 'generalmail'
+require_relative 'mailbuilder'

data/lib/sinatra/extensions/mail.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+class Mail
+
+  def initialize(args)
+    @receivers = args[:to]
+    @sender = args[:from]
+  end
+
+  def template
+    raise Exception, "You have to override 'template' method in #{self.class}"
+  end
+
+  def subject
+    raise Exception, "You have to override 'subject' method in #{self.class}"
+  end
+
+  def values
+    raise Exception, "You have to override 'values' method in #{self.class}"
+  end
+
+  def to
+    _receivers = {}
+    @receivers.each { |user| _receivers[user.full_name] = "Persons" }
+    _receivers
+  end
+
+  def from 
+    @sender ||= "apps@hexacta.com"
+  end
+
+  def send
+    MailSender.perform_async(self)
+  end
+
+end

data/lib/sinatra/extensions/mailbuilder.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+class MailBuilder
+
+  def to(receivers)
+    @to = receivers
+    return self
+  end
+
+  def from(sender)
+    @from = "#{sender.hxt_id}@hexacta.com"
+    return self
+  end
+
+  def subject(a_subject)
+    @subject = a_subject
+    return self
+  end
+
+  def description(a_description)
+    @description = a_description
+    return self
+  end
+
+  def link(a_link)
+    @link = a_link
+    return self
+  end
+
+  def send
+    @from ||= "apps@hexacta.com"
+    GeneralMail.new({ :to => @to,
+                      :from => @from,
+                      :subject => @subject,
+                      :description => @description,
+                      :link => @link
+                    }).send
+  end
+end

data/lib/sinatra/extensions/mailsender.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+require 'singleton'
+require 'sucker_punch'
+
+class MailSender
+  include SuckerPunch::Job
+
+  attr_reader :access_token, :expire, :refresh_token
+
+  def _do_connect(uri, form={},token=nil)
+    url = URI.parse("#{uri}")
+    http = Net::HTTP.new(url.host, url.port)
+    http.read_timeout = 1000
+    http.use_ssl = (url.scheme == 'https')
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    header = { 'Content-Type' => 'application/x-www-form-urlencoded' }
+    header["Authorization"] = "Bearer #{token}" unless token.nil?
+    request = Net::HTTP::Post.new(url, header)
+    request.form_data = form
+    http.start { |http| http.request(request) }
+  end
+
+  def _authorize_mail
+    params = [ [ "grant_type", "password" ], [ "client_id", "MailApp" ], [ "client_secret", "MailAppPRD2018!" ] ]
+    response = _do_connect("https://comunicacion.hexacta.com:4443/apptoken",params)
+    if( response.is_a?( Net::HTTPSuccess ) )
+      token = JSON.parse(response.body)
+      @access_token = token["access_token"]
+      @refresh_token = token["refresh_token"]
+      @expire  = DateTime.parse(token[".expires"])
+    else
+      NotificationSender.instance.send_error(nil,'Authorize mail failed',response.body)
+    end
+  end
+
+  def _build_map_values(mail_values)
+    values = []
+    for key in mail_values.keys
+      index = mail_values.keys.index(key)
+      values << ["MailValues[#{index}].Key", key]
+      values << ["MailValues[#{index}].Value", mail_values[key]]
+    end
+    values
+  end
+
+  def _build_to_map(to_map)
+    values = []
+    for key in to_map.keys
+      index = to_map.keys.index(key)
+      values << ["ResourcesRequest[#{index}].TypeGroup", to_map[key]]
+      values << ["ResourcesRequest[#{index}].Name", key]
+    end
+    values
+  end
+
+  def _expired?
+    expire.nil? || DateTime.now < expire
+  end
+
+  def do_send(mail)
+    begin
+      if _expired?
+        _authorize_mail
+      end
+
+      params = [ [ "ApplicationCode", 2009 ], [ "Name", mail.template ], [ "Subject", mail.subject ], [ "EmailAddress", mail.from ] ]
+      params = params + _build_map_values(mail.values) + _build_to_map(mail.to)
+
+      response = _do_connect("https://comunicacion.hexacta.com:4444/api/app/TemplateNotification/SendMail",params,@access_token)
+
+      if( !response.is_a?( Net::HTTPSuccess ) )
+        NotificationSender.instance.send_error(nil,'Send mail failed',response.body)
+      end
+    rescue StandardError => error
+      message = error.backtrace.join(',');
+      NotificationSender.instance.send_error(nil,"Mail send error",message)
+    end
+  end
+
+  def send(mail)
+    run(mail) #Async call
+  end
+
+  #For async method call
+  def perform(mail)
+    do_send(mail)
+  end
+end

data/lib/sinatra/extensions/notification.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+require 'singleton'
+
+class NotificationSender
+  include Singleton
+
+  def send_to(user,creator,title,message,label,link=nil)
+    notification = Notification.find_or_create(:user_id => user.id,
+                                :creator_id => creator.id,
+                                :title => title,
+                                :message => message,
+                                :label => label,
+                                :link => link,
+                                :creation_date => Date.today)
+    if link.nil?
+      notification.link = "/notifications/#{notification.id}"
+      notification.save
+    end
+    notification
+  end
+
+  def send_to_subscriptors(creator,title,message,label,link=nil)
+    Subscription.where(:label => label).all.each do |subscription|
+      notification = send_to(subscription.user,creator,title,message,label,link)
+    end
+  end
+
+  def send_error(creator,title,message)
+    Subscription.where(:label => 'error').all.each do |subscription|
+      creator = subscription.user if creator.nil?
+      notification = Notification.find(:user_id => subscription.user_id,
+                                       :creator_id => creator.id,
+                                       :title => title,
+                                       :message => message,
+                                       :label => 'error',
+                                       :read_date => nil)
+      if notification.nil?
+        notification = send_to(subscription.user,creator,title,message,'error')
+      end
+    end
+
+  end
+
+end

data/lib/sinatra/handlers/errors.rb

@@ -3,20 +3,27 @@ module Sinatra
   module ErrorHandler
     extend Hexacta
 
+    def enable_errors
+      p "Enabling errors..."
+      ErrorHandler.setup_dir("/app/views/#{Hexacta::GEM_FILE_DIR}/errors")
+
+      error_template(404)
+      error_template(403)
+      error_template(500)
+    end
+
     def error_template(code)
-      ErrorHandler.symlink("/lib/sinatra/views/errors/#{code}.slim","/app/views/#{Hexacta::GEM_FILE_DIR}/errors/#{code}.slim")
+      ErrorHandler.copy_file("/lib/sinatra/views/errors/#{code}.slim","/app/views/#{Hexacta::GEM_FILE_DIR}/errors/#{code}.slim")
       error code do
         if code == 500
           title = env['sinatra.error'].message.split(':')[0].gsub('#<','');
           message = (["in #{request.url}"] + env['sinatra.error'].backtrace).join(',');
-          notify_error(authenticated(User),title,message)
+          NotificationSender.instance.send_error(authenticated(User),title,message)
         end
         slim "#{Hexacta::GEM_FILE_DIR}/errors/#{code}".to_sym, locals: { :params => params }
       end
     end
 
-    p "Setting up errors directory..."
-    setup_dir("/app/views/#{Hexacta::GEM_FILE_DIR}/errors")
   end
 
   register ErrorHandler

data/lib/sinatra/handlers/init.rb

@@ -1,3 +1,5 @@
 # encoding: utf-8
 require_relative 'errors'
-require_relative 'notifications'
+require_relative 'notifications'
+require_relative 'params'
+require_relative 'reports'

data/lib/sinatra/handlers/notifications.rb

@@ -3,71 +3,60 @@ module Sinatra
   module NotificationHandler
     extend Hexacta
 
-    def new_notification
+    def enable_notifications
+      p "Enabling notifications..."
+      NotificationHandler.setup_dir("/app/views/#{Hexacta::GEM_FILE_DIR}/notifications")
+      NotificationHandler.copy_file("/lib/sinatra/views/notifications.slim","/app/views/#{Hexacta::GEM_FILE_DIR}/notifications.slim")
+      NotificationHandler.copy_all_files("/lib/sinatra/views/notifications","/app/views/#{Hexacta::GEM_FILE_DIR}/notifications")
+
       post '/notification' do
-        if params["user_ids"].blank?
-          notify(authenticated(User),params["title"],params["message"],params["label"])
+        if params[:user_ids].blank?
+          NotificationSender.instance.send_to_subscriptors(authenticated(User),params[:title],params[:message],params[:label])
         else
-          for id in params["user_ids"]
-            notify_to(User.find(:id => id),authenticated(User),params["title"],params["message"],params["label"])
+          for id in params[:user_ids]
+            NotificationSender.instance.send_to(User.find(:id => id),authenticated(User),params[:title],params[:message],params[:label])
           end
         end
         redirect back
       end
-    end
 
-    def edit_notification
       post '/notifications/:id' do |id|
         Notification.where(:user_id => authenticated(User).id, :id => id).update(:read_date => Date.today)
         200
       end
-    end
 
-    def read_notifications
       post '/notifications' do
-        Notification.where(:user_id => authenticated(User).id, :id => params["ids"]).update(:read_date => Date.today)
+        Notification.where(:user_id => authenticated(User).id, :id => params[:ids]).update(:read_date => Date.today)
         redirect back
       end
-    end
 
-    def get_notification
       get '/notifications/:id' do |id|
         notification = Notification.find(:id => id)
         redirect "/notifications" if notification.nil?
         slim "#{Hexacta::GEM_FILE_DIR}/notifications/view".to_sym, locals: { :notification => notification }
       end
-    end
 
-    def delete_notification
       delete '/notifications/:id' do |id|
         Notification.find(:user_id => authenticated(User).id, :id => id).destroy.to_hash.to_json.to_s
       end
-    end
 
-    def delete_notifications
       delete '/notifications' do
-        Notification.where(:user_id => authenticated(User).id, :id => params["ids"]).destroy.to_s
+        Notification.where(:user_id => authenticated(User).id, :id => params[:ids]).destroy.to_s
       end
-    end
 
-    def get_notifications
       get '/notifications' do
         filters = params.select { |attribute| Notification.columns.include?(attribute.to_sym) }
-        params["limit"] = "20" if params["limit"].to_i < 20
-        params["limit"] = "100" if params["limit"].to_i > 100
-        limit = params["limit"].to_i
-        offset = params["offset"].to_i
+        params[:limit] = "20" if params[:limit].to_i < 20
+        params[:limit] = "100" if params[:limit].to_i > 100
+        limit = params[:limit].to_i
+        offset = params[:offset].to_i
 
-        query = Notification.where(:user_id => authenticated(User).id).where(filters.to_filter).order(:read_date,Sequel.desc(:id))
+        query = Notification.where(:user_id => authenticated(User).id).where(filters.to_filter).order(Sequel.desc(:id))
 
         slim "#{Hexacta::GEM_FILE_DIR}/notifications".to_sym, locals: { :notifications => query.limit(limit).offset(offset*limit).all, :total => query.count, :filters => params, :query => query }
       end
     end
 
-    p "Setting up notifications directory..."
-    setup_dir("/app/views/#{Hexacta::GEM_FILE_DIR}/notifications")
-    symlink("/lib/sinatra/views/notifications.slim","/app/views/#{Hexacta::GEM_FILE_DIR}/notifications.slim")
-    symlink_all("/lib/sinatra/views/notifications","/app/views/#{Hexacta::GEM_FILE_DIR}/notifications")
   end
 
   register NotificationHandler