ECSE 321 Introduction to Software Engineering: Hands-on Tutorials

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;
	}

}

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

	runtimeOnly 'org.postgresql:postgresql'
	testImplementation('org.springframework.boot:spring-boot-starter-test') {
		exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
	}
}

// REST endpoint specification
@RepositoryRestResource(collectionResourceRel = "person_data", path = "person_data")
public interface PersonRepository extends CrudRepository<Person, String>{

	Person findPersonByName(String name);

}

testImplementation 'org.mockito:mockito-core:2.+'
testImplementation 'org.mockito:mockito-junit-jupiter:2.18.3'

testRuntime 'org.junit.jupiter:junit-jupiter-engine:5.3.1'

testImplementation 'org.junit.platform:junit-platform-launcher:1.4.1'

package ca.mcgill.ecse321.eventregistration.service;

import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.junit.jupiter.MockitoExtension;


@ExtendWith(MockitoExtension.class)
public class TestEventRegistrationService {

}

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.when;

import java.sql.Date;
import java.sql.Time;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.stubbing.Answer;

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;

@Mock
private PersonRepository personDao;

@InjectMocks
private EventRegistrationService service;

private static final String PERSON_KEY = "TestPerson";

@BeforeEach
public void setMockOutput() {
    lenient().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;
        }
    });
}

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

@Transactional
public Person getPerson(String name) {
    if (name == null || name.trim().length() == 0) {
        throw new IllegalArgumentException("Person name cannot be empty!");
    }
    Person person = personRepository.findPersonByName(name);
    return person;
}

@Transactional
public Event getEvent(String name) {
    if (name == null || name.trim().length() == 0) {
        throw new IllegalArgumentException("Event name cannot be empty!");
    }
    Event event = eventRepository.findEventByName(name);
    return event;
}

@Transactional
public Event createEvent(String name, Date date, Time startTime, Time endTime) {
    // Input validation
    String error = "";
    if (name == null || name.trim().length() == 0) {
        error = error + "Event name cannot be empty! ";
    }
    if (date == null) {
        error = error + "Event date cannot be empty! ";
    }
    if (startTime == null) {
        error = error + "Event start time cannot be empty! ";
    }
    if (endTime == null) {
        error = error + "Event end time cannot be empty! ";
    }
    if (endTime != null && startTime != null && endTime.before(startTime)) {
        error = error + "Event end time cannot be before event start time!";
    }
    error = error.trim();
    if (error.length() > 0) {
        throw new IllegalArgumentException(error);
    }

    Event event = new Event();
    event.setName(name);
    event.setDate(date);
    event.setStartTime(startTime);
    event.setEndTime(endTime);
    eventRepository.save(event);
    return event;
}

@Transactional
public Registration register(Person person, Event event) {
    String error = "";
    if (person == null) {
        error = error + "Person needs to be selected for registration! ";
    } else if (!personRepository.existsById(person.getName())) {
        error = error + "Person does not exist! ";
    }
    if (event == null) {
        error = error + "Event needs to be selected for registration!";
    } else if (!eventRepository.existsById(event.getName())) {
        error = error + "Event does not exist!";
    }
    if (registrationRepository.existsByPersonAndEvent(person, event)) {
        error = error + "Person is already registered to this event!";
    }
    error = error.trim();

    if (error.length() > 0) {
        throw new IllegalArgumentException(error);
    }

    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<Event> getEventsAttendedByPerson(Person person) {
    if (person == null ) {
        throw new IllegalArgumentException("Person cannot be null!");
    }
    List<Event> eventsAttendedByPerson = new ArrayList<>();
    for (Registration r : registrationRepository.findByPerson(person)) {
        eventsAttendedByPerson.add(r.getEvent());
    }
    return eventsAttendedByPerson;
}

$ curl -s -X POST http://localhost:8080/persons/testperson1
{"name":"testperson1","events":[]}
$ curl -s -X POST http://localhost:8080/persons/testperson2
{"name":"testperson2","events":[]}
$ curl -s -X http://localhost:8080/persons
[{"name":"testperson1","events":[]},{"name":"testperson2","events":[]}]

$ curl -s -X GET  http://localhost:8080/persons | grep -o testperson1
testperson1

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

mv eventregistration-frontend/ EventRegistration-Frontent

$ 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
  });
}