ECSE 321 Introduction to Software Engineering: Hands-on Tutorials

computation
├── build.gradle
└── src
    ├── main
    │   └── java
    │       ├── application
    │       │   └── CompApp.java
    │       ├── computation
    │       │   └── Computation.java
    │       └── view
    │           └── ComputationPage.java
    └── test
        └── java
            └── computation
                ├── AllTests.java
                ├── ComputationTestAddSubstract.java
                └── ComputationTestDivideMultiply.java

apply plugin: 'java'
// This plugin has a predefined 'run' task that we can reuse to use Gradle to execute our application
apply plugin: 'application'

repositories {
    mavenCentral()
}
dependencies {
    testImplementation "junit:junit:4.12"
}

task compile(type: JavaCompile) {
  classpath = sourceSets.main.compileClasspath
  classpath += sourceSets.test.runtimeClasspath
  sourceSets.test.java.outputDir = file('build/bin')
  sourceSets.main.java.outputDir = file('build/bin')
}

/*
 * specifying sourceSets is not necessary in this case, since
 * we are applying the default folder structure assumed by Gradle
 */
sourceSets {
  main {
    java { srcDir 'src/main/java' }
  }
  test {
    java { srcDir 'src/test/java'}
  }
}

mainClassName='application.CompApp'

jar {
  destinationDir=file('distributable')
  manifest {
    // It is smart to reuse the name of the main class variable instead of hardcoding it
    attributes "Main-Class": "$mainClassName"
  }
}

heroku buildpacks:add -a eventregistration-backend-<UNIQUE_ID> https://github.com/heroku/heroku-buildpack-multi-procfile
heroku buildpacks:add -a eventregistration-backend-<UNIQUE_ID> heroku/gradle

task stage () {
    dependsOn ':EventRegistration-Backend:assemble'
}

include ':EventRegistration-Backend'

gradle wrapper --gradle-version 5.6.2

.gradle/

git add .
git status #make sure that files in .gradle/ are not added

On branch master
Your branch is ahead of 'origin/master' by 2 commits.
  (use "git push" to publish your local commits)

Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

	new file:   .gitignore
	new file:   build.gradle
	new file:   gradle/wrapper/gradle-wrapper.jar
	new file:   gradle/wrapper/gradle-wrapper.properties
	new file:   gradlew
	new file:   gradlew.bat
	new file:   settings.gradle

git commit -m "Adding Gradle wrapper"

web: java -jar EventRegistration-Backend/build/libs/EventRegistration-Backend-0.0.1-SNAPSHOT.jar

heroku config:add PROCFILE=EventRegistration-Backend/Procfile --app eventregistration-backend-<UNIQUE_ID>

heroku git:remote --app eventregistration-backend-<UNIQUE_ID> --remote backend-heroku

set git remote backend-heroku to https://git.heroku.com/eventregistration-backend-<UNIQUE_ID>.git

backend-heroku	https://git.heroku.com/eventregistration-backend-123.git (fetch)
backend-heroku	https://git.heroku.com/eventregistration-backend-123.git (push)
origin	git@github.com:imbur/eventregistration.git (fetch)
origin	git@github.com:imbur/eventregistration.git (push)

git push backend-heroku master

[...]
***************************
APPLICATION FAILED TO START
***************************

Description:

Failed to configure a DataSource: 'url' attribute is not specified and no embedded datasource could be configured.

Reason: Failed to determine a suitable driver class
[...]

package ca.mcgill.ecse321.eventregistration;

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.SpringApplication;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
@SpringBootApplication
public class EventRegistrationApplication {

	public static void main(String[] args) {
		SpringApplication.run(EventRegistrationApplication.class, args);
	}

	@RequestMapping("/")
	public String greeting() {
		return "Hello world!";
	}
}

package ca.mcgill.ecse321.eventregistration.dao;

import java.sql.Date;
import java.sql.Time;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import ca.mcgill.ecse321.eventregistration.model.Person;
import ca.mcgill.ecse321.eventregistration.model.Event;

@Repository
public class EventRegistrationRepository {

	@Autowired
	EntityManager entityManager;

	@Transactional
	public Person createPerson(String name) {
		Person p = new Person();
		p.setName(name);
		entityManager.persist(p);
		return p;
	}

