introspective_grape 0.0.3

data/spec/dummy/app/api/dummy/chat_api.rb

@@ -0,0 +1,108 @@
+class Dummy::ChatAPI < DummyAPI
+  Chat.default_includes :chat
+
+  before do 
+    authorize!
+  end
+
+  resource :chats do  
+
+    desc "list the current user's existing chats" 
+    get '/' do
+      authorize Chat.new, :index?
+      present current_user.chats.includes(:users), with: ChatEntity
+    end
+
+    desc "get new chat notifications"
+    params {
+      optional :id, type: Integer, desc: "Chat ID"
+    }
+    get '/notifications' do
+      authorize Chat.new, :show?
+      present current_user.new_messages?(params[:id])
+    end
+
+
+    desc "get messages"
+    params {
+      optional :id, type: Integer, desc: "Chat ID"
+      optional :new, type: Boolean, desc: "Get only new messages"
+      optional :mark_as_read, type: Boolean, desc: "Mark new messages as read"
+    }
+    get '/messages' do
+      authorize Chat.new, :show?
+      present current_user.read_messages(params[:id], mark_as_read: params[:mark_as_read], new: params[:new]), with: MessageEntity
+    end
+
+
+    desc "list the users in a chat"
+    params {
+      requires :id, type: Integer, desc: "Chat ID"
+    }
+    get '/users' do
+      authorize Chat.new, :show?
+      present current_user.chats.find(params[:id]).active_users, with: UserEntity
+    end
+
+
+    desc "add user(s) to a chat"
+    params {
+      requires :id, type: Integer, desc: "Chat ID"
+      requires :user_ids, desc: 'Comma separated list of User IDs', type: String, regexp: /^\d+(,\d+)*$/
+    }
+    post '/users' do
+      authorize Chat.new, :create?
+      user_ids = params[:user_ids].split(',')
+      present status: current_user.add_chatters(params[:id], user_ids)
+    end
+
+
+    desc "start a new chat"
+    params {
+      requires :message, type: String
+      requires :user_ids, desc: 'Comma separated list of User IDs', type: String, regexp: /^\d+(,\d+)*$/
+    }
+    post do
+      authorize Chat.new, :create?
+      user_ids = params[:user_ids].split(',')
+      present current_user.chat(user_ids, params[:message])
+    end
+
+
+    desc "reply to a chat"
+    params {
+      requires :id, type: Integer, desc: "Chat ID"
+      requires :message, type: String
+    }
+    put ':id' do
+      authorize Chat.new, :create?
+      current_user.reply(params[:id], params[:message])
+    end
+
+
+    desc "drop out of a chat"
+    params {
+      requires :id, type: Integer, desc: "Chat ID"
+    }
+    delete ':id' do
+      authorize Chat.new, :create?
+      present status: current_user.leave_chat(params[:id])
+    end
+  end
+
+
+  class UserEntity < Grape::Entity
+    expose :id, :name, :email, :avatar_url
+  end
+
+  class ChatEntity < Grape::Entity
+    expose :id, :creator_id
+    expose :users, using: UserEntity
+  end
+
+  class MessageEntity < Grape::Entity
+    expose :id, :chat_id, :message
+    expose :author, using: UserEntity
+  end 
+
+end

data/spec/dummy/app/api/dummy/company_api.rb

@@ -0,0 +1,8 @@
+class Dummy::CompanyAPI < IntrospectiveGrape::API
+  restful Company
+
+  class CompanyEntity < Grape::Entity
+    expose :id, :name, :short_name, :created_at, :updated_at
+  end
+end
+

data/spec/dummy/app/api/dummy/entities.rb

@@ -0,0 +1,25 @@
+# Grape Entity monkey patch to ensure that all keys are exposed as camelCased instead of the actual Ruby snake_case names.
+# Note that the keys are not touched if the :as option is used, so
+#   expose :some_name, :as => 'some_name'
+# will remain snake_cased
+
+#class Grape::Entity
+#  protected
+#  def self.key_for(attribute)
+#    (exposures[attribute.to_sym][:as] || attribute).to_s.camelize(:lower).to_sym
+#  end
+#end
+
+module Dummy::Entities
+
+  # base class for entities
+  class DummyEntity < Grape::Entity
+    # common formatters can go here
+  end
+
+  # User entities
+  class User < DummyEntity
+    expose :id, :email, :first_name, :last_name, :avatar_url, :authentication_token
+  end
+end
+

