sinatra-hexacta 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acbebd0dade426417f396054c4d2e277402fc59cbad3b7e27c248a193e59859d
-  data.tar.gz: beaf9fcfffa445c4b7f39e49be20132bf8103199dc972b4b1235d89280e6c4b6
+  metadata.gz: 57e2b70893a33833d923a230a2efc0112358d81961b1897b6894bde81c49672a
+  data.tar.gz: 9eb2b5cce23ac52c1bb105df09c4543b7291ad047f0150762ae13303a2bf1a97
 SHA512:
-  metadata.gz: 9b374e1e2f8106c23168de0312034f4dab4669d11582f51e935ed436eab1b7f1965fd1963f3fc64a39de16f199c19ad3948655de3f04fb1b77d8c64a17aac186
-  data.tar.gz: 268e659e4ae71122214d640c33a4c5e3a2cc6a5f1338aa6659633a18673671278ec1752d19ecd9febc1988ba632c7d836d751915544811c11fec8e4f64e72bfa
+  metadata.gz: 4e9c5a79fe2a7b4e33c3b37ec4b732f7306ae7f5402528dedce8e7f26f80e6b5e7ce13b3d5f86cbd6899fded25ee380c027c12570189475882e7567624783d76
+  data.tar.gz: 8fd1274ede9d5e51882f02f7fdbda786d8a8f1f05d1346a422ae68435ca3f818d85e7586d40b4a2443e95fc6ee2a6bd998c06ce704463ad5a37a86a27c309f54

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/init.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+require_relative 'date'
+require_relative 'antiquity'
+require_relative 'notification'

data/lib/sinatra/extensions/notification.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+class NotificationSender
+
+  def self.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 self.send_to_subscriptors(creator,title,message,label,link=nil)
+    Subscription.where(:label => label).all.each do |subscription|
+      notification = NotificationSender.send_to(subscription.user,creator,title,message,label,link)
+    end
+  end
+
+  def self.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 = NotificationSender.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")
       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.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.symlink("/lib/sinatra/views/notifications.slim","/app/views/#{Hexacta::GEM_FILE_DIR}/notifications.slim")
+      NotificationHandler.symlink_all("/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.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.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

data/lib/sinatra/handlers/params.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Sinatra
+  module ParamsHandler
+
+    def enable_params
+      p "Enabling params handler..."
+
+      before "*" do
+        unless params.nil?
+          tmp = {}
+          for key in params.keys
+            value = params[key]
+            value = value.join(",").split(",") if value.respond_to? :join
+            tmp[key.to_sym] =  value
+          end
+          @params.clear
+          @params = tmp
+        end
+      end
+
+    end
+
+  end
+
+  register ParamsHandler
+end

data/lib/sinatra/handlers/reports.rb

@@ -1 +1,28 @@
-#TOBEDONE
+# encoding: utf-8
+module Sinatra
+  module ReportHandler
+    extend Hexacta
+
+    def enable_reports
+      p "Enabling reports..."
+      before '/reports/*' do
+        error(403) if authenticated(User).permissions.empty?
+      end
+
+      get '/reports' do
+        slim :reports
+      end
+
+      get '/reports/:report_name' do |report_name|
+        date = Date.parse(params["date"]) unless params["date"].nil?
+        date ||= Date.today
+        headers "Content-Disposition" => "attachment;filename=#{report_name}.#{date}.xls",
+          "Content-Type" => "application/octet-stream"
+          slim "reports/#{report_name}".to_sym, locals: { :date => date }, :layout => false
+      end
+    end
+
+  end
+
+  register ReportHandler
+end

data/lib/sinatra/helpers/alerts.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Sinatra
+  module AlertHelper
+    extend Hexacta
+
+    def info_alert(option_hash)
+      slim "#{Hexacta::GEM_FILE_DIR}/alerts/info".to_sym, locals: option_hash
+    end
+
+    def empty_alert(option_hash)
+      slim "#{Hexacta::GEM_FILE_DIR}/alerts/empty".to_sym, locals: option_hash
+    end
+
+    def warning_alert(option_hash)
+      slim "#{Hexacta::GEM_FILE_DIR}/alerts/warning".to_sym, locals: option_hash
+    end
+
+    def error_alert(option_hash)
+      slim "#{Hexacta::GEM_FILE_DIR}/alerts/error".to_sym, locals: option_hash
+    end
+
+    setup_dir("/app/views/#{Hexacta::GEM_FILE_DIR}/alerts")
+    symlink_all("/lib/sinatra/views/alerts","/app/views/#{Hexacta::GEM_FILE_DIR}/alerts")
+  end
+
+  helpers AlertHelper
+end

data/lib/sinatra/helpers/cas.rb

@@ -0,0 +1,92 @@
+require 'active_support/all' #bug in rubycas client requires this
+require 'rubycas-client'
+
+module Sinatra
+  module CasHelper
+
+    CAS_CLIENT = CASClient::Client.new(:cas_base_url => ENV['CAS_BASE_URL'], :log => Logger.new(STDOUT), :ticket_store_config => {:storage_dir => ENV['TICKET_STORE_DIR']})
+
+    def need_authentication(request, session)
+      if session[:cas_ticket]
+        if request[:ticket] && session[:cas_ticket] != request[:ticket]
+          true
+        else
+          false
+        end
+      else
+        true
+      end
+    end
+
+    def process_cas_login(request, session)
+      if request[:ticket] && request[:ticket] != session[:ticket]
+
+        service_url = read_service_url(request)
+        service_ticket = read_ticket(request[:ticket], service_url)
+
+        CAS_CLIENT.validate_service_ticket(service_ticket)
+
+        if service_ticket.success
+          session[:cas_ticket] = service_ticket.ticket
+          session[:cas_user] = service_ticket.user
+        else
+          redirect request.path_info
+          #raise "Service Ticket validation failed! #{st.failure_code} - #{st.failure_message}"
+        end
+      end
+
+    end
+
+    def logged_in?(request, session)
+      session[:cas_ticket] && !session[:cas_ticket].empty?
+    end
+
+    def require_authorization(request, session)
+      if !logged_in?(request, session)
+        service_url = read_service_url(request)
+        url = CAS_CLIENT.add_service_to_login_url(service_url)
+        redirect url
+      end
+    end
+
+    def authenticated(model)
+      raise 500 if session[:cas_user].nil? || session[:cas_user].empty?
+      model.find(:hxt_id => "#{session[:cas_user]}")
+    end
+
+    private
+    def read_ticket(ticket_str, service_url)
+      return nil unless ticket_str and !ticket_str.empty?
+
+      if ticket_str =~ /^PT-/
+        CASClient::ProxyTicket.new(ticket_str, service_url)
+      else
+        CASClient::ServiceTicket.new(ticket_str, service_url)
+      end
+    end
+
+    def read_service_url(request)
+      service_url = url(request.path_info)
+      if request.GET
+        params = request.GET.dup
+        params.delete(:ticket)
+        if params
+          [service_url, Rack::Utils.build_nested_query(params)].join('?')
+        end
+      end
+      return service_url
+    end
+
+    def logout_cas(request, session)
+      if logged_in?(request, session)
+        url = CAS_CLIENT.logout_url()
+        session.clear
+        str = request.referer
+        comeback = "=" + (str.include?("?")? str.slice(0..(str.index('?')-1)) : str) #Hack mal!
+        redirect url + (url.include?("?service")? "" : "?service") + comeback
+      end
+    end
+  end
+
+  helpers CasHelper
+end