	@Transactional
	public Person getPerson(String name) {
		Person p = entityManager.find(Person.class, name);
		return p;
	}

	@Transactional
	public Event createEvent(String name, Date date, Time startTime, Time endTime) {
		Event e = new Event();
		e.setName(name);
		e.setDate(date);
		e.setStartTime(startTime);
		e.setEndTime(endTime);
		entityManager.persist(e);
		return e;
	}

	@Transactional
	public Event getEvent(String name) {
		Event e = entityManager.find(Event.class, name);
		return e;
	}

}

@Transactional
public List<Event> getEventsBeforeADeadline(Date deadline) {
	TypedQuery<Event> q = entityManager.createQuery("select e from Event e where e.date < :deadline",Event.class);
	q.setParameter("deadline", deadline);
	List<Event> resultList = q.getResultList();
	return resultList;
}

jdbc:postgresql://<HOST>:<PORT>/<DATABASE_NAME>?user=<USERNAME>&password=<PASSWORD>&sslmode=require

$> psql postgresql://ec2-54-243-223-245.compute-1.amazonaws.com:5432/d4412g60aaboa7?user=hdjnflfirvkmmr
Password:
psql (10.6 (Ubuntu 10.6-0ubuntu0.18.04.1))
SSL connection (protocol: TLSv1.2, cipher: ECDHE-RSA-AES256-GCM-SHA384, bits: 256, compression: off)
Type "help" for help.

d4412g60aaboa7=> \dt
                          List of relations
 Schema |                Name                | Type  |     Owner
--------+------------------------------------+-------+----------------
 public | event                              | table | hdjnflfirvkmmr
 public | person                             | table | hdjnflfirvkmmr
 public | registration                       | table | hdjnflfirvkmmr
 public | registration_manager               | table | hdjnflfirvkmmr
 public | registration_manager_events        | table | hdjnflfirvkmmr
 public | registration_manager_persons       | table | hdjnflfirvkmmr
 public | registration_manager_registrations | table | hdjnflfirvkmmr
(7 rows)

d4412g60aaboa7=> select * from event ;
 name |    date    | end_time | start_time
------+------------+----------+------------
 e1   | 3899-10-09 | 12:00:00 | 10:00:00
(1 row)

d4412g60aaboa7=> \q
$>

package ca.mcgill.ecse321.eventregistration.dao;

import org.springframework.data.repository.CrudRepository;

import ca.mcgill.ecse321.eventregistration.model.Person;

public interface PersonRepository extends CrudRepository<Person, String>{

	Person findPersonByName(String name);

}

package ca.mcgill.ecse321.eventregistration.dao;

import org.springframework.data.repository.CrudRepository;

import ca.mcgill.ecse321.eventregistration.model.Event;

public interface EventRepository extends CrudRepository<Event, String> {

	Event findEventByName(String name);

}

package ca.mcgill.ecse321.eventregistration.dao;

import java.util.List;

import org.springframework.data.repository.CrudRepository;

import ca.mcgill.ecse321.eventregistration.model.Event;
import ca.mcgill.ecse321.eventregistration.model.Person;
import ca.mcgill.ecse321.eventregistration.model.Registration;

public interface RegistrationRepository extends CrudRepository<Registration, Integer> {

	List<Registration> findByPerson(Person personName);

	boolean existsByPersonAndEvent(Person person, Event eventName);

	Registration findByPersonAndEvent(Person person, Event eventName);

}

package ca.mcgill.ecse321.eventregistration.service;

import java.sql.Date;
import java.sql.Time;
import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import ca.mcgill.ecse321.eventregistration.dao.EventRepository;
import ca.mcgill.ecse321.eventregistration.dao.PersonRepository;
import ca.mcgill.ecse321.eventregistration.dao.RegistrationRepository;
import ca.mcgill.ecse321.eventregistration.model.Event;
import ca.mcgill.ecse321.eventregistration.model.Person;
import ca.mcgill.ecse321.eventregistration.model.Registration;

@Service
public class EventRegistrationService {

	@Autowired
	EventRepository eventRepository;
	@Autowired
	PersonRepository personRepository;
	@Autowired
	RegistrationRepository registrationRepository;

