Merge branch 'feature/subgroups'

.rbenv-vars-sample

 
 # Do we bind to a socket or port?
 PUMA_BIND=
+
+# Set to enable Sentry reporting
+SENTRY_DSN=

Gemfile

 gem 'delayed_job_active_record'
 gem 'daemons'
 
+# Error reporting
+gem 'sentry-raven'
+
 group :development, :test do
   # Call 'byebug' anywhere in the code to stop execution and get a debugger console
   gem 'byebug', platform: :mri

Gemfile.lock

     execjs (2.7.0)
     faker (1.7.3)
       i18n (~> 0.5)
+    faraday (0.14.0)
+      multipart-post (>= 1.2, < 3)
     ffi (1.9.18)
     font-awesome-sass (4.7.0)
       sass (>= 3.2)
     mini_portile2 (2.1.0)
     minitest (5.10.1)
     multi_json (1.12.1)
+    multipart-post (2.0.0)
     netrc (0.11.0)
     nio4r (2.0.0)
     nokogiri (1.7.1)
       sprockets (>= 2.8, < 4.0)
       sprockets-rails (>= 2.0, < 4.0)
       tilt (>= 1.1, < 3)
+    sentry-raven (2.7.2)
+      faraday (>= 0.7.6, < 1.0)
     spring (2.0.1)
       activesupport (>= 4.2)
     spring-watcher-listen (2.0.1)
   rabl
   rails (~> 5.0.0, >= 5.0.0.1)
   sass-rails (~> 5.0)
+  sentry-raven
   spring
   spring-watcher-listen (~> 2.0.0)
   sqlite3
   yard
 
 BUNDLED WITH
-   1.13.6
+   1.16.0

app/assets/javascripts/activities.coffee

   clipboard = new Clipboard('.copy-reactions', {
     'text': clipreactions
   })
+  $('.subgroup-filter').on('change', (e) -> filterparticipants(e))
 
 @clipreactions = (trigger) ->
   id = trigger.dataset['activity']
     res.push(resp['unknown']['message'])
 
   res.join('\n')
+
+@filterparticipants = (e) ->
+  show = e.target.value
+  if (show == 'all')
+    $('.participant-row').show()
+    @updatecounts()
+    this.subgroupfilter = null
+  else if (show == 'withoutgroup')
+    selector = "tr.participant-row.success:not([data-subgroup-id])"
+    $('.participant-row').hide()
+    $(selector).show()
+    @updatecounts()
+    this.subgroupfilter = show
+  else
+    selector = "[data-subgroup-id=" + e.target.value + "]"
+    $('.participant-row').hide()
+    $(selector).show()
+    @updatecounts(show)
+    this.subgroupfilter = show
+
+@updatecounts = (subgroupid) ->
+  selector = 'tr.countable.participant-row'
+  selectorend = '[style!="display: none;"]'
+
+  if (subgroupid)
+    selectorend = '[data-subgroup-id=' + subgroupid + ']' + selectorend
+
+  pselect = selector + '.success' + selectorend
+  uselect = selector + '.warning' + selectorend
+  aselect = selector + '.danger' + selectorend
+
+  numall = $(selector + selectorend).length
+  numpresent = $(pselect).length
+  numunknown = $(uselect).length
+  numabsent  = $(aselect).length
+
+  $('.state-count.all-count').html(numall)
+  $('.state-count.present-count').html(numpresent)
+  $('.state-count.unknown-count').html(numunknown)
+  $('.state-count.absent-count').html(numabsent)
+  [numpresent, numabsent, numunknown]

app/assets/javascripts/buttonhandlers.jsx.js

 // Creates an AJAX-request and registers the appropriate handlers once it is done.
 function change_presence(e)
 {
-	// Gather data
-	var group, person, activity, state;
-	group 	 = this.dataset["groupId"];
-	person   = this.dataset["personId"];
-	activity = this.dataset["activityId"];
-	rstate 	 = this.dataset["newState"];
-
-	var state;
-	switch (rstate)
-	{
-		case "present":
-			state = true;
-			break;
-
-		case "absent":
-			state = false;
-			break;
-
-		case "unknown":
-			state = null;
-			break;
-	}
-
-	// Make request
-	var req;
-	req = $.ajax(`/groups/${group}/activities/${activity}/presence`,
-		{
-		  method: 'PUT',
-		  data: {person_id: person, attending: state},
-		  statusCode: {
-			423: function() {
-				alert( "De deadline is al verstreken! Vraag orgi of bestuur of het nog kan.");
-			},
-			403: function() {
-				alert( "Je hebt geen rechten om iemand anders aan te passen!");
-			}
-		  }
-		}
-	)
-	.done( activity_changed );
-
-	// Pack data for success
-	req.aardbei_activity_data =
-		{
-			group: group,
-			person: person,
-			activity: activity,
-			state: state
-		};
+    // Gather data
+    var group, person, activity, state;
+    group    = this.dataset["groupId"];
+    person   = this.dataset["personId"];
+    activity = this.dataset["activityId"];
+    rstate   = this.dataset["newState"];
+
+    var state;
+    switch (rstate)
+    {
+        case "present":
+            state = true;
+            break;
+
+        case "absent":
+            state = false;
+            break;
+
+        case "unknown":
+            state = null;
+            break;
+    }
+
+    // Make request
+    var req;
+    req = $.ajax(`/groups/${group}/activities/${activity}/presence`,
+        {
+          method: 'PUT',
+          data: {person_id: person, attending: state},
+          statusCode: {
+            423: function() {
+                alert( "De deadline is al verstreken! Vraag orgi of bestuur of het nog kan.");
+            },
+            403: function() {
+                alert( "Je hebt geen rechten om iemand anders aan te passen!");
+            }
+          }
+        }
+    )
+    .done( activity_changed );
+
+    // Pack data for success
+    req.aardbei_activity_data =
+        {
+            group: group,
+            person: person,
+            activity: activity,
+            state: state
+        };
 }
 
 // Update all references on the page to this activity:
 // 2. The present/absent buttons
 function activity_changed(data, textStatus, xhr)
 {
-	// Unpack activity-data
-	var target;
-	target = xhr.aardbei_activity_data;
-
-	// Determine what color and icons we're going to use
-	var new_rowclass;
-	var new_confirm_icon, new_decline_icon;
-	switch (target.state)
-	{
-		case true:
-			new_rowclass = "success";
-			new_confirm_icon = check_selected;
-			new_decline_icon = times_unselected;
-			break;
-
-		case false:
-			new_rowclass = "danger";
-			new_confirm_icon = check_unselected;
-			new_decline_icon = times_selected;
-			break;
-
-		case null:
-			new_rowclass = "warning";
-			new_confirm_icon = check_unselected;
-			new_decline_icon = times_unselected;
-			break;
-	}
-
-	// Update all tr's containing this person's presence
-	$(`tr[data-person-id=${target.person}][data-activity-id=${target.activity}]`)
-	  .removeClass('success danger warning')
-	  .addClass(new_rowclass);
-
-	// Update all buttons for this person's presence
+    // Unpack activity-data
+    var target;
+    target = xhr.aardbei_activity_data;
+
+    // Determine what color and icons we're going to use
+    var new_rowclass;
+    var new_confirm_icon, new_decline_icon;
+    switch (target.state)
+    {
+        case true:
+            new_rowclass = "success";
+            new_confirm_icon = check_selected;
+            new_decline_icon = times_unselected;
+            break;
+
+        case false:
+            new_rowclass = "danger";
+            new_confirm_icon = check_unselected;
+            new_decline_icon = times_selected;
+            break;
+
+        case null:
+            new_rowclass = "warning";
+            new_confirm_icon = check_unselected;
+            new_decline_icon = times_unselected;
+            break;
+    }
+
+    // Update all tr's containing this person's presence
+    $(`tr[data-person-id=${target.person}][data-activity-id=${target.activity}]`)
+      .removeClass('success danger warning')
+      .addClass(new_rowclass);
+
+    // Update all buttons for this person's presence
     $(`.btn-present[data-person-id=${target.person}][data-activity-id=${target.activity}]`)
       .html(new_confirm_icon);
     $(`.btn-absent[data-person-id=${target.person}][data-activity-id=${target.activity}]`)
       .append(" Present");
     $(`.btn-absent[data-person-id=${target.person}][data-activity-id=${target.activity}][data-wide=1]`)
       .append(" Absent");
+
+    if (window.updatecounts != undefined)
+        updatecounts(window.subgroupfilter);
 }
 
 function alert_failure(data, textStatus, xhr)
 {
-	alert(`Something broke! We got a ${textStatus}, (${data}).`);
+    alert(`Something broke! We got a ${textStatus}, (${data}).`);
 }
 
 var check_unselected = '<i class="fa fa-check"></i>';

app/controllers/activities_controller.rb

 class ActivitiesController < ApplicationController
   include GroupsHelper
   include ActivitiesHelper
-  before_action :set_activity_and_group, only: [:show, :edit, :update, :destroy, :presence, :change_organizer]
-  before_action :set_group,            except: [:show, :edit, :update, :destroy, :presence, :change_organizer]
+
+  has_activity_id = [
+    :show, :edit, :edit_subgroups, :update, :update_subgroups, :destroy,
+    :presence, :change_organizer, :create_subgroup, :update_subgroup,
+    :destroy_subgroup, :immediate_subgroups, :clear_subgroups
+  ]
+  before_action :set_activity_and_group, only: has_activity_id
+  before_action :set_group,            except: has_activity_id
+
+  before_action :set_subgroup, only: [:update_subgroup, :destroy_subgroup]
   before_action :require_membership!
