serum-rails 0.1.0

data/spec/test_app/app/controllers/shared/boring_controller_trait/index_trait.rb

@@ -0,0 +1,39 @@
+# Provides an index action with includes, an order, find-as-you-type search, pagination and an option to see deletable records.
+# origin: RM
+module BoringControllerTrait::IndexTrait
+  as_trait do |options|
+
+    afterlife = options.delete(:afterlife) || :deleted
+    show_afterlife = "show_#{afterlife}"
+    with_afterlife = "with_#{afterlife}"
+    
+    index.wants.html do
+      render :partial => "list" if request.xhr?
+    end
+
+    private
+
+    define_method :collection do
+      list = collection_scope
+      list = list.scoped(:include => options[:include]) if options[:include]
+      list = list.scoped(:order => options[:order]) if options[:order]
+      list = list.send(with_afterlife, params[show_afterlife] == '1') if list.respond_to?(with_afterlife)
+      list = list.search(*search_args) if list.respond_to?(:search) && params[:query].present?
+      list = paginate(list)
+      list
+    end
+
+    define_method :collection_scope do
+      end_of_association_chain
+    end
+
+    define_method :paginate do |scope|
+      scope.paginate(:page => params[:page], :per_page => PAGE_SIZE)
+    end
+
+    define_method :search_args do
+      params[:query]      
+    end
+
+  end
+end

data/spec/test_app/app/controllers/shared/boring_controller_trait/log_changes_trait.rb

@@ -0,0 +1,18 @@
+# Configures a resource_controller to automatically set a user performing a record change.
+# origin: RM
+module BoringControllerTrait::LogChangesTrait
+  as_trait do
+
+    [:object, :build_object].each do |method|
+      define_method method do |*args|
+        super.tap do |record|
+          if record.present? && record.respond_to?(:changing_user=)
+            record.changing_user = current_user
+            # the actual logging takes place in the object model after saving
+          end
+        end
+      end
+    end
+
+  end
+end

data/spec/test_app/app/controllers/shared/boring_controller_trait.rb

@@ -0,0 +1,16 @@
+# Provides a resource_controller preconfigured with options you want 99% of the time. Used by most controllers that do CRUD.
+# origin: RM
+module BoringControllerTrait
+  as_trait do |*options|
+    
+    options = options.first || {}
+
+    options[:singleton] ? resource_controller(:singleton) : resource_controller
+
+    does 'boring_controller_trait/flash'
+    does 'boring_controller_trait/deletable' unless options[:destroy_is_permanent]
+    does 'boring_controller_trait/index', options unless options[:singleton]
+    does 'boring_controller_trait/helpers', options
+
+  end
+end

data/spec/test_app/app/controllers/users_controller.rb

@@ -0,0 +1,49 @@
+# Provides user sign up, the user status pages and sends friendship requests to individual users.
+# origin: RM
+class UsersController < ApplicationController
+
+  public_controller :only => [:new, :create]
+  
+  does 'boring_controller'
+
+  permissions :users
+  in_sections :members
+
+  new_action do
+    before { set_sections_for_sign_up }
+  end
+
+  update do
+    flash 'Profile updated'
+  end
+
+  create do
+    before { set_sections_for_sign_up }
+    flash 'Welcome!'
+    wants.html do
+      sign_in(object)
+      redirect_to root_path
+    end
+  end
+
+  show.before do
+    in_sections :profile if object == current_user
+  end
+
+  def request_friendship
+    object.friendship_requests.create! :requesting_user => current_user if current_user.can_become_friends_with? object
+    flash[:notice] = 'Contact requests sent'
+    redirect_to object_path
+  end
+
+  private
+
+  def set_sections_for_sign_up
+    in_sections :sign_up, :exclusive => true
+  end
+
+  def object_params
+    (super || {}).slice(:username, :email, :password, :password_confirmation, :full_name, :town, :country)
+  end
+
+end

data/spec/test_app/app/controllers/ws/api_controller/formatters_trait.rb