	@Transactional
	public Person createPerson(String name) {
		Person person = new Person();
		person.setName(name);
		personRepository.save(person);
		return person;
	}

	@Transactional
	public Person getPerson(String name) {
		Person person = personRepository.findPersonByName(name);
		return person;
	}

	@Transactional
	public List<Person> getAllPersons() {
		return toList(personRepository.findAll());
	}

	@Transactional
	public Event createEvent(String name, Date date, Time startTime, Time endTime) {
		Event event = new Event();
		event.setName(name);
		event.setDate(date);
		event.setStartTime(startTime);
		event.setEndTime(endTime);
		eventRepository.save(event);
		return event;
	}

	@Transactional
	public Event getEvent(String name) {
		Event event = eventRepository.findEventByName(name);
		return event;
	}

	@Transactional
	public List<Event> getAllEvents() {
		return toList(eventRepository.findAll());
	}

	@Transactional
	public Registration register(Person person, Event event) {
		Registration registration = new Registration();
		registration.setId(person.getName().hashCode() * event.getName().hashCode());
		registration.setPerson(person);
		registration.setEvent(event);

		registrationRepository.save(registration);

		return registration;
	}

	@Transactional
	public List<Registration> getAllRegistrations(){
		return toList(registrationRepository.findAll());
	}

	@Transactional
	public List<Event> getEventsAttendedByPerson(Person person) {
		List<Event> eventsAttendedByPerson = new ArrayList<>();
		for (Registration r : registrationRepository.findByPerson(person)) {
			eventsAttendedByPerson.add(r.getEvent());
		}
		return eventsAttendedByPerson;
	}

	private <T> List<T> toList(Iterable<T> iterable){
		List<T> resultList = new ArrayList<T>();
		for (T t : iterable) {
			resultList.add(t);
		}
		return resultList;
	}

}

implementation 'org.springframework.boot:spring-boot-starter-data-rest'
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
implementation 'org.springframework.boot:spring-boot-starter-web'

runtimeOnly 'org.postgresql:postgresql'
testImplementation 'org.springframework.boot:spring-boot-starter-test'

@RepositoryRestResource(collectionResourceRel = "participants", path = "participants")
public interface PersonRepository extends CrudRepository<Person, String>{

	Person findPersonByName(String name);

}

dependencies {
  // Add these lines to the dependency configuration, don't replace the existing dependencies
  	testImplementation "junit:junit:4.12"
  	testRuntime('org.junit.jupiter:junit-jupiter-engine:5.3.1')
    testImplementation('org.mockito:mockito-core:2.+')
  	testImplementation('org.mockito:mockito-junit-jupiter:2.18.3')
}

testImplementation group: 'org.junit.platform', name: 'junit-platform-launcher', version: "1.3.1"

package ca.mcgill.ecse321.eventregistration;

@RunWith(MockitoJUnitRunner.class)
public class EventregistrationServiceTests {

}

@Transactional
public Person createPerson(String name) {
  if (name == null || name == "") {
    throw new IllegalArgumentException("Person name cannot be empty!");
  }
  Person person = personRepository.findPersonByName(name);
  if ( person == null ) {
    person = new Person();
    person.setName(name);
    personRepositroy.save(person);
  }
  return person;
}

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.springframework.boot.test.context.SpringBootTest;
import ca.mcgill.ecse321.eventregistration.dao.EventRepository;
import ca.mcgill.ecse321.eventregistration.dao.PersonRepository;
import ca.mcgill.ecse321.eventregistration.dao.RegistrationRepository;
import ca.mcgill.ecse321.eventregistration.service.EventRegistrationService;
import org.mockito.invocation.InvocationOnMock;
import org.springframework.test.context.junit4.SpringRunner;
import ca.mcgill.ecse321.eventregistration.controller.EventRegistrationRestController;
import ca.mcgill.ecse321.eventregistration.model.Person;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

@Mock
private PersonRepository personDao;

@InjectMocks
private EventRegistrationService service;

private static final String PERSON_KEY = "TestPerson";
private static final String NONEXISTING_KEY = "NotAPerson";