data/spec/dummy/app/api/dummy/location_api.rb

@@ -0,0 +1,37 @@
+class Dummy::LocationAPI < IntrospectiveGrape::API
+
+  default_includes Location, :child_locations, :gps, :beacons, :locatables
+
+  exclude_actions LocationBeacon, :show,:create,:update,:destroy
+  exclude_actions LocationGps, :show,:create,:update,:destroy
+
+  restful Location, [:name, :kind,
+    {gps_attributes: [:id, :lat, :lng, :alt, :_destroy]},
+    {beacons_attributes: [:id, :company_id, :mac_address, :uuid, :major, :minor, :_destroy]},
+  ]
+
+  class Locatable < Grape::Entity
+    expose :id, :locatable_id, :locatable_type, :updated_at, :created_at
+  end
+
+  class LocationBeaconEntity < Grape::Entity
+    expose :id, :uuid, :major, :minor, :company_id, :mac_address, :created_at
+  end
+
+  class LocationGpsEntity < Grape::Entity
+    expose :id, :lat, :lng, :alt, :updated_at
+  end
+
+  class ChildLocationEntity < Grape::Entity
+    expose :id, :name, :kind, :created_at, :updated_at
+  end
+
+  class LocationEntity < Grape::Entity
+    expose :id, :name, :kind,  :parent_location_id, :created_at, :updated_at
+    expose :locatables,       using: Locatable
+    expose :child_locations,  using: ChildLocationEntity
+    expose :gps,              using: LocationGpsEntity
+    expose :beacons,          using: LocationBeaconEntity
+  end
+end
+

data/spec/dummy/app/api/dummy/project_api.rb

@@ -0,0 +1,51 @@
+class Dummy::ProjectAPI < IntrospectiveGrape::API
+
+  default_includes Project, :owner, :admins, :user_project_jobs, project_jobs: [:job], teams: [:team_users]
+  default_includes Team, :team_users
+  default_includes TeamUser, user: [:projects], team: [:project]
+  default_includes ProjectJob, :job
+
+  exclude_actions Project, :create,:destroy,:update
+  exclude_actions Team, :show
+  exclude_actions TeamUser, :show,:update
+
+
+  restful Project, [:id, teams_attributes: [:id,:name,:_destroy, team_users_attributes: [:id, :user_id, :_destroy] ]] 
+
+  class AdminEntity < Grape::Entity
+    expose :id, as: :user_id
+    expose :email, :name, :avatar_url
+  end
+
+  class UserJobEntity < Grape::Entity
+    expose :user_id, :name, :email, :avatar_url, :title, :created_at
+  end
+
+  class JobEntity < Grape::Entity
+    expose :title
+  end
+
+  class UserEntity < Grape::Entity
+    expose :id, :name, :avatar_url
+  end
+
+  class TeamUserEntity < Grape::Entity
+    expose :id
+    expose :user, using: UserEntity
+  end
+
+  class TeamEntity < Grape::Entity
+    expose :id, :name, :created_at, :updated_at
+    expose :team_users, using: TeamUserEntity
+  end
+
+  class ProjectEntity < Grape::Entity
+    expose :id, :name, :created_at, :updated_at
+    expose :owner,  using: Dummy::CompanyAPI::CompanyEntity
+    expose :admins, using: AdminEntity
+    expose :project_jobs,      as: :jobs,      using: JobEntity
+    expose :user_project_jobs, as: :user_jobs, using: UserJobEntity
+    expose :teams, using: TeamEntity
+  end
+end
+

data/spec/dummy/app/api/dummy/role_api.rb

@@ -0,0 +1,7 @@
+class Dummy::RoleAPI < IntrospectiveGrape::API
+  restful Role
+
+  class RoleEntity < Grape::Entity
+    expose :id, :email, :ownable_type, :ownable_id, :created_at, :updated_at
+  end
+end

data/spec/dummy/app/api/dummy/sessions.rb