-  before_action :require_leader!, only: [:mass_new, :mass_create, :new, :create, :destroy]
-  before_action :require_organizer!, only: [:edit, :update, :change_organizer]
+  before_action :require_leader!, only: [
+    :mass_new, :mass_create, :new, :create, :destroy
+  ]
+  before_action :require_organizer!, only: [
+    :edit, :update, :change_organizer, :create_subgroup, :update_subgroup,
+    :destroy_subgroup, :edit_subgroups, :update_subgroups, :immediate_subgroups,
+    :clear_subgroups
+  ]
 
   # GET /groups/:id/activities
   # GET /activities.json
   def index
-    @activities = @group.activities
-      .where('start > ?', Time.now)
-      .order(start: :asc)
-      .paginate(page: params[:page], per_page: 25)
+    if params[:past]
+      @activities = @group.activities
+        .where('start < ?', Time.now)
+        .order(start: :desc)
+        .paginate(page: params[:page], per_page: 25)
+    else
+      @activities = @group.activities
+        .where('start > ?', Time.now)
+        .order(start: :asc)
+        .paginate(page: params[:page], per_page: 25)
+    end
   end
 
   # GET /activities/1
       .find_by(person: current_person)
     @counts = @activity.state_counts
     @num_participants = @counts.values.sum
+    @assignable_subgroups = @activity.subgroups
+      .where(is_assignable: true)
+      .order(name: :asc)
+      .pluck(:name)
+    @subgroup_ids = @activity.subgroups
+      .order(name: :asc)
+      .pluck(:name, :id)
+    @subgroup_ids.prepend( [I18n.t('activities.subgroups.filter_nofilter'), 'all'] )
+    @subgroup_ids.append( [I18n.t('activities.subgroups.filter_nogroup'), 'withoutgroup'] )
   end
 
   # GET /activities/new
     set_edit_parameters!
   end
 
+  # GET /activities/1/edit_subgroups
+  def edit_subgroups
+    @subgroups = @activity.subgroups.order(is_assignable: :desc, name: :asc)
+
+    if @subgroups.none?
+      flash_message(:error, I18n.t('activities.errors.cannot_subgroup_without_subgroups'))
+      redirect_to group_activity_edit(@group, @activity)
+    end
+
+    @subgroup_options = @subgroups.map { |sg| [sg.name, sg.id] }
+    @subgroup_options.prepend(['--', 'nil'])
+
+    @participants = @activity.participants
+      .joins(:person)
+      .where.not(attending: false)
+      .order(:subgroup_id)
+      .order('people.first_name', 'people.last_name')
+  end
+
+  # POST /activities/1/update_subgroups
+  def update_subgroups
+    Participant.transaction do
+      # For each key in participant_subgroups:
+      params[:participant_subgroups].each do |k, v|
+        # Get Participant, Subgroup
+        p = Participant.find_by id: k
+        sg = Subgroup.find_by id: v unless v == 'nil'
+
+        # Verify that the Participant and Subgroup belong to this activity
+        # Edit-capability is enforced by before_filter.
+        if !p || p.activity != @activity || (!sg && v != 'nil') || (sg && sg.activity != @activity)
+          flash_message(:danger, I18n.t(:somethingbroke))
+          redirect_to group_activity_edit_subgroups_path(@group, @activity)
+          raise ActiveRecord::Rollback
+        end
+
+        if v != 'nil'
+          p.subgroup = sg
+        else
+          p.subgroup = nil
+        end
+
+        p.save
+      end
+    end
+
+    flash_message(:success, I18n.t('activities.subgroups.edited'))
+    redirect_to edit_group_activity_path(@group, @activity, anchor: 'subgroups')
+  end
+
+  # POST /activities/1/immediate_subgroups
+  def immediate_subgroups
+    if params[:overwrite]
+      @activity.clear_subgroups!
+    end
+
+    @activity.assign_subgroups!
+
+    if params[:overwrite]
+      flash_message(:success, I18n.t('activities.subgroups.redistributed'))
+    else
+      flash_message(:success, I18n.t('activities.subgroups.remaining_distributed'))
+    end
+
+    redirect_to edit_group_activity_path(@group, @activity)
+  end
+
+  # POST /activities/1/clear_subgroups
+  def clear_subgroups
+    @activity.clear_subgroups!
+
+    flash_message(:success, I18n.t('activities.subgroups.cleared'))
+    redirect_to edit_group_activity_path(@group, @activity)
+  end
+
   # Shared lookups for rendering the edit-view
   def set_edit_parameters!
     @non_organizers = @activity.participants.where(is_organizer: [false, nil])
 
     @non_organizers_options.sort!
     @organizers_options.sort!
+
+    @subgroup = Subgroup.new if !@subgroup
+    @subgroups = @activity.subgroups.order(is_assignable: :desc, name: :asc)
   end
 
   # POST /activities
     end
     flash_message(:success, message)
 
-    redirect_to edit_group_activity_path(@group, @activity)
+    redirect_to edit_group_activity_path(@group, @activity, anchor: 'organizers-add')
   end
 
   # PATCH/PUT /activities/1
     end
   end
 
+  # POST /activities/1/subgroups
+  def create_subgroup
+    @subgroup = Subgroup.new(subgroup_params)
+    @subgroup.activity = @activity
+
+    if @subgroup.save
+      flash_message :success, I18n.t('activities.subgroups.created')
+      redirect_to edit_group_activity_path(@group, @activity, anchor: 'subgroups-add')
+    else
+      flash_message :danger, I18n.t('activities.subgroups.create_failed')
+      set_edit_parameters!
+      render :edit
+    end
+  end
+
+  # PATCH /activities/1/subgroups/:subgroup_id
+  def update_subgroup
+    if @subgroup.update(subgroup_params)
+      flash_message :success, I18n.t('activities.subgroups.updated')
+      redirect_to edit_group_activity_path(@group, @activity, anchor: 'subgroups')
+    else
+      flash_message :danger, I18n.t('activities.subgroups.update_failed')
+      set_edit_parameters!
+      render :edit
+    end
+  end
+
+  # DELETE /activities/1/subgroups/:subgroup_id
+  def destroy_subgroup
+    @subgroup.destroy
+    flash_message :success, I18n.t('activities.subgroups.destroyed')
+    redirect_to edit_group_activity_path(@group, @activity, anchor: 'subgroups')
+  end
+
   # PATCH/PUT /groups/:group_id/activities/:id/presence
   # PATCH/PUT /groups/:group_id/activities/:id/presence.json
   def presence
       @group = Group.find(params[:group_id])
     end
 
+    def set_subgroup
+      @subgroup = Subgroup.find(params[:subgroup_id])
+    end
+
     # Never trust parameters from the scary internet, only allow the white list through.
     def activity_params
-      params.require(:activity).permit(:name, :description, :location, :start, :end, :deadline, :reminder_at)
+      params.require(:activity).permit(:name, :description, :location, :start, :end, :deadline, :reminder_at, :subgroup_division_enabled, :no_response_action)
+    end
+
+    def subgroup_params
+      params.require(:subgroup).permit(:name, :is_assignable)
     end
 end

app/controllers/dashboard_controller.rb

       .joins(:activity)
       .where('activities.end >= ? OR (activities.end IS NULL AND activities.start >= ?)', DateTime.now, DateTime.now)
       .order('activities.start ASC')
-      .paginate(page: params[:upage], per_page: 10)
     @user_organized = @upcoming
       .where(is_organizer: true)
       .limit(3)
+    @upcoming = @upcoming
+      .paginate(page: params[:upage], per_page: 10)
     @need_response = @upcoming
       .where(attending: nil)
       .paginate(page: params[:nrpage], per_page: 5)

app/controllers/groups_controller.rb

 class GroupsController < ApplicationController
   include GroupsHelper
-  before_action :set_group, only: [:show, :edit, :update, :destroy]
-  before_action :require_admin!, only: [:index, :process_mass_add_members, :mass_add_members]
+  before_action :set_group, only: [:show, :edit, :update, :destroy, :create_default_subgroup, :update_default_subgroup, :destroy_default_subgroup, :mass_add_members, :process_mass_add_members]
+  before_action :set_default_subgroup, only: [:update_default_subgroup, :destroy_default_subgroup]
+  before_action :require_admin!, only: [:index]
   before_action :require_membership!, only: [:show]
-  before_action :require_leader!, only: [:edit, :update, :destroy]
+  before_action :require_leader!, only: [:edit, :update, :destroy, :create_default_subgroup, :update_default_subgroup, :destroy_default_subgroup, :process_mass_add_members, :mass_add_members]
 
   # GET /groups
   # GET /groups.json
   # GET /groups/1
   # GET /groups/1.json
   def show
-    @organized_activities = current_person.organized_activities.
-      joins(:activity).where(
-        'activities.group_id': @group.id
-    )
-    if @organized_activities.count > 0
+    @organized_activities = current_person
+      .organized_activities
+      .joins(:activity)
+      .where('activities.group_id': @group.id)
+      .where('start > ?', Date.today)
+
+    if @organized_activities.any?
       @groupmenu = 'col-md-6'
     else
       @groupmenu = 'col-md-12'
 
   # GET /groups/1/edit
   def edit
+    @defaultsubgroup = DefaultSubgroup.new
   end
 
   # POST /groups
         }
         format.json { render :show, status: :ok, location: @group }
       else
+        @defaultsubgroup = DefaultSubgroup.new
         format.html { render :edit }
         format.json { render json: @group.errors, status: :unprocessable_entity }
       end
   end
 
   def mass_add_members
-    @group = Group.find(params[:group_id])
   end
 
   def process_mass_add_members