@Before
public void setMockOutput() {
	when(personDao.findPersonByName(anyString())).thenAnswer( (InvocationOnMock invocation) -> {
		if(invocation.getArgument(0).equals(PERSON_KEY)) {
			Person person = new Person();
			person.setName(PERSON_KEY);
			return person;
		} else {
			return null;
		}
	});
}

@Test
public void testCreatePerson() {
	assertEquals(0, service.getAllPersons().size());

	String name = "Oscar";

	try {
		person = service.createPerson(name);
	} catch (IllegalArgumentException e) {
		// Check that no error occurred
		fail();
	}

	assertEquals(name, person.getName());
}

@Test
public void testCreatePersonNull() {
	String name = null;
	String error = null;

	try {
		person = service.createPerson(name);
	} catch (IllegalArgumentException e) {
		error = e.getMessage();
	}

	// check error
	assertEquals("Person name cannot be empty!", error);
}

package ca.mcgill.ecse321.tutorial7;

public class Library {

	public static double returnAverage(int value[], int arraySize, int MIN, int MAX) {
		int index, ti, tv, sum;
		double average;
		index = 0;
		ti = 0;
		tv = 0;
		sum = 0;
		while (ti < arraySize && value[index] != -999) {
			ti++;
			if (value[index] >= MIN && value[index] <= MAX) {
				tv++;
				sum += value[index];
			}
			index++;
		}
		if (tv > 0)
			average = (double) sum / tv;
		else
			average = (double) -999;
		return average;
	}
}

package ca.mcgill.ecse321.tutorial7;

import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class LibraryTest {

	@Test
	public void allBranchCoverageMinimumTestCaseForReturnAverageTest1() {
		int[] value = {5, 25, 15, -999};
		int AS = 4;
		int min = 10;
		int max = 20;
		double average = Library.returnAverage(value, AS, min, max);
		assertEquals(15, average, 0.1);
	}

	@Test
	public void allBranchCoverageMinimumTestCaseForReturnAverageTest2() {
		int[] value = {};
		int AS = 0;
		int min = 10;
		int max = 20;
		double average = Library.returnAverage(value, AS, min, max);
		assertEquals(-999.0, average, 0.1);
	}
}

$ node -v
v8.10.0
$ npm -v
3.5.2

$ cd ~/git/eventregistration

$ cd EventRegistration-Frontend
$ npm install
$ npm run dev

<template>
</template>
<script>
</script>
<style>
</style>

<template>
  <div id="eventregistration">
    <h2>People</h2>
    <table>
      <tr>
          <td>John</td>
          <td>Event to attend</td>
      </tr>
      <tr>
          <td>
              <input type="text" placeholder="Person Name">
          </td>
          <td>
              <button>Create</button>
          </td>
      </tr>
    </table>
    <p>
      <span style="color:red">Error: Message text comes here</span>
    </p>
  </div>
</template>

<style>
  #eventregistration {
    font-family: 'Avenir', Helvetica, Arial, sans-serif;
    color: #2c3e50;
    background: #f2ece8;
  }
</style>

export default new Router({
  routes: [
    {
      path: '/',
      name: 'Hello',
      component: Hello
    },
    {
      path: '/app',
      name: 'EventRegistration',
      component: EventRegistration
    }
  ]
})

function PersonDto (name) {
  this.name = name
  this.events = []
}

function EventDto (name, date, start, end) {
  this.name = name
  this.eventDate = date
  this.startTime = start
  this.endTime = end
}

export default {
  name: 'eventregistration',
  data () {
    return {
      people: [],
      newPerson: '',
      errorPerson: '',
      response: []
    }
  },
  //...
}

created: function () {
  // Test data
  const p1 = new PersonDto('John')
  const p2 = new PersonDto('Jill')
  // Sample initial content
  this.people = [p1, p2]
},

methods: {
  createPerson: function (personName) {
    // Create a new person and add it to the list of people
    var p = new PersonDto(personName)
    this.people.push(p)
    // Reset the name field for new people
    this.newPerson = ''
  }
}

<script src="./registration.js">
</script>

<table>
  <!-- ... -->
  <tr>
    <td>
        <input type="text" v-model="newPerson" placeholder="Person Name">
    </td>
    <td>
        <button @click="createPerson(newPerson)">Create Person</button>
    </td>
  </tr>