@@ -0,0 +1,55 @@
+class Dummy::Sessions < Grape::API
+
+  resource :sessions do
+
+    desc "create a user session" do
+      detail "sign in a user"
+    end
+    params do
+      requires :login,        type: String,  desc: "email address"
+      requires :password,     type: String,  desc: "password"
+      optional :token,        type: Boolean, desc: "set to true to generate and return Firebase secure token", default: false
+    end
+    post '/' do
+      authorize User.new, :sessions?
+      user = User.find_first_by_auth_conditions({email: params[:login]})
+      if user && user.valid_password?(params[:password]) && user.valid_for_authentication?
+
+        # commented out for now, User model is not yet confirmable
+        #unauthorized! DummyAPI::USER_NOT_CONFIRMED unless user.confirmed?
+
+        token = nil
+        if params[:token]
+          payload = {
+              uid: "#{user.id}", # uid must be a string
+              email: user.email,
+              avatar_url: user.avatar_url
+          }
+          user.authentication_token = SecureRandom.urlsafe_base64(nil, false)
+          user.save
+        end
+
+        #user.ensure_authentication_token!
+        env['warden'].set_user(user, scope: :user)
+        present user, with: Dummy::Entities::User, token: token
+      else
+        unauthorized! DummyAPI::BAD_LOGIN
+      end
+    end
+
+
+    desc "delete a user session" do
+      detail "sign out the current user" 
+    end
+    delete '/' do
+      authorize User.new, :sessions?
+      if u = User.find_by_authentication_token(params[:api_key])
+        u.authentication_token = nil
+        {status: u.save!}
+      else
+        {status: true } # the user is already logged out
+      end
+    end 
+
+  end
+end

data/spec/dummy/app/api/dummy/user_api.rb

@@ -0,0 +1,32 @@
+class Dummy::UserAPI < IntrospectiveGrape::API
+
+  skip_presence_validations :password
+
+  exclude_actions Role, :show,:update
+  exclude_actions UserProjectJob, :show,:update
+
+  restful User, [:id, :email, :password, :first_name, :last_name, :skip_confirmation_email,
+    user_project_jobs_attributes: [:id, :job_id, :project_id, :_destroy],
+    roles_attributes: [:id, :ownable_type, :ownable_id, :_destroy],
+    avatar_attributes: [:id, :file, :_destroy]
+  ]
+
+  class RoleEntity < Grape::Entity
+    expose :id, :ownable_type, :ownable_id
+  end
+
+  class ImageEntity < Grape::Entity
+    expose :id, :file_processing #, 'file.url'
+  end
+
+  class UserProjectJobEntity < Grape::Entity
+    expose :id, :name, :title, :job_id, :project_id
+  end
+
+  class UserEntity < Grape::Entity
+    expose :id, :email, :first_name, :last_name, :avatar_url
+    expose :roles, as: :roles_attributes, using: RoleEntity
+    expose :user_project_jobs, as: :user_project_jobs_attributes, using: UserProjectJobEntity
+  end 
+
+end

data/spec/dummy/app/api/dummy_api.rb

@@ -0,0 +1,57 @@
+#require 'grape-swagger'
+#require 'grape-entity'
+require 'active_record_helpers'
+#require 'introspective_grape/camel_snake'
+
+class DummyAPI < Grape::API
+  version 'v1', using: :path
+  format :json
+  default_format :json
+
+  include ErrorHandlers
+  helpers PermissionsHelper
+  helpers ApiHelpers
+
+  USER_NOT_CONFIRMED =    'user_not_confirmed'  # "Your account must be confirmed, please check your email inbox."
+  BAD_LOGIN =             'bad_login' # incorrect username or password'
+
+  before do
+    # sets server date in response header. This can be used on the client side
+    header "X-Server-Date", "#{Time.now.to_i}"
+    header "Expires", 1.year.ago.httpdate
+    # Convert incoming camel case params to snake case: grape will totally blow this
+    # if the params hash is not a Hashie::Mash, so make it one of those:
+    #@params = Hashie::Mash.new(snake_keys(params))
+  end
+
+  before_validation do
+    Rails.logger.info "With params: #{params.to_hash.inspect}"
+  end
+
+  after do
+    unless self.options[:path].first =~ /swagger/
+      verify_authorized # Ensure that all endpoints are authorized by a policy class
+    end
+  end
+
+  # Load the in-memory database for the test app
+  load "#{Rails.root}/db/schema.rb"
+
+  # Mount every api endpoint under app/api/dummy/.
+  Dir.glob(Rails.root+"app"+"api"+'dummy'+'*.rb').each do |f|
+    api = "Dummy::#{File.basename(f, '.rb').camelize.sub(/Api$/,'API')}".constantize
+    mount api if api.respond_to? :endpoints
+  end
+
+  # configure grape-swagger to auto-generate swagger docs
+  protocol = Rails.application.config.force_ssl ? 'https' : 'http'
+  add_swagger_documentation({
+    base_path:                "#{protocol}://localhost:3000/api",
+    api_version:              'v1',
+      hide_documentation_path:  true,
+      format:                   :json,
+      hide_format:              true
+     #markdown:                 true
+  })
+
+end