-    @group = Group.find(params[:group_id])
     require 'csv'
     uploaded_io = params[:spreadsheet]
     result = Person.from_csv(uploaded_io.read)
 
     result.each do |p|
       m = Member.find_by(person: p, group: @group)
-      if not m
+      unless m
         m = Member.new(person: p, group: @group)
         m.save!
       end
     end
-    flash_message(:success, "#{result.count} people added to group")
+    flash_message(:success, I18n.t('groups.mass_add_success', count: result.count))
     redirect_to group_members_path(@group)
   end
 
+  # POST /groups/:id/default_subgroups
+  def create_default_subgroup
+    @defaultsubgroup = DefaultSubgroup.new(default_subgroup_params)
+    @defaultsubgroup.group = @group
+
+    if @defaultsubgroup.save
+      flash_message(:success, I18n.t('defaultsubgroups.created'))
+      redirect_to edit_group_path(@group)
+    else
+      flash_message(:danger, I18n.t('defaultsubgroups.create_failed'))
+      render :edit
+    end
+  end
+
+  # PATCH /groups/:id/default_subgroups/:default_subgroup_id
+  def update_default_subgroup
+    if @defaultsubgroup.update(default_subgroup_params)
+      flash_message(:success, I18n.t('defaultsubgroups.updated'))
+      redirect_to edit_group_path(@group)
+    else
+      flash_message(:danger, I18n.t('defaultsubgroups.update_failed'))
+      render :edit
+    end
+  end
+
+  # DELETE /groups/:id/default_subgroups/:default_subgroup_id
+  def destroy_default_subgroup
+    @defaultsubgroup.destroy
+    flash_message(:info, I18n.t('defaultsubgroups.destroyed'))
+    redirect_to edit_group_path(@group)
+  end
+
   private
     # Use callbacks to share common setup or constraints between actions.
     def set_group
-      @group = Group.find(params[:id])
+      @group = Group.find(params[:group_id] || params[:id])
+    end
+
+    # Retrieve DefaultSubgroup to update or delete
+    def set_default_subgroup
+      @defaultsubgroup = DefaultSubgroup.find(params[:default_subgroup_id])
     end
 
     # Never trust parameters from the scary internet, only allow the white list through.
     def group_params
       params.require(:group).permit(:name)
     end
+
+    def default_subgroup_params
+      params.require(:default_subgroup).permit(:name, :is_assignable)
+    end
 end

app/helpers/authentication_helper.rb

       redirect_to controller: 'authentication', action: 'login_form'
       return false
     end
+
+    Raven.user_context(
+      user_firstname: current_person.first_name
+    )
     return true
   end
 

app/mailers/participant_mailer.rb

     @person = person
     @activity = activity
 
-    subject = I18n.t('activities.emails.attendance_reminder.subject', activity: @activity.name)
+    if activity.no_response_action # is true
+      key = 'activities.emails.attendance_reminder.subject_present'
+    else
+      key = 'activities.emails.attendance_reminder.subject_absent'
+    end
+
+    subject = I18n.t(key, activity: @activity.name)
+
+    mail(to: @person.email, subject: subject)
+  end
+
+  def subgroup_notification(person, activity, participant)
+    @person = person
+    @activity = activity
+
+    @subgroup = participant.subgroup.name
+
+    @others = participant
+      .subgroup
+      .participants
+      .where.not(person: @person)
+      .map { |pp| pp.person.full_name }
+      .sort
+      .join(', ')
+
+    @subgroups = @activity
+      .subgroups
+      .order(name: :asc)
+
+    @organizers = @activity
+      .organizer_names
+      .sort
+      .join(', ')
+
+    subject = I18n.t('activities.emails.subgroup_notification.subject', subgroup: @subgroup, activity: @activity.name)
 
     mail(to: @person.email, subject: subject)
   end

app/models/activity.rb

   # @!attribute reminder_done
   #   @return [Boolean]
   #     whether or not sending the reminder has finished.
+  #
+  # @!attribute subgroup_division_enabled
+  #   @return [Boolean]
+  #     whether automatic subgroup division on the deadline is enabled.
+  #
+  # @!attribute subgroup_division_done
+  #   @return [Boolean]
+  #     whether subgroup division has been performed.
+  #
+  # @!attribute no_response_action
+  #   @return [Boolean]
+  #     what action to take when a participant has not responded and the
+  #     reminder is being sent. True to set the participant to attending, false
+  #     to set to absent.
 
   belongs_to :group
 
     dependent: :destroy
   has_many :people, through: :participants
 
+  has_many :subgroups,
+    dependent: :destroy
+
   validates :name, presence: true
   validates :start, presence: true
   validate  :deadline_before_start, unless: "self.deadline.blank?"
   validate  :end_after_start,       unless: "self.end.blank?"
   validate  :reminder_before_deadline, unless: "self.reminder_at.blank?"
+  validate  :subgroups_for_division_present, on: :update
 
   after_create :create_missing_participants!
-  after_commit :schedule_reminder, if: Proc.new {|a| a.previous_changes["reminder_at"] }
+  after_create :copy_default_subgroups!
+  after_commit :schedule_reminder,
+               if: Proc.new { |a| a.previous_changes["reminder_at"] }
+  after_commit :schedule_subgroup_division,
+               if: Proc.new { |a| (a.previous_changes['deadline'] ||
+                                   a.previous_changes['subgroup_division_enabled']) &&
+                                  !a.subgroup_division_done &&
+                                  a.subgroup_division_enabled }
 
   # Get all people (not participants) that are organizers. Does not include
   # group leaders, although they may modify the activity as well.
     self.participants.includes(:person).where(is_organizer: true)
   end
 