</table>

created: function () {
  // Initializing people from backend
    AXIOS.get(`/persons`)
    .then(response => {
      // JSON responses are automatically parsed.
      this.people = response.data
    })
    .catch(e => {
      this.errorPerson = e;
    });
}

createPerson: function (personName) {
  AXIOS.post(`/persons/`+personName, {}, {})
  .then(response => {
    // JSON responses are automatically parsed.
    this.people.push(response.data)
    this.newPerson = ''
    this.errorPerson = ''
  })
  .catch(e => {
    var errorMsg = e.message
    console.log(errorMsg)
    this.errorPerson = errorMsg
  });
}

public class DatePickerFragment extends DialogFragment
        implements DatePickerDialog.OnDateSetListener {

    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        // Use the current date as the default date in the picker
        final Calendar c = Calendar.getInstance();
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH);
        int day = c.get(Calendar.DAY_OF_MONTH);

        // Parse the existing time from the arguments
        Bundle args = getArguments();
        if (args != null) {
            year = args.getInt("year");
            month = args.getInt("month");
            day = args.getInt("day");
        }

        // Create a new instance of DatePickerDialog and return it
        return new DatePickerDialog(getActivity(), this, year, month, day);
    }

    public void onDateSet(DatePicker view, int year, int month, int day) {
        MainActivity myActivity = (MainActivity)getActivity();
        myActivity.setDate(getArguments().getInt("id"), day, month, year);
    }
}

public class TimePickerFragment extends DialogFragment
        implements TimePickerDialog.OnTimeSetListener {

    String label;

    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        int hour = 0;
        int minute = 0;

        // Parse the existing time from the arguments
        Bundle args = getArguments();
        if (args != null) {
            hour = args.getInt("hour");
            minute = args.getInt("minute");
        }

        // Create a new instance of TimePickerDialog and return it
        return new TimePickerDialog(getActivity(), this, hour, minute,
                DateFormat.is24HourFormat(getActivity()));
    }

    public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
        MainActivity myActivity = (MainActivity)getActivity();
        myActivity.setTime(getArguments().getInt("id"), hourOfDay, minute);
    }
}

private Bundle getTimeFromLabel(String text) {
    Bundle rtn = new Bundle();
    String comps[] = text.toString().split(":");
    int hour = 12;
    int minute = 0;

    if (comps.length == 2) {
        hour = Integer.parseInt(comps[0]);
        minute = Integer.parseInt(comps[1]);
    }

    rtn.putInt("hour", hour);
    rtn.putInt("minute", minute);

    return rtn;
}

private Bundle getDateFromLabel(String text) {
    Bundle rtn = new Bundle();
    String comps[] = text.toString().split("-");
    int day = 1;
    int month = 1;
    int year = 1;

    if (comps.length == 3) {
        day = Integer.parseInt(comps[0]);
        month = Integer.parseInt(comps[1]);
        year = Integer.parseInt(comps[2]);
    }

    rtn.putInt("day", day);
    rtn.putInt("month", month-1);
    rtn.putInt("year", year);

    return rtn;
}

public void showTimePickerDialog(View v) {
    TextView tf = (TextView) v;
    Bundle args = getTimeFromLabel(tf.getText().toString());
    args.putInt("id", v.getId());

    TimePickerFragment newFragment = new TimePickerFragment();
    newFragment.setArguments(args);
    newFragment.show(getSupportFragmentManager(), "timePicker");
}

public void showDatePickerDialog(View v) {
    TextView tf = (TextView) v;
    Bundle args = getDateFromLabel(tf.getText().toString());
    args.putInt("id", v.getId());

    DatePickerFragment newFragment = new DatePickerFragment();
    newFragment.setArguments(args);
    newFragment.show(getSupportFragmentManager(), "datePicker");
}

public void setTime(int id, int h, int m) {
    TextView tv = (TextView) findViewById(id);
    tv.setText(String.format("%02d:%02d", h, m));
}

public void setDate(int id, int d, int m, int y) {
    TextView tv = (TextView) findViewById(id);
    tv.setText(String.format("%02d-%02d-%04d", d, m + 1, y));
}