@@ -0,0 +1,91 @@
+# Trait to format CaP objects as json.
+# origin: M
+module Ws::ApiController::FormattersTrait
+  as_trait do
+
+    def format_date(date)
+      date.strftime('%Y%m%d')
+    end
+
+    def format_version(time)
+      time.to_i.to_s
+    end
+
+    def format_conference(conference, options = {})
+      result = {
+        'version' => format_version(conference.updated_at),
+        'id' => conference.id,
+        'name' => conference.name,
+        'creator' => format_user(conference.user, :stub => true),
+        'startdate' => format_date(conference.start_date),
+        'enddate' => format_date(conference.end_date),
+        'categories' => format_categories(conference.categories),
+        'description' => conference.description,
+        'location' => conference.address
+      }
+      if options[:stub]
+        result.slice!('name', 'startdate', 'enddate', 'categories')
+        result.merge!('details' => ws_conference_url(conference))
+      end
+      result
+    end
+
+    def format_conferences(conferences)
+      conferences.collect do |conference|
+        format_conference conference, :stub => true
+      end
+    end
+
+    def format_users(users)
+      users.collect do |user|
+        format_user(user, :stub => true)
+      end
+    end
+
+    def format_user(user, options = {})
+      result = {
+        'version' => format_version(user.updated_at),
+        'id' => user.id,
+        'username' => user.username,
+        'fullname' => user.full_name,
+        'email' => user.email,
+        'town' => user.town,
+        'country' => user.country,
+        'status' => (api_user ? api_user.status_towards(user) : 'no_contact')
+      }
+      if options[:stub]
+        result.slice!('username')
+        result.merge!('details' => ws_member_url(user.username))
+      end
+      unless options[:full_details]
+        result.delete('email')
+        result.delete('fullname')
+      end
+      result
+    end
+
+    def format_category(category, options = {})
+      { 'name' => category.name }.tap do |result|
+        if options[:stub]
+          result.merge! 'details' => ws_category_url(category)
+        else
+          mother = category.parent
+          children = category.children
+          result.merge!({
+            'version' => format_version(category.updated_at),
+            'id' => category.id,
+            'parent' => mother.present? ? format_category(mother, :stub => true) : {},
+            'subcategories' => children.collect{ |child| format_category(child, :stub => true) }
+          })
+        end
+      end
+    end
+
+    def format_categories(categories)
+      categories.collect do |category|
+        format_category category, :stub => true
+      end
+    end
+
+  end
+end

data/spec/test_app/app/controllers/ws/api_controller/parsers_trait.rb

@@ -0,0 +1,59 @@
+# Trait to parse incoming json objects
+# origin: M
+module Ws::ApiController::ParsersTrait
+  as_trait do
+
+    def find_user(user)
+      if user
+        User.find_by_username(user['username'])
+      end
+    end
+
+    def find_categories(categories)
+      if categories
+        Category.find_all_by_name(categories.collect { |category| category['name'] }).collect(&:id)
+      else
+        []
+      end
+    end
+
+    def find_category(name)
+      Category.find_by_name(name) if name
+    end
+
+    def compact_hash!(hash)
+      hash.delete_if { |key, value| value.nil? }
+    end
+
+    def parse_conference(conference)
+      compact_hash!(
+        :name => conference['name'],
+        :user => find_user(conference['creator']),
+        :start_date => conference['startdate'],
+        :end_date => conference['enddate'],
+        :category_list => find_categories(conference['categories']),
+        :description => conference['description'],
+        :address => conference['location']
+      )
+    end
+
+    def parse_category(category)
+      {
+        :name => category['name'],
+        :parent => find_category(category['parent'].andand['name'])
+      }
+    end
+
+    def parse_user(user)
+      compact_hash!(
+        :username => user['username'],
+        :password => user['password'],
+        :password_confirmation => user['password'],
+        :full_name => user['fullname'],
+        :email => user['email'],
+        :town => user['town'],
+        :country => user['country']
+      )
+    end
+  end
+end

data/spec/test_app/app/controllers/ws/api_controller.rb