+  def organizer_names
+    self.organizers.map { |o| o.person.full_name }
+  end
+
   # Determine whether the passed Person participates in the activity.
   def is_participant?(person)
     Participant.exists?(
     end
   end
 
+  # Create Subgroups from the defaults set using DefaultSubgroups
+  def copy_default_subgroups!
+    defaults = self.group.default_subgroups
+
+    # If there are no subgroups, there cannot be subgroup division.
+    self.update_attribute(:subgroup_division_enabled, false) if defaults.none?
+
+    defaults.each do |dsg|
+      sg = Subgroup.new(activity: self)
+      sg.name = dsg.name
+      sg.is_assignable = dsg.is_assignable
+      sg.save! # Should never fail, as DSG and SG have identical validation, and names cannot clash.
+    end
+
+  end
+
   # Create multiple Activities from data in a CSV file, assign to a group, return.
   def self.from_csv(content, group)
     reader = CSV.parse(content, {headers: true, skip_blanks: true})
       st            = Time.strptime(row['start_time'], '%H:%M')
       a.start       = Time.zone.local(sd.year, sd.month, sd.day, st.hour, st.min)
 
-      if not row['end_date'].blank?
+      unless row['end_date'].blank?
         ed          = Date.strptime(row['end_date'])
         et          = Time.strptime(row['end_time'], '%H:%M')
         a.end       = Time.zone.local(ed.year, ed.month, ed.day, et.hour, et.min)
       end
 
-      dd            = Date.strptime(row['deadline_date'])
-      dt            = Time.strptime(row['deadline_time'], '%H:%M')
-      a.deadline    = Time.zone.local(dd.year, dd.month, dd.day, dt.hour, dt.min)
+      unless row['deadline_date'].blank?
+        dd            = Date.strptime(row['deadline_date'])
+        dt            = Time.strptime(row['deadline_time'], '%H:%M')
+        a.deadline    = Time.zone.local(dd.year, dd.month, dd.day, dt.hour, dt.min)
+      end
+
+      unless row['reminder_at_date'].blank?
+        rd            = Date.strptime(row['reminder_at_date'])
+        rt            = Time.strptime(row['reminder_at_time'], '%H:%M')
+        a.reminder_at = Time.zone.local(rd.year, rd.month, rd.day, rt.hour, rt.min)
+      end
+
+      unless row['subgroup_division_enabled'].blank?
+        a.subgroup_division_enabled = row['subgroup_division_enabled'].downcase == 'y'
+      end
+
+      unless row['no_response_action'].blank?
+        a.no_response_action = row['no_response_action'].downcase == 'p'
+      end
 
       result << a
     end
     self.delay(run_at: self.reminder_at).send_reminder
   end
 
+  def schedule_subgroup_division
+    return if self.deadline.nil? || self.subgroup_division_done
+
+    self.delay(run_at: self.deadline).assign_subgroups!(mail: true)
+  end
+
+  # Assign a subgroup to all attending participants without one.
+  def assign_subgroups!(mail= false)
+    # Sanity check: we need subgroups to divide into.
+    return unless self.subgroups.any?
+
+    # Get participants in random order
+    ps = self
+      .participants
+      .where(attending: true)
+      .where(subgroup: nil)
+      .to_a
+
+    ps.shuffle!
+
+    # Get groups, link to participant count
+    groups = self
+      .subgroups
+      .where(is_assignable: true)
+      .to_a
+      .map { |sg| [sg.participants.count, sg] }
+
+    ps.each do |p|
+      # Sort groups so the group with the least participants gets the following participant
+      groups.sort!
+
+      # Assign participant to group with least members
+      p.subgroup = groups.first.second
+      p.save
+
+      # Update the group's position in the list, will sort when next participant is processed.
+      groups.first[0] += 1
+    end
+
+    if mail
+      self.notify_subgroups!
+    end
+  end
+
+  def clear_subgroups!(only_assignable = true)
+    sgs = self
+      .subgroups
+
+    if only_assignable
+    sgs = sgs
+      .where(is_assignable: true)
+    end
+
+    ps = self
+      .participants
+      .where(subgroup: sgs)
+
+    ps.each do |p|
+      p.subgroup = nil
+      p.save
+    end
+  end
+
+  # Notify participants of the current subgroups, if any.
+  def notify_subgroups!
+    ps = self
+      .participants
+      .joins(:person)
+      .where.not(subgroup: nil)
+
+    ps.each do |pp|
+      pp.send_subgroup_notification
+    end
+  end
+
   private
+
   # Assert that the deadline for participants to change the deadline, if any,
   # is set before the event starts.
   def deadline_before_start
       errors.add(:reminder_at, I18n.t('activities.errors.must_be_before_deadline'))
     end
   end
+
+  # Assert that there is at least one divisible subgroup.
+  def subgroups_for_division_present
+    if self.subgroups.where(is_assignable: true).none? && subgroup_division_enabled?
+      errors.add(:subgroup_division_enabled, I18n.t('activities.errors.cannot_divide_without_subgroups'))
+    end
+  end
 end

app/models/default_subgroup.rb

+class DefaultSubgroup < ApplicationRecord
+  belongs_to :group
+
+  validates :name, presence: true, uniqueness: { scope: :group, case_sensitive: false }
+  validates :group, presence: true
+end

app/models/group.rb

   has_many :activities,
     dependent: :destroy
 
+  has_many :default_subgroups,
+    dependent: :destroy
+
   validates :name,
     presence: true,
     uniqueness: {

app/models/participant.rb

 
   belongs_to :person
   belongs_to :activity
+  belongs_to :subgroup, optional: true
+
+  after_validation :clear_subgroup, if: 'self.attending != true'
 
   validates :person_id,
     uniqueness: {
       message: I18n.t('activities.errors.already_in')
     }
 
+  HUMAN_ATTENDING = {
+    true => I18n.t('activities.state.present'),
+    false => I18n.t('activities.state.absent'),
+    nil => I18n.t('activities.state.unknown')
+  }
+
+  # @return [String]
+  #   the name for the Participant's current state in the current locale.
+  def human_attending
+    HUMAN_ATTENDING[self.attending]
+  end
+
   # TODO: Move to a more appropriate place
   # @return [String]
   #   the class for a row containing this activity.
   def send_reminder
     return unless self.attending.nil?
 
-    self.attending = true
+    self.attending = self.activity.no_response_action
     notes = self.notes || ""
     notes << '[auto]'
     self.notes = notes
     ParticipantMailer.attendance_reminder(self.person, self.activity).deliver_later
   end
 
+  # Send subgroup information email if person is attending.
+  def send_subgroup_notification
+    return unless self.attending && self.subgroup
+
+    ParticipantMailer.subgroup_notification(self.person, self.activity, self).deliver_later
+  end
+
+  # Clear subgroup if person is set to 'not attending'.
+  def clear_subgroup
+    self.subgroup = nil
+  end
+
 end

app/models/subgroup.rb

+class Subgroup < ApplicationRecord
+  belongs_to :activity
+  has_many :participants
+
+  validates :name, presence: true, uniqueness: { scope: :activity, case_sensitive: false }
+  validates :activity, presence: true
+
+  def participant_names
+    self
+      .participants
+      .joins(:person)
+      .map { |p| p.person.full_name }
+      .sort
+  end
+end

app/views/activities/_form.html.erb

 <%= form_for([@group, activity]) do |f| %>
   <% if activity.errors.any? %>
     <div id="error_explanation">
-      <h2><%= pluralize(activity.errors.count, "error") %> prohibited this activity from being saved:</h2>
+      <h2>
+        <%= I18n.t(:could_not_be_saved, errorcount: I18n.t(:error, count: activity.errors.count), class: I18n.t('activities.singular')) %>
+      </h2>
 
       <ul>
       <% activity.errors.full_messages.each do |message| %>
       <%= f.label :deadline %>
       <%= f.datetime_field :deadline, class: 'form-control' %>
     </div>
+    <div class="form-group row">
+      <div class="col-md-6">
+        <%= f.label :reminder_at %>
+        <%= f.datetime_field :reminder_at, class: 'form-control' %>
+      </div>
+      <div class="col-md-6">
+        <%= f.label :no_response_action %>
+        <%= f.select(:no_response_action, options_for_select([
+          [I18n.t('activities.no_response_action.auto_present'), 'true'],
+          [I18n.t('activities.no_response_action.auto_absent'), 'false']
+        ], selected: @activity.no_response_action.to_s), {}, {class: 'form-control'}) %>
+      </div>
+    </div>
     <div class="form-group">
-      <%= f.label :reminder_at %>
-      <%= f.datetime_field :reminder_at, class: 'form-control' %>
+      <div class="check-box">
+        <%= f.check_box(:subgroup_division_enabled) %>
+        <%= t 'activerecord.attributes.activity.subgroup_division_enabled' %>
+      </div>
+    </div>
+    <div class="form-group btn-group">
+      <%= f.submit class: 'btn btn-primary' %>
+      <% unless activity.new_record? %>
+        <%= link_to I18n.t('activities.subgroups.distribute_remaining'),
+          { action: 'immediate_subgroups', group_id: activity.group_id, activity_id: activity.id },
+          class: 'btn btn-warning',
+          method: :post,
+          data: { confirm: I18n.t('activities.subgroups.distribute_remaining_explanation')}
+        %>
+        <%= link_to I18n.t('activities.subgroups.redistribute'),
+          { action: 'immediate_subgroups', group_id: activity.group_id, activity_id: activity.id, overwrite: true },
+          method: :post,
+          class: 'btn btn-danger',
+          data: { confirm: I18n.t('activities.subgroups.redistribute_explanation')}
+        %>
+        <%= link_to I18n.t('activities.subgroups.clear'),
+          { action: 'clear_subgroups', group_id: activity.group_id, activity_id: activity.id, },
+          method: :post,
+          class: 'btn btn-danger',
+          data: { confirm: I18n.t('activities.subgroups.clear_explanation')}
+        %>
+      <% end %>
     </div>
-    <%= f.submit class: 'btn btn-primary' %>
   </div>
 <% end %>

app/views/activities/_state_counts.html.haml

 (
 %span.state-count.present-count
   = counts[true] or 0
-  P
-,
+P,
 %span.state-count.unknown-count
   = counts[nil] or 0
-  ?
-,
+?,
 %span.state-count.absent-count
   = counts[false] or 0
-  A
-)
+A)

app/views/activities/edit.html.haml

   = t 'activities.organizers.manage'
 .row
   .col-md-6
-    %h4
+    %h4#organizers-add
       = t 'activities.organizers.add'
     - if @non_organizers.count > 0
       = form_tag(group_activity_change_organizer_path(@group, @activity), method: 'post') do
       = t 'activities.organizers.no_non_organizers'
 
   .col-md-6
-    %h4
+    %h4#organizers-remove
       = t 'activities.organizers.remove'
     - if @organizers.count > 0
       = form_tag(group_activity_change_organizer_path(@group, @activity), method: 'post') do
     - else
       = t 'activities.organizers.no_organizers'
 
-= link_to t(:back), group_activity_path(@group, @activity)
-|
-= link_to t(:overview), group_activities_path(@group)
+%h2
+  = t 'activities.subgroups.manage'
+
+.row
+  .col-md-6
+    %h4#subgroups-add
+      = t 'activities.subgroups.create'
+
+    = form_for(@subgroup, url: group_activity_create_subgroup_path(@group, @activity), method: :post) do |f|
+
+      - if @subgroup.errors.any?
+        .has-error.form-group#error_explanation
+          %ul
+            - @subgroup.errors.full_messages.each do |message|
+              %li= message
+
+      .form-group{ class: [ ('has-error' if @subgroup.errors.any?) ] }
+
+        %label
+          = t 'activerecord.attributes.subgroup.name'
+        = f.text_field :name, class: 'form-control'
+
+      .form-group
+        .check-box
+          %label
+            = f.check_box :is_assignable
+            = t 'activerecord.attributes.subgroup.is_assignable'
+            (
+            %i.fa.fa-random
+            )
+
+      = f.submit t('activities.subgroups.create'), class: 'btn btn-success'
+
+  .col-md-6#subgroups
+    - if @activity.subgroups.blank?
+      %p
+        = t 'activities.subgroups.none'
+    - else
+      %table.table
+        %tr
+          %th
+            = t 'activerecord.attributes.subgroup.name'
+
+          %th
+            %i.fa.fa-random
+
+          %th
+            %i.fa.fa-cogs
+        - @subgroups.each do |sg|
+          %tr
+            %td
+              = sg.name
+              = surround '(', ')' do
+                = sg.participants.count
+            %td
+              = link_to group_activity_update_subgroup_path(@group, @activity, sg.id, 'subgroup[is_assignable]' => !sg.is_assignable), method: :patch, class: 'btn btn-default btn-xs' do
+                - if sg.is_assignable
+                  %i.fa.fa-check
+                - else
+                  %i.fa.fa-times
+
+            %td
+              = link_to group_activity_destroy_subgroup_path(@group, @activity, sg.id), method: :delete, class: 'btn btn-danger btn-xs' do
+                %i.fa.fa-trash
+
+      = link_to(group_activity_edit_subgroups_path(@group, @activity), class: 'btn btn-default') do
+        %i.fa.fa-edit
+        = t 'activities.subgroups.edit'
+
+
+.btn-group
+  = link_to t(:back), group_activity_path(@group, @activity), class: 'btn btn-default'
+  = link_to t(:overview), group_activities_path(@group), class: 'btn btn-default'

app/views/activities/edit_subgroups.html.haml

+.row
+  .alert.alert-info
+    = t 'activities.subgroups.only_present_people'
+.row
+  .col-md-12
+    = form_tag(group_activity_update_subgroups_path(@group, @activity)) do
+      %table.table
+        %tr
+          %th
+            Naam
+
+          %th
+            Huidig
+
+          %th
+            Nieuw
+
+        - @participants.each do |p|
+          %tr
+            %td
+              = p.person.full_name
+
+            %td
+              = p.subgroup&.name || '--'
+
+            %td
+              = select_tag("participant_subgroups[#{p.id}]", options_for_select(@subgroup_options, p.subgroup_id || 'nil'), class: 'form-control input-sm')
+
+      = submit_tag("Opslaan", class: 'btn btn-primary')
+      = link_to(edit_group_activity_path(@group, @activity), class: 'btn btn-default') do
+        = t :back

app/views/activities/index.html.haml

 %h1
-  = t 'activerecord.models.activity.other'
-
-= link_to new_group_activity_path(@group), class: 'btn btn-default pull-right' do
-  %i.fa.fa-plus
-  = t 'activities.new'
+  - if params[:past]
+    = t 'activities.past'
+  - else
+    = t 'activities.upcoming'
 
 - isleader = @group.leaders.include?(current_person) || current_person.is_admin?
+.btn-group.pull-right
+  - if params[:past]
+    = link_to group_activities_path(@group), class: 'btn btn-default' do
+      %i.fa.fa-history
+      = t 'activities.upcoming'
+  - else
+    = link_to group_activities_path(@group, past: true), class: 'btn btn-default' do
+      %i.fa.fa-history
+      = t 'activities.past'
+  - if isleader
+    = link_to new_group_activity_path(@group), class: 'btn btn-default' do
+      %i.fa.fa-plus
+      = t 'activities.new'
 
 %table.table
   %thead
     %tr
       %th
-        = t 'activerecord.attributes.activities.name'
+        = t 'activerecord.attributes.activity.name'
 
       %th
-        = t 'activerecord.attributes.activities.start'
+        = t 'activerecord.attributes.activity.start'
 
       %th
         P/A/?
               %i.fa.fa-pencil
 
 = will_paginate @activities
-

app/views/activities/mass_new.html.haml

     .col-md-12
       = form_tag(group_activities_mass_new_path(@group), method: 'post', multipart: true) do
         .form-group
-          = file_field_tag 'spreadsheet'
+          = file_field_tag 'spreadsheet', required: true
         .form-group
-          = submit_tag
+          = submit_tag("Go!", class: 'btn btn-warning', confirm: t(:areyousure))

app/views/activities/show.html.haml

 
 
       %table.table
-        %tr
-          %td
-            = t 'activities.attrs.organizers'
-          %td
-            = @organizers
-        %tr
-          %td
-            = t 'activities.attrs.description'
-          %td
-            = @activity.description
+        - unless @organizers.blank?
+          %tr
+            %td
+              = t 'activities.attrs.organizers'
+            %td
+              = @organizers
 
-        %tr
-          %td
-            = t 'activities.attrs.where'
-          %td
-            = @activity.location
+        - unless @activity.description.blank?
+          %tr
+            %td
+              = t 'activities.attrs.description'
+            %td
+              = @activity.description
+
+        - unless @activity.location.blank?
+          %tr
+            %td
+              = t 'activities.attrs.where'
+            %td
+              = @activity.location
 
         %tr
           %td
               - else
                 = l @activity.end, format: :long
 
-        %tr
-          %td
-            = t 'activities.attrs.deadline'
+        - if @activity.deadline
+          %tr
+            %td
+              = t 'activities.attrs.deadline'
 
-          %td
-            - if @activity.deadline
+            %td
               = l @activity.deadline, format: :long
 
+        - if @assignable_subgroups.any?
+          %tr
+            %td
+              = t 'activerecord.attributes.activity.subgroups'
+
+            %td
+              = @assignable_subgroups.join(', ')
+
+        - if @ownparticipant&.subgroup
+          %tr
+            %td
+              = t 'activities.participant.yoursubgroup'
+            %td
+              = @ownparticipant.subgroup.name
+
   - if @ownparticipant
     .col-md-3
       .panel.panel-default
             emptytext: t('activities.participant.add_notes')
 
 .hidden-xs
-  %h2
-    = @num_participants
-    = t 'activities.participant.plural'
-    = render partial: "state_counts", locals: {counts: @counts}
+  .row
+    .col-md-6
+      %h2
+        %span.state-count.all-count
+          = @num_participants
+        = t 'activities.participant.plural'
+        = render partial: "state_counts", locals: {counts: @counts}
+    .col-md-6
+      - if @activity.subgroups.any?
+        = select_tag(:subgroup_filter, options_for_select(@subgroup_ids), class: 'form-control subgroup-filter')
 
   %table.table.table-bordered
     - @participants.each do |p|
-      %tr{class: p.row_class, data: {person_id: p.person.id, activity_id: @activity.id}}
+      %tr.participant-row.countable{class: p.row_class, data: {person_id: p.person.id, activity_id: @activity.id, subgroup_id: p.subgroup_id}}
         %td
           = p.person.full_name
           - if p.is_organizer
             = render partial: "activities/presence_buttons", locals: {activity: @activity, person: p.person, state: p.attending}
 
 .hidden-sm.hidden-md.hidden-lg
+  - if @activity.subgroups.any?
+    .panel.panel-default
+      .panel-heading
+        = t 'activerecord.attrs.activities.subgroups'
+      .panel-body
+        = select_tag(:subgroup_filter, options_for_select(@subgroup_ids), class: 'form-control subgroup-filter')
+
   .panel.panel-default.panel-success
     .panel-heading
       %a{role: 'button', href: '#present-collapse', data: {toggle: 'collapse'}, 'aria-expanded': 'false'}
           %i.fa.fa-angle-up
 
         = t 'activities.state.present'
-        %span.badge
+        %span.badge.state-count.present-count
           = @counts[true] || "0"
 
     %table.table.collapse#present-collapse
       %tbody
         - @participants.where(attending: true).each do |p|
-          %tr{data: {person_id: p.person.id, activity_id: @activity.id}}
+          %tr.participant-row{data: {person_id: p.person.id, activity_id: @activity.id, subgroup_id: p.subgroup_id}}
             %td
               = p.person.full_name
               - if p.is_organizer
               - if p.person.id == current_person.id || all_buttons
                 = render partial: "activities/presence_buttons", locals: {activity: @activity, person: p.person, state: p.attending}
 
-          %tr{data: {person_id: p.person_id, activity_id: @activity.id}}
+          %tr.participant-row{data: {person_id: p.person_id, activity_id: @activity.id, subgroup_id: p.subgroup_id}}
             %td{colspan: "2"}
               = editable p, :notes, url: presence_group_activity_path(@activity.group, @activity, person_id: p.person_id), title: t('activities.participant.notes'), value: p.notes, emptytext: "--"
 
 
         = t 'activities.state.need_response'
 
-        %span.badge
+        %span.badge.state-count.unknown-count
           = @counts[nil] || "0"
 
     %table.table.collapse#unknown-collapse
       %tbody
         - @participants.where(attending: nil).each do |p|
-          %tr{data: {person_id: p.person.id, activity_id: @activity.id}}
+          %tr.participant-row{data: {person_id: p.person.id, activity_id: @activity.id, subgroup_id: p.subgroup_id}}
             %td
               = p.person.full_name
               - if p.is_organizer
               - if p.person.id == current_person.id || all_buttons
                 = render partial: "activities/presence_buttons", locals: {activity: @activity, person: p.person, state: p.attending}
 
-          %tr{data: {person_id: p.person_id, activity_id: @activity.id}}
+          %tr.participant-row{data: {person_id: p.person_id, activity_id: @activity.id, subgroup_id: p.subgroup_id}}
             %td{colspan: "2"}
               = editable p, :notes, url: presence_group_activity_path(@activity.group, @activity, person_id: p.person_id), title: t('activities.participant.notes'), value: p.notes, emptytext: "--"
 
 
         = t 'activities.state.absent'
 
-        %span.badge
+        %span.badge.state-count.absent-count
           = @counts[false] || "0"
 
     %table.table.collapse#absent-collapse
       %tbody
         - @participants.where(attending: false).each do |p|
-          %tr{data: {person_id: p.person.id, activity_id: @activity.id}}
+          %tr.participant-row{data: {person_id: p.person.id, activity_id: @activity.id, subgroup_id: p.subgroup_id}}
             %td
               = p.person.full_name
               - if p.is_organizer
               - if p.person.id == current_person.id || all_buttons
                 = render partial: "activities/presence_buttons", locals: {activity: @activity, person: p.person, state: p.attending}
 
-          %tr{data: {person_id: p.person_id, activity_id: @activity.id}}
+          %tr.participant-row{data: {person_id: p.person_id, activity_id: @activity.id, subgroup_id: p.subgroup_id}}
             %td{colspan: "2"}
               = editable p, :notes, url: presence_group_activity_path(@activity.group, @activity, person_id: p.person_id), title: t('activities.participant.notes'), value: p.notes, emptytext: "--"

app/views/activities/subgroup_editor.html.haml

+.row
+  .col-md-12
+    %table.table
+      %tr
+        %th
+          Naam
+
+        %th
+          Status
+
+        %th
+          Huidig
+
+        %th
+          Nieuw
+
+      - @participants.each do |p|
+        %td
+          = p.person.full_name
+
+        %td
+          = p.attending
+
+        %td
+          = p.subgroup.name
+
+        %td
+          TODO

app/views/dashboard/home.html.haml

                     = link_to group do
                       = group.name
 
-    .col-md-6
-      .panel.panel-default
-        .panel-heading
-          = t 'dashboard.organized_you'
+    - if @user_organized.any?
+      .col-md-6
+        .panel.panel-default
+          .panel-heading
+            = t 'dashboard.organized_you'
 
-        .panel-body
-          %table.table.table-striped.table-bordered
-            %tbody
-              - @user_organized.each do |p|
-                - a = p.activity
-                %tr
-                  %td
-                    = link_to group_activity_url(a.group, a) do
-                      = a.name
-                      = "(#{a.human_state_counts})"
+          .panel-body
+            %table.table.table-striped.table-bordered
+              %tbody
+                - @user_organized.each do |p|
+                  - a = p.activity
+                  %tr
+                    %td
+                      = link_to group_activity_url(a.group, a) do
+                        = a.name
+                        = "(#{a.human_state_counts})"
 
   .row
     .col-md-12

app/views/groups/edit.html.erb

-<h1>Editing Group</h1>
-
-<%= render 'form', group: @group %>
-
-<%= link_to 'Show', @group %> |
-<%= link_to 'Back', groups_path %>

app/views/groups/edit.html.haml

+%h1
+  = t 'groups.edit'
+
+= render 'form', group: @group
+
+%h2
+  = t 'defaultsubgroups.manage'
+
+%p
+  = t 'defaultsubgroups.settings_blurb'
+
+.row
+  .col-md-6
+    %h4
+      = t 'defaultsubgroups.create'
+
+    -#= form_tag(group_create_default_subgroup_path(@group), method: :post, class: 'form') do
+    = form_for(@defaultsubgroup, url: group_create_default_subgroup_path(@group), method: :post) do |f|
+      - if @defaultsubgroup.errors.any?
+        .has-error.form-group#error_explanation
+          %ul
+            - @defaultsubgroup.errors.full_messages.each do |message|
+              %li
+                = message
+
+      .form-group{ class: [ ('has-error' if @defaultsubgroup.errors.any?) ] }
+        %label
+          = t 'activerecord.attributes.default_subgroup.name'
+        = f.text_field(:name, class: 'form-control')
+
+      .form-group
+        .check-box
+          %label
+            = f.check_box(:is_assignable)
+            = t 'activerecord.attributes.default_subgroup.is_assignable'
+
+      = f.submit t('defaultsubgroups.create'), class: 'btn btn-success'
+
+  .col-md-6
+    %h4
+      = t 'defaultsubgroups.destroy'
+
+    - if @group.default_subgroups.blank?
+      %p
+        = t 'defaultsubgroups.none'
+
+    - else
+      = form_tag(group_destroy_default_subgroup_path(@group), method: :delete, class: 'form') do
+        .form-group
+          %label
+            = t 'activerecord.models.default_subgroup.one'
+          - options = @group.default_subgroups.pluck(:name, :id)
+          = select_tag(:default_subgroup_id, options_for_select(options), class: 'form-control')
+
+        = submit_tag(t('defaultsubgroups.destroy'), class: 'btn btn-danger')
+
+.row
+  .col-md-12
+    .btn-group
+      = link_to t(:back), @group, class: 'btn btn-default'
+      = link_to t('activities.mass_import_short'), group_activities_mass_new_path(@group), class: 'btn btn-default'
+      = link_to t('groups.mass_add_short'), group_mass_add_path(@group), class: 'btn btn-default'

app/views/groups/mass_add_members.html.haml

   .row
     .col-md-12
       %h1
-        Mass-adding members to
-        = @group.name
-      = form_tag("/groups/#{@group.id}/mass_add", method: 'post', multipart: true) do
-        = file_field_tag 'spreadsheet'
-        = submit_tag
+        = t 'groups.mass_add_members', group: @group.name
+  .row
+    .col-md-12
+      %p
+        = t 'groups.mass_add_explanation'
+      = link_to asset_path('batch_persons.csv'), class: 'btn btn-default' do
+        = t :download
+  .row
+    .col-md-12
+      = form_tag(group_mass_add_path(@group), method: 'post', multipart: true) do
+        .form-group
+          = file_field_tag 'spreadsheet', required: true
+        .form-group
+          = submit_tag("Go!", class: 'btn btn-warning', confirm: t(:areyousure))

app/views/participant_mailer/attendance_reminder.html.haml

 %p= t 'authentication.emails.greeting', name: @person.first_name
 
-%p= t 'activities.emails.attendance_reminder.havenot_responded', activity: @activity.name
+- if @activity.no_response_action
+  %p= t 'activities.emails.attendance_reminder.set_to_present', activity: @activity.name
+- else
+  %p= t 'activities.emails.attendance_reminder.set_to_absent', activity: @activity.name
 
 %p= t 'activities.emails.attendance_reminder.if_cannot', deadline: l(@activity.deadline, format: :short)
 

app/views/participant_mailer/attendance_reminder.text.erb

 <%= t 'authentication.emails.greeting', name: @person.first_name %>
 
-<%= t 'activities.emails.attendance_reminder.havenot_responded', activity: @activity.name %>
+<% if @activity.no_response_action %>
+<%= t 'activities.emails.attendance_reminder.set_to_present', activity: @activity.name %>
+<% else %>
+<%= t 'activities.emails.attendance_reminder.set_to_absent', activity: @activity.name %>
+<% end %>
 
 <%= t 'activities.emails.attendance_reminder.if_cannot', deadline: l(@activity.deadline, format: :short) %>
 

app/views/participant_mailer/subgroup_notification.html.haml

+%p= t 'authentication.emails.greeting', name: @person.first_name
+
+%p= t 'activities.emails.subgroup_notification.yoursubgroupis', activity: @activity.name, subgroup: @subgroup
+
+- if !@others.empty?
+  %p= t 'activities.emails.subgroup_notification.subgroupmembers', others: @others
+- else
+  %p= t 'activities.emails.subgroup_notification.noothersinsubgroup'
+
+%p= t 'activities.emails.subgroup_notification.allsubgroups'
+%ul
+  - @subgroups.each do |sg|
+    %li
+      = succeed ':' do
+        = sg.name
+      = sg.participant_names.join ', '
+
+%p= t 'activities.emails.subgroup_notification.cannotdecline', organizers: @organizers
+
+%p
+  = link_to group_activity_url(@activity.group, @activity) do
+    = t 'activities.emails.open_activity'
+
+%p
+  = t('activities.emails.ending').sample
+  %br
+  Aardbei
+
+%hr
+%footer
+  %p
+    = t 'activities.emails.cant_turn_off'

app/views/participant_mailer/subgroup_notification.text.erb

+<%= t 'authentication.emails.greeting', name: @person.first_name %>
+
+<%= t 'activities.emails.subgroup_notification.yoursubgroupis', activity: @activity.name, subgroup: @subgroup %>
+
+<% if !@others.empty? %>
+<%= t 'activities.emails.subgroup_notification.subgroupmembers', others: @others %>
+<% else %>
+<%= t 'activities.emails.subgroup_notification.noothersinsubgroup' %>
+<% end %>
+
+<%= t 'activity.emails.subgroup_notification.allsubgroups' %>
+
+<% @subgroups.each do |sg| %>
+- <%= sg.name %>: <%= sg.participant_names.join(', ') %>
+<% end %>
+
+<%= t 'activity.emails.subgroup_notification.cannotdecline', organizers: @organizers %>
+
+<%= group_activity_url(@activity.group, @activity) %>
+
+<%= t('activities.emails.ending').sample %>
+Aardbei
+
+---
+<%= t 'activities.emails.cant_turn_off' %>

config/locales/aardbei_en.yml

 
   invalid_csrf: "You submitted an invalid request! If you got here after clicking a link, it's possible that someone is doing something nasty!"
 
+  could_not_be_saved: "%{errorcount} prevented this %{class} from being saved:"
+
+  error:
+    zero: "no errors"
+    one: "an error"
+    other: "%{count} errors"
+
   activerecord:
     models:
       person:
         end: "End"
         description: "Description"
         deadline: "Deadline"
+        no_response_action: "Action when no response"

config/locales/aardbei_nl.yml

 
   areyousure: "Weet je het zeker?"
 
-  somethingbroke: "Er is iets misgegaan!"
+  somethingbroke: "Er is iets misgegaan! Neem contact op als dit blijft gebeuren."
 
   value_required: "Een verplichte vraag was leeg."
 
   invalid_csrf: "Ongeldig authenticiteitstoken! Als je hier terecht bent gekomen na het klikken op een link is het mogelijk dat iemand iets naars probeerde!"
+
+  could_not_be_saved: "Door %{errorcount} kon deze %{class} niet worden opgeslagen:"
+
+  error:
+    zero: "geen fouten"
+    one: "een fout"
+    other: "%{count} fouten"

config/locales/activities/en.yml

     edit: "Edit activity"
     updated: "Activity updated."
     destroyed: "Activity destroyed."
+    mass_import_short: "Import activities"
     mass_import: "Create multiple activities in %{group}"
     mass_imported: "%{count} activities created!"
 
+    upcoming: 'Upcoming activities'
+    past: 'Past activities'
+
     mass_import_explanation: "Download the example file using the link below, fill in the fields (end and deadline are optional), and upload the file using the upload form."
 
     upcoming_yours: "Upcoming activities organized by you"
     errors:
       must_be_before_start: "must be before start"
       must_be_after_start: "must be after start"
+      must_be_before_deadline: "must be before deadline"
       already_in: "person already participates in activity"
+      cannot_divide_without_subgroups: "a divisible subgroup must exist"
 
     participant:
       singular: "participant"
       notes: "Notes"
       add_notes: "Add notes"
       yourresponse: "Your response"
+      yoursubgroup: "Your subgroup"
 
       copy_responses: "Copy responses"
       copy_absent: "Copy absentees"
       open_activity: "Open activity"
       open_settings: "Preferences"
       dont_want_mail: "If you no longer want to receive these emails, change your preferences using the following link:"
+      cant_turn_off: "This email cannot be disabled, because it contains important information."
       ending:
         - "Cheers,"
       attendance_reminder:
         subject: "You are now listed as 'attending' for %{activity}"
-        havenot_responded: "You have not yet indicated if you will be at %{activity}. Because we assume that you're present if you don't respond, your response has been set to 'attending'."
+        set_to_present: "You have not yet indicated if you will be at %{activity}. Because we assume that you're present if you don't respond, your response has been set to 'attending'."
+        set_to_absent: "You have not yet indicated if you will be at %{activity}. This activity is set to assume to set you to absent if you don't respond, so your response has been set to 'absent'."
         if_cannot: "If you wish to change this, you can change your response until %{deadline} using the following link:"
+
+      subgroup_notification:
+        subject: "You have been assigned to subgroup %{subgroup} for %{activity}"
+        yoursubgroupis: "The upcoming activity %{activity} uses subgroups, and you have been assigned to subgroup %{subgroup}."
+        subgroupmembers: "The other people in this subgroup are: %{others}"
+        noothersinsubgroup: "There are no other people in this subgroup. :("
+        allsubgroups: "All subgroups (including yours):"
+        cannotdecline: "This email was sent when the deadline expired. If you find you cannot attend, please contact the Drerrie, or one of the organisers (%{organizers})."
+
+    subgroups:
+      manage: 'Manage subgroups'
+      create: 'Create subgroup'
+      created: 'Subgroup created.'
+      create_failed: 'Could not create subgroup!'
+
+      edit: 'Edit subgroup division'
+      edited: 'Subgroup division updated.'
+
+      update: 'Update subgroup'
+      updated: 'Subgroup updated.'
+      update_failed: 'Could not update subgroup!'
+
+      destroy: 'Destroy subgroup'
+      destroyed: 'Subgroup destroyed.'
+      none: 'There are no subgroups.'
+
+      filter_nogroup: 'Attending, no subgroup'
+      filter_nofilter: 'Show everyone'
+
+      only_present_people: "Only people who will attend are listed, because people who don't cannot be in a subgroup."
+
+      clear: 'Clear subgroups'
+      clear_explanation: 'This removes everyone in a assignable subgroup from their subgroup! Are you sure you want this?'
+      cleared: 'Subgroups cleared.'
+
+      redistribute: 'Redistribute subgroups'
+      redistribute_explanation: 'This removes everyone in a assignable subgroup from that subgroup, and then randomly reassigns everyone to their subgroup. Are you sure you want this?'
+      redistributed: 'Subgroups redistributed.'
+
+      distribute_remaining: 'Distribute remaining to subgroups'
+      distribute_remaining_explanation: 'This distributes all remaining attending participants not yet in a subgroup to a subgroup. Do you want this?'
+      remaining_distributed: 'Remaining participants distributed.'

config/locales/activities/nl.yml

     edit: "Activiteit bewerken"
     updated: "Activiteit bijgewerkt."
     destroyed: "Activiteit verwijderd."
+    mass_import_short: "Activiteiten importeren"
     mass_import: "Meerdere activiteiten aanmaken in %{group}"
     mass_imported: "%{count} activiteiten aangemaakt!"
 
+    upcoming: 'Aankomende activiteiten'
+    past: 'Afgelopen activiteiten'
+
     mass_import_explanation: "Download het voorbeeldbestand via de link hieronder, vul de velden in in het formaat zoals het staat aangegeven (einde en deadline zijn niet verplicht), en upload het via de knop onderaan."
 
     upcoming_yours: "Aankomende activiteiten georganiseerd door jou"
       must_be_after_start: "moet na start zijn"
       must_be_before_deadline: "moet voor deadline zijn"
       already_in: "persoon doet al mee aan activiteit"
+      cannot_divide_without_subgroups: "moet indeelbare subgroep hebben"
 
     participant:
       singular: "deelnemer"
       notes: "Opmerkingen"
       add_notes: "Opmerkingen toevoegen"
       yourresponse: "Jouw antwoord"
+      yoursubgroup: "Jouw subgroep"
 
       copy_responses: "Kopieer overzicht"
       copy_absent: "Kopieer afwezigen"
       description: "Omschrijving"
       deadline: "Deadline"
 
+    no_response_action:
+      auto_present: 'Automatisch aanmelden'
+      auto_absent: 'Automatisch afmelden'
+
     emails:
       open_activity: "Activiteit openen"
       open_settings: "Instellingen"
       dont_want_mail: "Als je dit soort mailtjes niet meer wilt ontvangen, kun je dit uitschakelen via de volgende link:"
+      cant_turn_off: "Omdat deze mail belangrijk is kan je hem niet uitzetten."
       ending:
         - "Met griendelijke vroet,"
         - "Met groetelijke doei,"
         - "Doi,"
         - "Talla,"
       attendance_reminder:
-        subject: "Je bent automatisch aangemeld voor %{activity}"
-        havenot_responded: "Je hebt nog niet aangegeven of je bij %{activity} kunt zijn. Omdat we ervan uitgaan dat je er bent als je niks aangeeft, is je reactie automatisch op 'aanwezig' gezet."
-        if_cannot: "Als je toch niet aanwezig kunt zijn, kan je dit tot %{deadline} aangeven via de volgende link:"
+        subject_present: "Je bent automatisch aangemeld voor %{activity}"
+        subject_absent: "Je bent automatisch afgemeld voor %{activity}"
+        set_to_present: "Je hebt nog niet aangegeven of je bij %{activity} kunt zijn. De organisatoreen van deze activiteit gaan ervan uit dat je er wel bent als je niets aangeeft,  dus je reactie is op 'aanwezig' gezet."
+        set_to_absent: "Je hebt nog niet aangegeven of je bij %{activity} kan zijn. De organisatoren van deze activiteit gaan ervan uit dat je er niet bent als je niets aangeeft, dus je reactie is op 'afwezig' gezet."
+        if_cannot: "Als je dit nog wilt veranderen kan je dit tot %{deadline} aangeven via de volgende link:"
+
+      subgroup_notification:
+        subject: "Je bent ingedeeld in subgroep %{subgroup} voor %{activity}"
+        yoursubgroupis: "De aankomende opkomst %{activity} gebruikt subgroepen, en jij bent ingedeeld in subgroep %{subgroup}."
+        subgroupmembers: "De andere mensen in deze subgroep zijn: %{others}"
+        noothersinsubgroup: "Er zijn geen andere mensen in deze subgroep. :("
+        allsubgroups: "Alle groepjes (inclusief de jouwe) zijn:"
+        cannotdecline: "Deze email is verstuurd toen de deadline voor het afmelden verstreek. Als je om wat voor reden dan ook toch niet kan, neem dan contact op met de Drerrie (afmeld@maartenberg.nl) of een van de organisators van de opkomst (%{organizers})."
+
+    subgroups:
+      manage: 'Subgroepen aanpassen'
+      create: 'Subgroep aanmaken'
+      created: 'Subgroep aangemaakt.'
+      create_failed: 'Kon subgroep niet opslaan!'
+
+      edit: 'Subgroepindeling bewerken'
+      edited: 'Subgroepindeling bijgewerkt.'
+
+      update: 'Subgroep bijwerken'
+      updated: 'Subgroep bijgewerkt.'
+      update_failed: 'Kon subgroep niet bijwerken!'
+
+      destroy: 'Subgroep verwijderen'
+      destroyed: 'Subgroep verwijderd.'
+      none: 'Er zijn geen subgroepen.'
+
+      filter_nogroup: 'Aangemeld, geen groep'
+      filter_nofilter: 'Toon iedereen'
+
+      only_present_people: 'Je ziet alleen maar mensen die zijn aangemeld in dit overzicht, omdat mensen die zijn afgemeld niet in een subgroep kunnen zitten.'
+
+      clear: 'Subgroepen legen'
+      clear_explanation: 'Dit verwijdert iedereen in een indeelbare subgroep uit zijn subgroep! Weet je zeker dat je dit wilt?'
+      cleared: 'Subgroepen geleegd.'
+
+      redistribute: 'Subgroepen opnieuw indelen'
+      redistribute_explanation: 'Dit verwijdert iedereen in een indeelbare subgroep uit die subgroep, en deelt daarna iedereen willekeurig opnieuw in. Weet je zeker dat je dit wilt?'
+      redistributed: 'Subgroepen opnieuw ingedeeld.'
+
+      distribute_remaining: 'Overgebleven naar subgroepen'
+      distribute_remaining_explanation: 'Dit deelt iedereen die is aangemeld, maar nog niet in een subgroep zit, in in een willekeurige subgroep (volgens normale volgorde van kleinste groep eerst). Wil je dit?'
+      remaining_distributed: 'Overgebleven personen ingedeeld in subgroepen.'

config/locales/defaultsubgroups_en.yml

+en:
+  defaultsubgroups:
+    manage: 'Manage default subgroups'
+    settings_blurb: "The groups set here will be added automatically to each new activity that is created. Note that actually assigning participants to groups has to be enabled separately."
+
+    create: 'Add default subgroup'
+    created: 'Default subgroup added.'
+    create_failed: 'Could not create default subgroup!'
+
+    updated: 'Default subgroup updated.'
+    update_failed: 'Could not update default subgroup!'
+
+    destroy: 'Remove default subgroup'
+    destroyed: 'Default subgroup destroyed.'
+
+    none: 'There are no default subgroups.'

config/locales/defaultsubgroups_nl.yml

+nl:
+  defaultsubgroups:
+    manage: 'Standaard subgroepen aanpassen'
+    settings_blurb: "De groepen die hier staan aangegeven worden automatisch aangemaakt voor iedere nieuwe activiteit die wordt toegevoegd. Het daadwerkelijk indelen in deze groepen moet wel per activiteit worden ingeschakeld."
+
+    create: 'Standaardgroep toevoegen'
+    created: 'Standaardgroep toegevoegd.'
+    create_failed: 'Kon de standaardgroep niet opslaan!'
+
+    updated: 'Standaardgroep bijgewerkt.'
+    update_failed: 'Kon de standaardgroep niet bijwerken!'
+
+    destroy: 'Standaardgroep verwijderen'
+    destroyed: 'Standaardgroep verwijderd.'
+
+    none: 'Er zijn geen standaardgroepen.'

config/locales/groups/en.yml

     member_updated: "Member updated."
     member_removed: "%{name} was removed from the group."
 
+    mass_add_members: "Adding multiple members to %{group}"
+    mass_add_short: "Import members"
+    mass_add_explanation: "Download the example file using the link below, and fill in this file in the format shown. Upload the completed form using the form at the bottom of this page. Note that all data fields will be ignored if a user with the same email address exists. Date of birth is not required."
+    mass_add_success: "%{count} members added to group."
+
     member:
       add: "New Member"
       adding: "Add member to %{name}"

config/locales/groups/nl.yml

     member_updated: "Lid bijgewerkt."
     member_removed: "%{name} is verwijderd uit de groep."
 
+    mass_add_members: "Meerdere leden toevoegen aan %{group}"
+    mass_add_short: "Leden importeren"
+    mass_add_explanation: "Download het voorbeeldbestand via de link hieronder, vul de velden in in het formaat zoals aangegeven, en upload het ingevulde formulier via de knop onderaan. Merk op dat aangepaste velden worden genegeerd als al een gebruiker met hetzelfde e-mailadres bestaat. Geboortedatum is niet verplicht."
+    mass_add_success: "%{count} leden toegevoegd aan de groep."
+
     member:
       add: "Lid toevoegen"
       adding: "Lid toevoegen aan %{name}"

config/locales/translation_nl.yml

       token: Token  #g
       user: Gebruiker  #g
 
+      default_subgroup:
+        one: Standaardgroep
+        other: Standaardgroepen
+
+      subgroup:
+        one: Subgroep
+        other: Subgroepen
+
     attributes:
       activity:
         deadline: Deadline  #g
         start: Start  #g
         reminder_at: Herinnering om
         reminder_done: Herinnering verstuurd
+        subgroups: :activerecord.models.subgroup.other
+        subgroup_division_enabled: Subgroepen indelen
+        subgroup_division_done: Subgroepen ingedeeld
+        no_response_action: Actie bij geen reactie
 
       group:
         activities: Activiteiten  #g
+        default_subgroups: Standaardsubgroepen
         members: Leden  #g
         name: Naam  #g
         people: Mensen  #g
         email: E-mail  #g
         password_digest: Wachtwoord-digest  #g
         person: :activerecord.models.person  #g
+
+      default_subgroup:
+        name: Naam
+        is_assignable: Gebruiken voor indelen
+
+      subgroup:
+        name: Naam
+        is_assignable: Gebruiken voor indelen

config/routes.rb

     get 'mass_add', to: 'groups#mass_add_members'
     post 'mass_add', to: 'groups#process_mass_add_members'
 
+    post 'subgroups', to: 'groups#create_default_subgroup', as: 'create_default_subgroup'
+    patch 'subgroups/:default_subgroup_id', to: 'groups#update_default_subgroup', as: 'update_default_subgroup'
+    delete 'subgroups(/:default_subgroup_id)', to: 'groups#destroy_default_subgroup', as: 'destroy_default_subgroup'
+
     resources :members do
       post 'promote', to: 'members#promote', on: :member
       post 'demote', to: 'members#demote', on: :member
       post 'change_organizer', to: 'activities#change_organizer'
       put 'presence', to: 'activities#presence', on: :member
       patch 'presence', to: 'activities#presence', on: :member
+
+      post 'subgroups', to: 'activities#create_subgroup', as: 'create_subgroup'
+      patch 'subgroups/:subgroup_id', to: 'activities#update_subgroup', as: 'update_subgroup'
+      delete 'subgroups(/:subgroup_id)', to: 'activities#destroy_subgroup', as: 'destroy_subgroup'
+
+      get 'edit_subgroups', to: 'activities#edit_subgroups'
+      post 'update_subgroups', to: 'activities#update_subgroups'
+      post 'immediate_subgroups', to: 'activities#immediate_subgroups'
+      post 'clear_subgroups', to: 'activities#clear_subgroups'
     end
   end
   get 'my_groups', to: 'groups#user_groups', as: :user_groups

db/migrate/20170930201201_create_default_subgroups.rb

+class CreateDefaultSubgroups < ActiveRecord::Migration[5.0]
+  def change
+    create_table :default_subgroups do |t|
+      t.references :group, foreign_key: true
+      t.string :name, null: false
+      t.boolean :is_assignable
+
+      t.timestamps
+    end
+  end
+end

db/migrate/20171001124009_create_subgroups.rb

+class CreateSubgroups < ActiveRecord::Migration[5.0]
+  def change
+    create_table :subgroups do |t|
+      t.references :activity, foreign_key: true
+      t.string :name, null: false
+      t.boolean :is_assignable
+
+      t.timestamps
+    end
+  end
+end

db/migrate/20171001150124_add_subgroup_to_participants.rb

+class AddSubgroupToParticipants < ActiveRecord::Migration[5.0]
+  def change
+    add_reference :participants, :subgroup, foreign_key: true
+  end
+end

db/migrate/20171023080215_add_subgroup_job_markers_to_activities.rb

+class AddSubgroupJobMarkersToActivities < ActiveRecord::Migration[5.0]
+  def change
+    add_column :activities, :subgroup_division_enabled, :boolean
+    add_column :activities, :subgroup_division_done, :boolean
+  end
+end

db/migrate/20180206181016_add_no_response_action_to_activities.rb

+class AddNoResponseActionToActivities < ActiveRecord::Migration[5.0]
+  def change
+    add_column :activities, :no_response_action, :boolean, default: true
+  end
+end

db/schema.rb

 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20170917140643) do