<LinearLayout
    android:layout_height="wrap_content"
    android:layout_width="match_parent"
    android:orientation="vertical">
    <TextView
        android:id="@+id/error"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        android:visibility="gone"
        android:text=""
        android:textColor="@color/colorAccent"/>

    <LinearLayout
        android:layout_height="wrap_content"
        android:layout_width="match_parent"
        android:orientation="vertical">
        <LinearLayout
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:orientation="vertical">
            <LinearLayout
                android:orientation="horizontal"
                android:layout_height="wrap_content"
                android:layout_width="match_parent">
                <TextView
                    android:layout_height="wrap_content"
                    android:layout_width="wrap_content"
                    android:text="@string/personspinner_label"/>
                <Spinner
                    android:layout_height="wrap_content"
                    android:layout_width="wrap_content"
                    android:layout_gravity="end"
                    android:id="@+id/personspinner"/>
            </LinearLayout>
            <LinearLayout
                android:orientation="horizontal"
                android:layout_height="wrap_content"
                android:layout_width="match_parent">
                <TextView
                    android:layout_height="wrap_content"
                    android:layout_width="wrap_content"
                    android:text="@string/eventspinner_label"/>
                <Spinner
                    android:id="@+id/eventspinner"
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:layout_gravity="end"
                    android:layout_margin="0dp"/>
            </LinearLayout>
        </LinearLayout>
        <!-- TODO add a Register and Refresh Lists buttons here -->
    </LinearLayout>

    <View
        android:layout_height="2dp"
        android:layout_width="fill_parent"
        android:background="#16552e"/>

    <LinearLayout
        android:orientation="vertical"
        android:layout_height="wrap_content"
        android:layout_width="match_parent">
        <EditText
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:id="@+id/newperson_name"
            android:hint="@string/newperson_hint"/>
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="end"
            android:text="@string/newperson_button"
            android:onClick="addPerson"/>
    </LinearLayout>

    <View
        android:layout_height="2dp"
        android:layout_width="fill_parent"
        android:background="#16552e"/>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical">
        <EditText android:id="@+id/newevent_name"
            android:layout_height="wrap_content"
            android:layout_width="fill_parent"
            android:hint="@string/newevent_hint"/>
        <LinearLayout
            android:orientation="horizontal"
            android:layout_height="wrap_content"
            android:layout_width="match_parent">
            <TextView
                android:layout_height="wrap_content"
                android:layout_width="0dp"
                android:layout_weight="1"
                android:text="@string/newevent_date_label"/>
            <TextView
                android:layout_height="wrap_content"
                android:layout_width="wrap_content"
                android:text="@string/newevent_date_first"
                android:layout_gravity="end"
                android:id="@+id/newevent_date"
                android:onClick="showDatePickerDialog"/>
        </LinearLayout>
        <LinearLayout
            android:orientation="horizontal"
            android:layout_height="wrap_content"
            android:layout_width="match_parent">
            <TextView
                android:layout_height="wrap_content"
                android:layout_width="0dp"
                android:layout_weight="1"
                android:text="@string/starttime_label"/>
            <TextView
                android:layout_height="wrap_content"
                android:layout_width="wrap_content"
                android:text="@string/starttime_first"
                android:layout_gravity="end"
                android:id="@+id/starttime"
                android:onClick="showTimePickerDialog"/>
        </LinearLayout>
        <!-- TODO add a label and a time picker for event end time -->
        <!-- TODO add Add Event button here -->
    </LinearLayout>
</LinearLayout>

<resources>
    <string name="app_name">EventRegistration-Android</string>
    <string name="action_settings">Settings</string>
    <string name="newperson_hint">Who?</string>
    <string name="newperson_button">Add Person</string>
    <string name="newevent_date_label">Date?</string>
    <string name="personspinner_label">Person?</string>
    <string name="eventspinner_label">Event?</string>
    <string name="starttime_label">Start time?</string>
    <string name="newevent_date_first">01-07-2019</string>
    <string name="starttime_first">10:00</string>
    <string name="newevent_hint">Event Name?</string>
</resources>

public class MainActivity extends AppCompatActivity {
  private String error = null;
  // APPEND NEW CONTENT STARTING FROM HERE
  private List<String> personNames = new ArrayList<>();
  private ArrayAdapter<String> personAdapter;
  private List<String> eventNames = new ArrayList<>();
  private ArrayAdapter<String> eventAdapter;