@@ -0,0 +1,70 @@
+# Base class for all webservice controllers; defines common functionality like authorization.
+# origin: M
+class Ws::ApiController < ActionController::Base
+
+  does 'ws/api_controller/parsers'
+  does 'ws/api_controller/formatters'
+
+  before_filter :authenticate
+  before_filter :deny_guest
+  around_filter :rescue_exceptions
+
+  attr_reader :api_user
+
+  def json_params
+    unless @json_params
+      @json_params = params.dup
+      @json_params.delete(:controller)
+      @json_params.delete(:action)
+      @json_params
+    end
+    @json_params
+  end
+
+  def validate_version!(record, version)
+    unless record.updated_at.to_i.to_s == version
+      raise ActiveRecord::StaleObjectError
+    end
+  end
+
+  def self.public_actions(*actions)
+    skip_before_filter :deny_guest, :only => actions
+  end
+
+  def render_no_content
+    render :status => 204, :text => ''
+  end
+
+  def render_not_implemented
+    render :status => 501, :text => ''
+  end
+
+  private
+
+  def rescue_exceptions
+    yield
+  rescue Aegis::AccessDenied
+    render :status => '403', :text => ''
+  rescue ActiveRecord::RecordNotFound
+    render :status => '404', :text => ''
+  rescue ActiveRecord::StaleObjectError
+    render :status => '409', :text => ''
+  rescue => exception
+    render :status => '400', :text => ''
+  end
+
+  def authenticate
+    authenticate_with_http_basic do |username, password|
+      @api_user = api_user_from_credentials(username, password)
+    end
+    true
+  end
+
+  def deny_guest
+    request_http_basic_authentication('CaP Webservice') unless api_user
+  end
+
+  def api_user_from_credentials(username, password)
+    User.authenticate(username, password)
+  end
+end

data/spec/test_app/app/controllers/ws/attendees_controller.rb

@@ -0,0 +1,43 @@
+# Controller for /ws/conference/{id}/attendees
+# origin: M
+class Ws::AttendeesController < Ws::ApiController
+
+  public_actions :index
+
+  def index
+    conference = Conference.find(params[:conference_id])
+    attendees = conference.attendees
+    if attendees.any?
+      render :json => format_users(conference.attendees)
+    else
+      render_no_content
+    end
+  end
+
+  def create
+    conference = Conference.find(params[:conference_id])
+    api_user.may_attend_conference!(conference)
+    username = json_params['username']
+    if username != api_user.username
+      raise Aegis::AccessDenied
+    end
+
+    conference.attend!(api_user)
+
+    render_no_content
+  end
+
+  def destroy
+    conference = Conference.find(params[:conference_id])
+    api_user.may_cancel_attendance_conference!(conference)
+    username = params[:id]
+    if username != api_user.username
+      raise Aegis::AccessDenied
+    end
+
+    conference.cancel_attendance!(api_user)
+
+    render_no_content
+  end
+
+end

data/spec/test_app/app/controllers/ws/categories_controller.rb

@@ -0,0 +1,30 @@
+# Controller for /ws/categories
+# origin: M
+class Ws::CategoriesController < Ws::ApiController
+
+  public_actions :index, :show
+
+  def index
+    root_categories = Category.roots
+    if root_categories.any?
+      render :json => format_categories(root_categories)
+    else
+      render_no_content
+    end
+  end
+
+  def create
+    api_user.may_create_category!
+
+    category = Category.new(parse_category(json_params))
+
+    category.save!
+    render :json => format_category(category)
+  end
+
+  def show
+    category = Category.find(params[:id])
+    render :json => format_category(category)
+  end
+
+end

data/spec/test_app/app/controllers/ws/conferences_controller.rb

@@ -0,0 +1,62 @@
+# Controller for /ws/conferences
+# origin: M
+class Ws::ConferencesController < Ws::ApiController
+
+  public_actions :show, :by_category, :search
+
+  def show
+    conference = Conference.find(params[:id])
+    render :json => format_conference(conference)
+  end
+
+  def create
+    api_user.may_create_conference!
+
+    conference = Conference.new(parse_conference(json_params))
+    set_conference_fields(conference)
+
+    conference.save!
+    render :json => format_conference(conference)
+  end
+
+  def update
+    conference = Conference.find(params[:conference_id])
+    api_user.may_update_conference!(conference)
+
+    conference.attributes = parse_conference(json_params)
+    set_conference_fields(conference)
+
+    validate_version!(conference, json_params['version'])
+
+    conference.save!
+    render :json => format_conference(conference)
+  end
+
+  def by_category
+    category = Category.find params[:category_id]
+    if category.conferences.any?
+      render :json => format_conferences(category.conferences)
+    else
+      render_no_content
+    end
+  end
+
+  def search
+    conferences = ConferenceSearch.new(params.slice(:query) || {}).find
+    if conferences.any?
+      render :json => format_conferences(conferences)
+    else
+      render_no_content
+    end
+  end
+
+  private
+
+  def set_conference_fields(conference)
+    conference.user ||= api_user
+    if conference.user != api_user
+      raise Aegis::AccessDenied
+    end
+  end
+
+end