+ActiveRecord::Schema.define(version: 20180206181016) do
 
   create_table "activities", force: :cascade do |t|
     t.string   "name"
     t.datetime "end"
     t.datetime "deadline"
     t.integer  "group_id"
-    t.datetime "created_at",    null: false
-    t.datetime "updated_at",    null: false
+    t.datetime "created_at",                               null: false
+    t.datetime "updated_at",                               null: false
     t.datetime "reminder_at"
     t.boolean  "reminder_done"
+    t.boolean  "subgroup_division_enabled"
+    t.boolean  "subgroup_division_done"
+    t.boolean  "no_response_action",        default: true
     t.index ["group_id"], name: "index_activities_on_group_id"
   end
 
+  create_table "default_subgroups", force: :cascade do |t|
+    t.integer  "group_id"
+    t.string   "name",          null: false
+    t.boolean  "is_assignable"
+    t.datetime "created_at",    null: false
+    t.datetime "updated_at",    null: false
+    t.index ["group_id"], name: "index_default_subgroups_on_group_id"
+  end
+
   create_table "delayed_jobs", force: :cascade do |t|
     t.integer  "priority",   default: 0, null: false
     t.integer  "attempts",   default: 0, null: false
     t.text     "notes"
     t.datetime "created_at",   null: false
     t.datetime "updated_at",   null: false