  //...
}

@Override
protected void onCreate(Bundle savedInstanceState) {
  // ...
  // INSERT TO END OF THE METHOD
  // Add adapters to spinner lists and refresh spinner content
  Spinner personSpinner = (Spinner) findViewById(R.id.personspinner);
  Spinner eventSpinner = (Spinner) findViewById(R.id.eventspinner);

  personAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_spinner_item, personNames);
  personAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
  personSpinner.setAdapter(personAdapter);

  eventAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_spinner_item, eventNames);
  eventAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
  eventSpinner.setAdapter(eventAdapter);

  // Get initial content for spinners
  refreshLists(this.getCurrentFocus());
}

public void refreshLists(View view) {
    refreshList(personAdapter ,personNames, "people");
    refreshList(eventAdapter, eventNames, "events");
}

private void refreshList(final ArrayAdapter<String> adapter, final List<String> names, final String restFunctionName) {
    HttpUtils.get(restFunctionName, new RequestParams(), new JsonHttpResponseHandler() {

        @Override
        public void onSuccess(int statusCode, Header[] headers, JSONArray response) {
            names.clear();
            names.add("Please select...");
            for( int i = 0; i < response.length(); i++){
                try {
                    names.add(response.getJSONObject(i).getString("name"));
                } catch (Exception e) {
                    error += e.getMessage();
                }
                refreshErrorMessage();
            }
            adapter.notifyDataSetChanged();
        }

        @Override
        public void onFailure(int statusCode, Header[] headers, Throwable throwable, JSONObject errorResponse) {
            try {
                error += errorResponse.get("message").toString();
            } catch (JSONException e) {
                error += e.getMessage();
            }
            refreshErrorMessage();
        }
    });
}

public void addEvent(View v) {
    // start time
    TextView tv = (TextView) findViewById(R.id.starttime);
    String text = tv.getText().toString();
    String comps[] = text.split(":");

    int startHours = Integer.parseInt(comps[0]);
    int startMinutes = Integer.parseInt(comps[1]);

    // TODO get end time

    // date
    tv = (TextView) findViewById(R.id.newevent_date);
    text = tv.getText().toString();
    comps = text.split("-");

    int year = Integer.parseInt(comps[2]);
    int month = Integer.parseInt(comps[1]);
    int day = Integer.parseInt(comps[0]);

    // name
    tv = (TextView) findViewById(R.id.newevent_name);
    String name = tv.getText().toString();

    // Reminder: calling the service looks like this:
    // https://eventregistration-backend-123.herokuapp.com/events/testEvent?date=2013-10-23&startTime=00:00&endTime=23:59

    RequestParams rp = new RequestParams();

    NumberFormat formatter = new DecimalFormat("00");
    rp.add("date", year + "-" + formatter.format(month) + "-" + formatter.format(day));
    rp.add("startTime", formatter.format(startHours) + ":" + formatter.format(startMinutes));
    // TODO add end time as parameter

    HttpUtils.post("events/" + name, rp, new JsonHttpResponseHandler() {
        @Override
        public void onSuccess(int statusCode, Header[] headers, JSONObject response) {
            refreshErrorMessage();
            ((TextView) findViewById(R.id.newevent_name)).setText("");
        }

        @Override
        public void onFailure(int statusCode, Header[] headers, Throwable throwable, JSONObject errorResponse) {
            try {
                error += errorResponse.get("message").toString();
            } catch (JSONException e) {
                error += e.getMessage();
            }
            refreshErrorMessage();
        }
    });
}

public void register(View v) {

    Spinner partSpinner = (Spinner) findViewById(R.id.personspinner);
    Spinner eventSpinner = (Spinner) findViewById(R.id.eventspinner);

    error = "";

    // TODO issue an HTTP POST here
    // Reminder: calling the service looks like this:
    // https://eventregistration-backend-123.herokuapp.com/register?person=testPreson&event=testEvent


    // Set back the spinners to the initial state after posting the request
    partSpinner.setSelection(0);
    eventSpinner.setSelection(0);

    refreshErrorMessage();
}