data/spec/dummy/app/api/error_handlers.rb

@@ -0,0 +1,28 @@
+require 'pundit'
+module ErrorHandlers
+  def self.included(m)
+    m.rescue_from ActiveRecord::RecordInvalid do |e|
+      error_response message: e.record.errors.to_a.uniq.join(', '), status: 400
+    end
+
+    m.rescue_from Grape::Exceptions::ValidationErrors do |e|
+      error_response message: e.message, status: 400
+    end
+
+    m.rescue_from ActiveRecord::RecordNotFound do |e|
+      error_response message: "Record not found! #{e.message}", status: 404
+    end
+
+    m.rescue_from ActiveRecord::InvalidForeignKey do |e|
+      error_response message: "Join record not found! #{e.message}", status: 404
+    end
+
+    m.rescue_from Pundit::NotAuthorizedError do |e|
+      error_response message: "Forbidden", status: 403 
+    end
+
+    m.rescue_from Pundit::NotDefinedError do |e|
+      error_response message: "Policy not implemented", status: 501 
+    end
+  end
+end

data/spec/dummy/app/api/permissions_helper.rb

@@ -0,0 +1,7 @@
+require 'pundit'
+module PermissionsHelper
+  # Pundit won't import it's methods unless it sees a stub of ActionController's hide_action.
+  def hide_action; end
+  include Pundit
+
+end

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+end

data/spec/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/spec/dummy/app/models/abstract_adapter.rb

@@ -0,0 +1,13 @@
+class AbstractAdapter < ActiveRecord::Base
+  self.abstract_class = true
+
+  class << self
+    def human_attribute_name(attr, options = {})
+      # The default formatting of validation errors sucks, this helps a little syntatically:
+      super.titleize+":"
+    end
+
+  end
+
+end
+

data/spec/dummy/app/models/admin_user.rb

@@ -0,0 +1,6 @@
+class AdminUser < ActiveRecord::Base
+  # Include default devise modules. Others available are:
+  # :confirmable, :lockable, :timeoutable and :omniauthable
+  devise :database_authenticatable, 
+         :recoverable, :rememberable, :trackable, :validatable
+end

data/spec/dummy/app/models/chat.rb

@@ -0,0 +1,18 @@
+class Chat < AbstractAdapter
+  belongs_to :creator, foreign_key: :creator_id, :class_name => "User", inverse_of: :own_chats
+
+  has_many :chat_users, dependent: :destroy
+  has_many :users, through: :chat_users
+  has_many :chat_messages, dependent: :destroy
+  has_many :messages, class_name: 'ChatMessage', dependent: :destroy
+
+  def active_users
+    chat_users.includes(:user).select {|cu| cu.departed_at.nil? }.map(&:user)
+  end
+
+  before_create :add_creator_to_conversation 
+  def add_creator_to_conversation
+    users.push creator
+  end
+
+end

data/spec/dummy/app/models/chat_message.rb

@@ -0,0 +1,34 @@
+class ChatMessage < AbstractAdapter
+  belongs_to :chat
+  belongs_to :author, class_name: 'User'
+
+  has_many :chat_users, through: :chat
+  has_many :recipients, lambda {|message|  where(':created_at >= chat_users.created_at and (chat_users.departed_at IS NULL OR :created_at <= chat_users.departed_at)', created_at: message.created_at ) }, through: :chat_users, source: :user, class_name: 'User'
+
+  # Create ChatUserMessage records for each recipient to track read status
+  has_many :chat_message_users, dependent: :destroy
+
+  validate :author_in_chat
+
+  def author_in_chat
+    errors[:base] << 'User not in chat session.' unless chat.active_users.include? author
+  end
+
+  before_save :create_message_users, if: :new_record?
+  def create_message_users
+    chat_users.merge(ChatUser.current).each do |cu|
+      chat_message_users.build(user: cu.user)
+    end
+  end
+
+  def read_by?(user)
+    chat_message_users.merge(ChatMessageUser.read).map(&:user_id).include?(user.id)
+  end
+
+  def self.find_chat_for_users(users)
+    # presumably much more efficient ways to run an intersecton, we want to find the last
+    # exact match with the users being messaged to append to the existing chat.
+    Chat.eager_load(:chat_users).where("chat_users.departed_at IS NULL").order('chats.created_at desc').detect {|c| c.chat_users.map(&:user_id).uniq.sort == users.map(&:id).sort }
+  end
+
+end 

