Rework api/activities/index to show p/c/u, add routes

app/controllers/api/groups_controller.rb

 class Api::GroupsController < ApiController
-  before_action :set_group, only: [:show]
-  before_action :require_membership!, only: [:show]
-  before_action :api_require_admin!, only: [:index]
+  has_no_group = [:index]
+
+  before_action :set_group, except: has_no_group
+  before_action :require_membership!, except: has_no_group
+  before_action :api_require_admin!, only: has_no_group
 
   # GET /api/groups
   # GET /api/groups.json
   def index
-    @api_groups = Api::Group.all
+    @api_groups = Group.all
   end
 
   # GET /api/groups/1
   def show
   end
 
+  # GET /api/groups/1/current_activities
+  def current_activities
+    @activities = @group.current_activities
+    render 'api/activities/index'
+  end
+
+  # GET /api/groups/1/upcoming_activities
+  def upcoming_activities
+    @activities = @group.upcoming_activities
+    render 'api/activities/index'
+  end
+
+  # GET /api/groups/1/previous_activities
+  def previous_activities
+    @activities = @group.previous_activities
+    render 'api/activities/index'
+  end
+
   private
     # Use callbacks to share common setup or constraints between actions.
     def set_group

app/models/group.rb

   end
 
   # @return [Array<Activity>]
-  #   the Activity/Activities that are the closest to the given point in time.
-  #   Logic is as follows:
-  #     - If one or more Activities start before and end after the given point
-  #       in time, these are returned.
-  #     - Additionally, the last 3 activities that ended are returned, as well
-  #       as any activities starting within the next 48 hours.
+  #   all Activities that have started, and not yet ended.
   def current_activities(reference = Time.zone.now)
-    currently_active = self.activities
+    activities
       .where('start < ?', reference)
       .where('end > ?', reference)
+  end
 
-    previous = self.activities
+  # @return [Array<Activity>]
+  #   at most 3 activities that ended recently.
+  def previous_activities(reference = Time.zone.now)
+    activities
       .where('end < ?', reference)
       .order(end: :desc)
       .limit(3)
+  end
 
-    upcoming = self.activities
+  # @return [Array<Activity>]
+  #   all Activities starting within the next 48 hours.
+  def upcoming_activities(reference = Time.zone.now)
+    activities
       .where('start > ?', reference)
       .where('start < ?', reference.days_since(2))
       .order(start: :asc)
-
-    return {currently_active: currently_active, previous: previous, upcoming: upcoming}
   end
 
-  # Determine whether the passed person is a member of the group.
+  # @return [Boolean]
+  #   whether the passed person is a member of the group.
   def is_member?(person)
     Member.exists?(
       person: person,
     ) || person.is_admin?
   end
 
-  # Determine whether the passed person is a group leader.
+  # @return [Boolean]
+  #   whether the passed person is a group leader.
   def is_leader?(person)
     Member.exists?(
       person: person,

app/views/api/activities/index.rabl

 collection @activities
 
-attributes :id, :name
+attributes :id, :name, :description, :location, :start, :end, :deadline
+
+node :no_response_action do |a|
+  {
+    true => "present",
+    false => "absent"
+  }[a.no_response_action]
+end

config/routes.rb

       get 'groups', to: 'me#groups'
     end
 
-    resources :groups, only: [:index, :show]
+    resources :groups, only: [:index, :show] do
+      get :current_activities, on: :member
+      get :previous_activities, on: :member
+      get :upcoming_activities, on: :member
+    end
 
     resources :activities, only: [:index, :show]
     get 'activities/:id/response_summary', to: 'activities#response_summary'