data/spec/test_app/app/controllers/ws/contacts_controller.rb

@@ -0,0 +1,41 @@
+# Controller for /ws/contacts
+# origin: M
+class Ws::ContactsController < Ws::ApiController
+
+  public_actions :index
+
+  def index
+    user = User.find_by_username!(params[:member_id])
+    if user == api_user
+      contacts = user.contacts
+    else
+      contacts = user.friends
+    end
+
+    if contacts.any?
+      render :json => format_users(contacts)
+    else
+      render_no_content
+    end
+  end
+
+  def create
+    user = User.find_by_username!(params[:member_id])
+    positive = !!(json_params['positive'] or json_params['positive'] == 'true')
+    case api_user.status_towards(user)
+    when 'RCD_received'
+      request = api_user.friendship_requests.find(:first, :conditions => {:requesting_user_id => user.id})
+      if positive
+        request.accept
+      else
+        request.deny
+      end
+    when 'no_contact'
+      if positive
+        api_user.sent_friendship_requests.create!(:user_id => user.id)
+      end
+    end
+    render_no_content
+  end
+
+end

data/spec/test_app/app/controllers/ws/factory_controller.rb

@@ -0,0 +1,45 @@
+# Controller for /ws/reset and /ws/factorydefaults
+# origin: M
+class Ws::FactoryController < Ws::ApiController
+
+  def reset
+    api_user.may_reset_application_state!
+
+    clean_and_create_admin!
+
+    render_no_content
+  end
+
+  def factorydefaults
+    api_user.may_reset_application_state!
+
+    clean_and_create_admin!
+
+    users, categories, series, conferences = JSON.parse(File.read("#{Rails.root}/assets/data.json"))
+
+    users.each do |user|
+      User.create(parse_user(user))
+    end
+
+    categories.each do |category|
+      Category.create(parse_category(category))
+    end
+
+    conferences.each do |conference|
+      Conference.create(parse_conference(conference))
+    end
+
+    render_no_content
+  end
+
+  private
+
+  def clean_and_create_admin!
+    [Attendance, Category, ConferenceCategory, Conference, FriendshipRequest, Friendship, Invitation, User].each do |model|
+      model.delete_all
+    end
+
+    User.create_admin!
+  end
+
+end

data/spec/test_app/app/controllers/ws/members_controller.rb

@@ -0,0 +1,34 @@
+# Controller for /ws/members
+# origin: M
+class Ws::MembersController < Ws::ApiController
+
+  public_actions :create
+
+  def create
+    user = User.new(parse_user(json_params))
+
+    user.save!
+    render :json => format_user(user, :full_details => true)
+  end
+
+  def show
+    user = User.find_by_username!(params[:id])
+
+    render :json => format_user(user, :full_details => api_user.sees_details_of?(user))
+  end
+
+  def update
+    user = User.find_by_username!(params[:user_id])
+    unless user == api_user
+      raise Aegis::AccessDenied
+    end
+
+    user.attributes = parse_user(json_params)
+
+    validate_version!(user, json_params['version'])
+
+    user.save!
+    render :json => format_user(user, :full_details => true)
+  end
+
+end

data/spec/test_app/app/controllers/ws/series_controller.rb

@@ -0,0 +1,19 @@
+# Controller for /ws/series
+# origin: M
+class Ws::SeriesController < Ws::ApiController
+
+  public_actions :index, :show, :create
+
+  def index
+    render_not_implemented
+  end
+
+  def create
+    render_not_implemented
+  end
+
+  def show
+    render_not_implemented
+  end
+
+end

data/spec/test_app/app/controllers/ws/tests_controller.rb

@@ -0,0 +1,23 @@
+# Dummy controller to test some common webservice functionality; only used in specs
+# origin: M
+class Ws::TestsController < Ws::ApiController
+
+  def index
+    render :json => {'foo' => 'bar'}
+  end
+
+  def no_access
+    raise Aegis::AccessDenied
+  end
+
+  def error
+    raise "foo"
+  end
+
+  public_actions :public
+
+  def public
+    render :json => {'foo' => 'bar'}
+  end
+
+end