data/spec/dummy/app/models/chat_message_user.rb

@@ -0,0 +1,17 @@
+class ChatMessageUser < AbstractAdapter
+  belongs_to :chat_message
+  belongs_to :user
+  has_one    :chat, through: :chat_message
+
+  scope :read, ->{ where('read_at IS NOT NULL' ) }
+  scope :unread, ->{ where('read_at IS NULL' ) }
+
+  before_save :author_reads_message
+  def author_reads_message
+    self.read_at = Time.now if user == chat_message.author
+  end
+
+  def read?
+    read_at.present?
+  end
+end

data/spec/dummy/app/models/chat_user.rb

@@ -0,0 +1,16 @@
+class ChatUser < AbstractAdapter
+  belongs_to :chat
+  belongs_to :user 
+
+  alias_attribute :joined_at, :created_at
+  alias_attribute :left_at,   :departed_at
+
+  scope :current, ->{ where(departed_at: nil) }
+
+  validate :user_not_already_active, on: :create
+
+  def user_not_already_active
+    errors[:base] << "#{user.name} is already present in this chat." if chat.chat_users.where(user_id: user.id, departed_at: nil).count > 0 if user.persisted?
+  end
+
+end

data/spec/dummy/app/models/company.rb

@@ -0,0 +1,14 @@
+class Company < AbstractAdapter
+  has_many :roles, as: :ownable
+  has_many :admins, through: :roles, source: :user
+  accepts_nested_attributes_for :roles, allow_destroy: true
+  
+  has_many :beacons, class_name: 'LocationBeacon', dependent: :destroy
+  has_many :locatables
+  has_many :locations, through: :locatables, source: :locatable, source_type: 'Company'
+
+  has_many :projects, foreign_key: :owner_id, dependent: :destroy, inverse_of: :owner
+
+  validates_length_of :name, maximum: 256
+  validates_length_of :short_name, maximum: 10
+end

data/spec/dummy/app/models/image.rb

@@ -0,0 +1,21 @@
+require 'paperclip'
+#require 'delayed_paperclip'
+class Image < ActiveRecord::Base
+  belongs_to :imageable, polymorphic: true
+
+  has_attached_file :file, styles: {medium: "300x300>", thumb: "100x100"},
+    url: "/system/:imageable_type/:imageable_id/:id/:style/:filename"
+  
+  validates_attachment :file, content_type: {content_type: ["image/jpeg", "image/png", "image/gif"]}
+  validates_attachment_size :file, :less_than => 2.megabytes
+
+  #process_in_background :file, processing_image_url: 'empty_avatar.png'
+
+  Paperclip.interpolates :imageable_type  do |attachment, style|
+      attachment.instance.imageable_type.try(:pluralize)
+  end
+  Paperclip.interpolates :imageable_id  do |attachment, style|
+      attachment.instance.imageable_id
+  end
+
+end

data/spec/dummy/app/models/job.rb

@@ -0,0 +1,10 @@
+class Job < AbstractAdapter
+
+  has_many :project_jobs,     dependent: :destroy
+  accepts_nested_attributes_for :project_jobs, allow_destroy: true
+
+  has_many :user_project_jobs, dependent: :destroy
+  has_many :users,    through: :user_project_jobs
+  has_many :projects, through: :user_project_jobs
+
+end

data/spec/dummy/app/models/locatable.rb

@@ -0,0 +1,6 @@
+class Locatable < AbstractAdapter
+  belongs_to :location
+  belongs_to :locatable, polymorphic: true
+
+  validates_inclusion_of :locatable_type, in: %w(Company)
+end