+    t.integer  "subgroup_id"
     t.index ["activity_id"], name: "index_participants_on_activity_id"
     t.index ["person_id", "activity_id"], name: "index_participants_on_person_id_and_activity_id", unique: true
     t.index ["person_id"], name: "index_participants_on_person_id"
+    t.index ["subgroup_id"], name: "index_participants_on_subgroup_id"
   end
 
   create_table "people", force: :cascade do |t|
     t.index ["user_id"], name: "index_sessions_on_user_id"
   end
 
+  create_table "subgroups", force: :cascade do |t|
+    t.integer  "activity_id"
+    t.string   "name",          null: false
+    t.boolean  "is_assignable"
+    t.datetime "created_at",    null: false
+    t.datetime "updated_at",    null: false
+    t.index ["activity_id"], name: "index_subgroups_on_activity_id"
+  end
+
   create_table "tokens", force: :cascade do |t|
     t.string   "token"
     t.datetime "expires"

db/seeds.rb

   email: 'maarten@maartenberg.nl',
   person: p,
   password: 'aardbei123',
-  password_confirmation: 'aardbei123'
+  password_confirmation: 'aardbei123',
+  confirmed: true
 )
 
 p2 = Person.create!(
       start: starttime,
       end: endtime,
       deadline: deadline,
-      group: g
+      group: g,
+      no_response_action: Faker::Boolean.boolean
     )
   end
 end

public/batch_activities.csv

-name,description,location,start_date,start_time,end_date,end_time,deadline_date,deadline_time
-Name,Description,Location,2017-12-31,12:34:00,2017-12-31,12:43:00,2017-12-28,13:37:00
+name,description,location,start_date,start_time,end_date,end_time,deadline_date,deadline_time,reminder_at_date,reminder_at_time,subgroup_division_enabled,no_response_action
+Name,Description,Where,2017-12-31,12:34,2017-12-31,12:43,2017-12-28,13:37,2017-12-27,23:59,Y(es)/N(o),P(resent)/A(bsent)

public/batch_persons.csv

-first_name,infix,last_name,birth_date,email,organizers
+first_name,infix,last_name,birth_date,email
+Gekke,,Henkie,1-1-1997,gekkehenkie@maartenberg.nl