+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+
+
+ 
+
+
+
+
\ No newline at end of file
diff --git a/src/app/app.component.scss b/src/app/app.component.scss
new file mode 100644
index 0000000..a25539c
--- /dev/null
+++ b/src/app/app.component.scss
@@ -0,0 +1,27 @@
+:host {
+ display: flex;
+ flex-direction: column;
+ min-height: 100vh;
+}
+
+.content {
+ flex: 1 0 auto;
+}
+
+.footer {
+ margin-top: auto;
+ padding: 1.3rem;
+ flex-shrink: 0;
+ background-color: #808285;
+ color: #fff;
+ font-size: 14px;
+ line-height: 21px;
+ font-weight: normal;
+ display: flex;
+ justify-content: space-between;
+
+ a, a:active, a:hover, a:visited, a:link {
+ color: #fff;
+ border-bottom-color: #fff;
+ }
+}
diff --git a/src/app/app.component.spec.ts b/src/app/app.component.spec.ts
new file mode 100644
index 0000000..8105902
--- /dev/null
+++ b/src/app/app.component.spec.ts
@@ -0,0 +1,32 @@
+import { TestBed, async } from '@angular/core/testing';
+import { RouterTestingModule } from '@angular/router/testing';
+import { AppComponent } from './app.component';
+import { HeaderComponent } from './components/header/header.component';
+import { ConfigurationService } from './services/configuration.service';
+
+describe('AppComponent', () => {
+ beforeEach(async(() => {
+ const configurationServiceSpy: jasmine.SpyObj
+
+
diff --git a/src/app/components/error/error.component.scss b/src/app/components/error/error.component.scss
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/components/error/error.component.spec.ts b/src/app/components/error/error.component.spec.ts
new file mode 100644
index 0000000..4915f94
--- /dev/null
+++ b/src/app/components/error/error.component.spec.ts
@@ -0,0 +1,27 @@
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { ErrorComponent } from './error.component';
+import { HttpClientModule } from '@angular/common/http';
+
+describe('ErrorComponent', () => {
+ let component: ErrorComponent;
+ let fixture: ComponentFixture
+
+{{(configuration$ | async)?.siteName}}
+
+
+
+
+
+ {{'Votes - ' + (eventName$ | async)}}
+
+
\ No newline at end of file
diff --git a/src/app/modules/admin/voters-list/voters-list.component.scss b/src/app/modules/admin/voters-list/voters-list.component.scss
new file mode 100644
index 0000000..65c15f0
--- /dev/null
+++ b/src/app/modules/admin/voters-list/voters-list.component.scss
@@ -0,0 +1,12 @@
+
+.voters-list-section {
+ margin-top: 20px;
+ margin-bottom: 20px;
+ margin-left: 10px;
+}
+
+.winner {
+ margin: 30px;
+ font-weight: bold;
+ font-size: larger;
+}
diff --git a/src/app/modules/admin/voters-list/voters-list.component.spec.ts b/src/app/modules/admin/voters-list/voters-list.component.spec.ts
new file mode 100644
index 0000000..71b7fd2
--- /dev/null
+++ b/src/app/modules/admin/voters-list/voters-list.component.spec.ts
@@ -0,0 +1,75 @@
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
+import { of, asyncScheduler } from 'rxjs';
+import { observeOn } from 'rxjs/operators';
+
+import { AppMaterialModule } from '../../../app-material.module';
+
+import { VotersListComponent } from './voters-list.component';
+
+import { BackendService } from '../../../services/backend.service';
+import { EventsService } from '../../../services/events.service';
+import { logError } from 'src/app/utils/utils';
+
+describe('VotersListComponent', () => {
+ const VOTERS = ['First Voter', 'Second Voter', 'Third Voter', 'Fourth Voter', 'Fifth Voter'];
+ class MockBackEndService {
+ getVoters() {
+ // need to make it async to avoid error 'ExpressionChangedAfterItHasBeenCheckedError'
+ return of(VOTERS).pipe(observeOn(asyncScheduler));
+ }
+ }
+
+ let component: VotersListComponent;
+ let fixture: ComponentFixture
+
+
+
+ {{winner}}
+
+
+
+
+
+
+
+The list of those who voted
+ {{voter}}
+
+
+
diff --git a/src/app/modules/admin/voting-event/voting-event.component.scss b/src/app/modules/admin/voting-event/voting-event.component.scss
new file mode 100644
index 0000000..99c8e31
--- /dev/null
+++ b/src/app/modules/admin/voting-event/voting-event.component.scss
@@ -0,0 +1,28 @@
+@import "../../../styles/abstracts/mixins";
+
+.voting-event {
+ font-size: 1.6rem;
+
+ .voting-event-section {
+ padding: 1.3rem;
+
+ h3 {
+ margin-bottom: 1.3rem;
+ }
+
+ .voting-event-input {
+ width: 100%;
+ @include byor-input;
+ }
+
+ label {
+ display: block;
+ margin-bottom: .3rem;
+ }
+
+ .mat-flat-button {
+ margin: 0 1rem 1rem 0;
+ }
+
+ }
+}
diff --git a/src/app/modules/admin/voting-event/voting-event.component.spec.ts b/src/app/modules/admin/voting-event/voting-event.component.spec.ts
new file mode 100644
index 0000000..860b4f7
--- /dev/null
+++ b/src/app/modules/admin/voting-event/voting-event.component.spec.ts
@@ -0,0 +1,34 @@
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { ReactiveFormsModule } from '@angular/forms';
+import {NoopAnimationsModule} from '@angular/platform-browser/animations';
+import {RouterTestingModule} from '@angular/router/testing';
+
+import {AppMaterialModule} from '../../../app-material.module';
+
+import { VotingEventComponent } from './voting-event.component';
+import { EventsService } from '../../../services/events.service';
+import { HttpClientTestingModule } from '@angular/common/http/testing';
+
+describe('VotingEventComponent', () => {
+ let component: VotingEventComponent;
+ let fixture: ComponentFixture
+
+
+ All events
+ + + + +
+
+
+
+ {{votingEvent.name}}
+
+
+
+
+ Single event
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+New event
+ + +
+
+
+
+ Login
+
+
+
\ No newline at end of file
diff --git a/src/app/modules/login/login.component.scss b/src/app/modules/login/login.component.scss
new file mode 100644
index 0000000..06135e0
--- /dev/null
+++ b/src/app/modules/login/login.component.scss
@@ -0,0 +1,55 @@
+@import "../../styles/abstracts/mixins";
+
+$login-sections-max-width: 480px;
+
+.login-section {
+ margin: 1.3rem auto;
+ padding: 0 1.3rem;
+ max-width: $login-sections-max-width;
+
+ .event-selection {
+ display: block;
+ }
+
+ .login {
+ margin-bottom: 2rem;
+
+ .login-input {
+ width: 100%;
+ @include byor-input;
+ }
+
+ label {
+ display: block;
+ margin-bottom: .3rem;
+ }
+ }
+
+ .button-text {
+ color: #ffffff;
+ }
+
+}
+
+.event-selection {
+ display: block;
+}
+
+.login-title {
+ background-color: white;
+ padding-top: 30px;
+ padding-bottom: 30px;
+ width: 100%;
+ text-align: center;
+
+ h2 {
+ font-size: 48px;
+ line-height: 1em;
+ letter-spacing: -.06em;
+ font-weight: 400;
+ display: block;
+ padding: 0;
+ margin: 25px 0;
+ text-transform: uppercase;
+ }
+}
diff --git a/src/app/modules/login/login.component.spec.ts b/src/app/modules/login/login.component.spec.ts
new file mode 100644
index 0000000..0cbf567
--- /dev/null
+++ b/src/app/modules/login/login.component.spec.ts
@@ -0,0 +1,155 @@
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { HttpClientModule } from '@angular/common/http';
+import {RouterTestingModule} from '@angular/router/testing';
+import { of, throwError } from 'rxjs';
+
+import { marbles } from 'rxjs-marbles/jasmine';
+
+import {AppMaterialModule} from '../../app-material.module';
+
+import { LoginComponent } from './login.component';
+import { AuthService } from './auth.service';
+
+describe('LoginComponent', () => {
+ const validUserId = 'user';
+ const validPwd = 'pwd';
+
+ const userNotValidMsg = 'user not right';
+ const pwdNotValidMsg = 'pwd not right';
+ class MockAuthService {
+ login(user: string, pwd: string) {
+ if (user === validUserId && pwd === validPwd) {
+ return of(true);
+ } else
+ if (user !== validUserId) {
+ return throwError({message: userNotValidMsg});
+ } else {
+ return throwError({message: pwdNotValidMsg});
+ }
+ }
+ }
+
+ let component: LoginComponent;
+ let fixture: ComponentFixture
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Voting for event: {{votingEvent.name}}
+
+
+
+
+
+
+ {{votingEvent.name}}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ![]()
+
\ No newline at end of file
diff --git a/src/app/modules/vote/start-voting-session/start-voting-session.component.scss b/src/app/modules/vote/start-voting-session/start-voting-session.component.scss
new file mode 100644
index 0000000..8a3805b
--- /dev/null
+++ b/src/app/modules/vote/start-voting-session/start-voting-session.component.scss
@@ -0,0 +1,53 @@
+@import "../../../styles/abstracts/mixins";
+
+$login-sections-max-width: 480px;
+
+.vote-section {
+ margin: 1.3rem auto;
+ padding: 0 1.3rem;
+ max-width: $login-sections-max-width;
+
+ .event-selection {
+ display: block;
+ }
+
+ mat-form-field {
+ width: 100%;
+ }
+
+ .voter {
+ margin-bottom: 2rem;
+
+ .voter-input {
+ width: 100%;
+ @include byor-input;
+ }
+
+ label {
+ display: block;
+ margin-bottom: .3rem;
+ }
+ }
+
+ .button-disabled {
+ border: none;
+ }
+
+ .button-text {
+ color: #ffffff;
+ }
+}
+
+.banner-section {
+ margin: 0 auto;
+ padding: 6rem 1.3rem;
+ max-width: $login-sections-max-width;
+ text-align: center;
+
+ a {
+ border-bottom: none;
+ img {
+ max-width: 100%;
+ }
+ }
+}
diff --git a/src/app/modules/vote/start-voting-session/start-voting-session.component.spec.ts b/src/app/modules/vote/start-voting-session/start-voting-session.component.spec.ts
new file mode 100644
index 0000000..f5ba0fc
--- /dev/null
+++ b/src/app/modules/vote/start-voting-session/start-voting-session.component.spec.ts
@@ -0,0 +1,354 @@
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { HttpClientModule } from '@angular/common/http';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { RouterTestingModule } from '@angular/router/testing';
+import { of, asyncScheduler } from 'rxjs';
+import { tap, observeOn } from 'rxjs/operators';
+import { marbles } from 'rxjs-marbles/jasmine';
+import { AppMaterialModule } from '../../../app-material.module';
+import { StartVotingSessionComponent } from './start-voting-session.component';
+import { VoteService } from '../services/vote.service';
+import { VotingEvent } from 'src/app/models/voting-event';
+import { ConfigurationService } from 'src/app/services/configuration.service';
+import { logError } from 'src/app/utils/utils';
+
+describe('StartVotingSessionComponent', () => {
+ let fixture: ComponentFixture+ {{ring.name}}: + {{ring.description}} +
+
+ {{data.message}}
+
+ Your votes have been saved
diff --git a/src/app/modules/vote/vote/vote-saved-dialogue.component.ts b/src/app/modules/vote/vote/vote-saved-dialogue.component.ts new file mode 100644 index 0000000..c45d38a --- /dev/null +++ b/src/app/modules/vote/vote/vote-saved-dialogue.component.ts @@ -0,0 +1,17 @@ + +import { Component, Inject } from '@angular/core'; +import {MatDialogRef, MAT_DIALOG_DATA} from '@angular/material'; + +@Component({ + selector: 'byor-vote-saved-dialogue', + templateUrl: './vote-saved-dialogue.component.html', + styleUrls: ['./vote.component.scss'] +}) +export class VoteSavedDialogueComponent { + + constructor( + public dialogRef: MatDialogRef
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {{truncatedName(technology.name)}}
+
+ ;
+
+ beforeEach(async(() => {
+ TestBed.configureTestingModule({
+ declarations: [VoteComponent],
+ imports: [BrowserAnimationsModule, HttpClientTestingModule, RouterTestingModule, AppMaterialModule,],
+ providers: [
+ { provide: BackendService, useClass: MockBackEndService },
+ { provide: VoteService, useClass: MockVoteService },
+ ]
+ })
+ .compileComponents();
+ }));
+
+ beforeEach(() => {
+ fixture = TestBed.createComponent(VoteComponent);
+ component = fixture.componentInstance;
+ fixture.detectChanges();
+ });
+
+ it('1.0 should create', () => {
+ expect(component).toBeTruthy();
+ });
+
+ it('1.1 should select all the technologies emitted bythe BackEnd service since there are no filters applied', () => {
+ fixture.detectChanges();
+ fixture.whenStable().then(() => {
+ expect(component.technologiesToShow.length).toBe(TEST_TECHNOLOGIES.length);
+ });
+ });
+
+ it('1.2 should select just the technologies of the quadrant selected', () => {
+ const quadrantSelected = 'Tools';
+
+ component.quadrantSelected(quadrantSelected);
+ fixture.whenStable().then(() => {
+ expect(component.technologiesToShow.length).toBe(TEST_TECHNOLOGIES.filter(d => d.quadrant === quadrantSelected).length);
+ });
+ });
+
+ it('1.3 selects all technologies since we select twice in a row the same quadrant and therefore the toggle logic is applied', () => {
+ const quadrantSelected = 'Tools';
+
+ component.quadrantSelected(quadrantSelected);
+ component.quadrantSelected(quadrantSelected);
+
+ fixture.whenStable().then(() => {
+ expect(component.technologiesToShow.length).toBe(TEST_TECHNOLOGIES.length);
+ });
+ });
+
+ it('1.4 does not select a technology which has been voted', () => {
+ const ring = 'hold';
+ const technologyVotedIndex = 1;
+ const vote = {
+ ring,
+ technology: TEST_TECHNOLOGIES[technologyVotedIndex]
+ };
+
+ component.addVote(vote);
+ fixture.whenStable().then(() => {
+ expect(component.technologiesToShow.find(t => t.name === vote.technology.name)).toBeUndefined();
+ });
+ });
+
+ it('1.5 does SELECT a technology which has been voted and then whose vote has been cancelled', () => {
+ const ring = 'hold';
+ const technologyVotedIndex = 1;
+ const vote = {
+ ring,
+ technology: TEST_TECHNOLOGIES[technologyVotedIndex]
+ };
+
+ component.addVote(vote);
+ component.removeVote(vote);
+
+ fixture.whenStable().then(() => {
+ expect(component.technologiesToShow.find(t => t.name === vote.technology.name)).toBeDefined();
+ });
+ });
+
+ it('1.6 should give the list of votes filtered by ring', () => {
+ expect(component.getVotesByRing(TwRings.names[0]).length).toBe(0);
+
+ const firstVote = {
+ ring: TwRings.names[0],
+ technology: TEST_TECHNOLOGIES[0]
+ };
+ component.addVote(firstVote);
+
+ expect(component.getVotesByRing(TwRings.names[0])).toEqual([firstVote]);
+
+ const secondVote = {
+ ring: TwRings.names[1],
+ technology: TEST_TECHNOLOGIES[1]
+ };
+ component.addVote(secondVote);
+ const thirdVote = {
+ ring: TwRings.names[1],
+ technology: TEST_TECHNOLOGIES[2]
+ };
+ component.addVote(thirdVote);
+
+ expect(component.getVotesByRing(TwRings.names[0])).toEqual([firstVote]);
+ expect(component.getVotesByRing(TwRings.names[1])).toEqual([secondVote, thirdVote]);
+ expect(component.getVotesByRing(TwRings.names[2]).length).toEqual(0);
+
+ });
+
+ describe('search for technology', () => {
+ it('should list down all the technologies that matches the search string', () => {
+ component.search$ = of(TEST_TECHNOLOGIES[0].name)
+ fixture.whenStable().then(() => {
+ expect(component.technologiesToShow.find(t => t === TEST_TECHNOLOGIES[0]));
+ });
+ });
+
+ it('should list down all the technologies that matches the search character', () => {
+ component.search$ = of('c');
+ fixture.whenStable().then(() => {
+ expect(component.technologiesToShow.length).toBe(3);
+ expect(component.technologiesToShow).toContain(TEST_TECHNOLOGIES[2]);
+ expect(component.technologiesToShow).toContain(TEST_TECHNOLOGIES[3]);
+ expect(component.technologiesToShow).toContain(TEST_TECHNOLOGIES[4]);
+ });
+ });
+
+ it('should get empty list of technologies when that does not matches the search string', () => {
+ component.search$ = of('random');
+ fixture.whenStable().then(() => {
+ expect(component.technologiesToShow.length).toBe(0);
+ });
+ });
+ })
+
+ describe('vote exist', () => {
+ it('should return true when vote is already added', function () {
+ const ring = 'hold';
+ const technologyVotedIndex = 1;
+ const vote = {
+ ring,
+ technology: TEST_TECHNOLOGIES[technologyVotedIndex]
+ };
+
+ component.addVote(vote);
+
+ const isExist = component.isAlreadyVoted(TEST_TECHNOLOGIES[technologyVotedIndex].name);
+ expect(isExist).toBeTruthy()
+
+ });
+
+ it('should return false when vote does not find in the voted list', function () {
+ const ring = 'hold';
+ const technologyVotedIndex = 1;
+ const vote = {
+ ring,
+ technology: TEST_TECHNOLOGIES[technologyVotedIndex]
+ };
+ component.addVote(vote);
+ const isExist = component.isAlreadyVoted('random');
+ expect(isExist).toBeFalsy()
+
+ });
+ })
+});
diff --git a/src/app/modules/vote/vote/vote.component.ts b/src/app/modules/vote/vote/vote.component.ts
new file mode 100644
index 0000000..75c0df6
--- /dev/null
+++ b/src/app/modules/vote/vote/vote.component.ts
@@ -0,0 +1,248 @@
+import { Component, ViewChild, ElementRef, AfterViewInit, OnDestroy } from '@angular/core';
+import { Router } from '@angular/router';
+import { MatDialog } from '@angular/material';
+
+import { BehaviorSubject, combineLatest, Observable, fromEvent, concat, of, Subject, merge, EMPTY, Subscription } from 'rxjs';
+import { map, catchError, switchMap, scan, shareReplay, delay, tap } from 'rxjs/operators';
+
+import { environment } from '../../../../environments/environment';
+
+import { VoteDialogueComponent } from './vote-dialogue.component';
+import { VoteSavedDialogueComponent } from './vote-saved-dialogue.component';
+
+import { BackendService } from '../../../services/backend.service';
+import { ErrorService } from '../../../services/error.service';
+import { Technology } from '../../../models/technology';
+import { Vote } from '../../../models/vote';
+import { QUADRANT_NAMES } from '../../../models/quadrant';
+import { VoteService } from '../services/vote.service';
+import { VoteCredentials } from '../../../models/vote-credentials';
+import * as _ from 'lodash';
+import { TwRings } from 'src/app/models/ring';
+import { Comment } from 'src/app/models/comment';
+import { logError } from 'src/app/utils/utils';
+
+@Component({
+ selector: 'byor-vote',
+ templateUrl: './vote.component.html',
+ styleUrls: ['./vote.component.scss']
+})
+export class VoteComponent implements AfterViewInit, OnDestroy {
+ @ViewChild('searchField') searchField: ElementRef;
+ quadrants = QUADRANT_NAMES;
+ rings = TwRings.names;
+
+ private technologiesToShowSubscription: Subscription;
+ technologiesToShow: Technology[];
+
+ votes = new Array();
+ votes$ = new BehaviorSubject>(this.votes);
+ search$: Observable;
+ clearSearch$ = new Subject();
+ quadrantSelected$ = new BehaviorSubject('');
+ // the following Observable emits the name of the quadrant selected if it is different from the last quadrant selected,
+ // otherwise, if it is the same value as the last one selected, it emits an empty string
+ // this is to implement a toggle mechanism, so that if you click twice on the same button, the first time it emits
+ // the name of the quadrant associated to the button while the second time it emits the empty string - the third time it
+ // would emit again the name of the quadrant
+ // via this mechanims we can avoid defining a Class variable to hold the state of the "selected button" and we keep
+ // the implementation stateless - to be understood whether this makes it simpler
+ quadrantSelectedToggle$ = this.quadrantSelected$.pipe(
+ scan((currentQuadrant, quadrant) => {
+ return currentQuadrant === quadrant ? '' : quadrant;
+ }),
+ // shareReplay(1) is important since this Observable is used with 2 subscriptions: one to support the filtering
+ // and one to support the highlight of the selected quadrant button with toggling
+ shareReplay(1)
+ );
+
+ votingEventId$: Observable;
+
+ messageVote: string;
+
+ constructor(
+ private backEnd: BackendService,
+ private router: Router,
+ private errorService: ErrorService,
+ public dialog: MatDialog,
+ private voteService: VoteService
+ ) {}
+
+ ngAfterViewInit() {
+ this.search$ = merge(concat(of(''), fromEvent(this.searchField.nativeElement, 'keyup')), this.clearSearch$).pipe(
+ map(() => this.searchField.nativeElement.value)
+ );
+ this.technologiesToShowSubscription = this.techonologiesToShow().subscribe((t) => {
+ this.technologiesToShow = t;
+ });
+ }
+ ngOnDestroy() {
+ if (!!this.technologiesToShowSubscription) {
+ this.technologiesToShowSubscription.unsubscribe();
+ }
+ }
+
+ techonologiesToShow() {
+ let technologies: Array;
+ return this.getTechnologies().pipe(
+ tap((techs) => (technologies = techs)),
+ switchMap(() => {
+ return combineLatest([this.votes$, this.search$, this.quadrantSelectedToggle$]);
+ }),
+ // delay is needed to avoid the error ExpressionChangedAfterItHasBeenCheckedError
+ // @todo see if it is possible to remove delay
+ delay(0),
+ // show in the list only the technologies for which the user has not already cast a vote
+ map(([votes, search, quadrant]) => {
+ return technologies
+ .filter((technology) => votes.find((vote) => vote.technology.name === technology.name) === undefined)
+ .filter((technology) => search === '' || technology.name.toLowerCase().includes(search.toLowerCase()))
+ .filter((technology) => quadrant === '' || technology.quadrant.toLowerCase() === quadrant.toLowerCase());
+ }),
+ catchError((err) => {
+ logError(err);
+ this.router.navigate(['/error']);
+ this.errorService.setError(err);
+ return EMPTY;
+ })
+ );
+ }
+
+ getTechnologies() {
+ const votingEvent = this.voteService.credentials.votingEvent;
+ return this.backEnd.getVotingEvent(votingEvent._id).pipe(
+ map((event) => {
+ let technologies = event.technologies;
+ if (votingEvent.openForRevote) {
+ technologies = technologies.filter((t) => t.forRevote);
+ }
+ return _.sortBy(technologies, function(item: Technology) {
+ return item.name.toLowerCase();
+ });
+ })
+ );
+ }
+
+ getVotesByRing(ring: string): Vote[] {
+ return this.votes.filter((v) => v.ring === ring);
+ }
+
+ createNewTechnology(name: string, quadrant: string) {
+ const votingEvent = this.voteService.credentials.votingEvent;
+ const technology: Technology = {
+ name: name,
+ isnew: true,
+ description: '',
+ quadrant: quadrant
+ };
+ this.backEnd.addTechnologyToVotingEvent(votingEvent._id, technology).subscribe((resp) => {
+ this.openVoteDialog(technology);
+ });
+ }
+
+ openVoteDialog(technology: Technology): void {
+ let message: string;
+ if (this.votes.length === environment.maxNumberOfVotes) {
+ message = 'You have already given the max number of votes - cancel one vote if you want to vote for ' + technology.name;
+ }
+ const dialogRef = this.dialog.open(VoteDialogueComponent, {
+ width: '400px',
+ maxWidth: '90vw',
+ data: { technology, message }
+ });
+
+ dialogRef.afterClosed().subscribe((result) => {
+ if (result) {
+ const vote: Vote = {
+ ring: result.ring,
+ technology
+ };
+ if (result.comment) {
+ const voteComment: Comment = {
+ text: result.comment
+ };
+ vote.comment = voteComment;
+ }
+ if (vote.ring) {
+ this.addVote(vote);
+ }
+ }
+ });
+ }
+
+ addVote(vote: Vote) {
+ this.votes.push(vote);
+ this.votes$.next(this.votes);
+ }
+
+ removeVote(vote: Vote) {
+ const index = this.votes.indexOf(vote);
+ this.votes.splice(index, 1);
+ this.votes$.next(this.votes);
+ }
+
+ saveVotes() {
+ this.backEnd.saveVote(this.votes, this.voteService.credentials).subscribe(
+ (resp) => {
+ if (resp.error) {
+ if (resp.error.errorCode === 'V-01') {
+ const voterName = this.getVoterFirstLastName(this.voteService.credentials);
+ this.messageVote = ` ${voterName} has already voted`;
+ } else {
+ this.messageVote = `Vote could not be saved - look at the browser console
+ - maybe there is something there`;
+ }
+ } else {
+ const dialogRef = this.dialog.open(VoteSavedDialogueComponent, {
+ width: '400px'
+ });
+
+ dialogRef.afterClosed().subscribe((result) => {
+ this.router.navigate(['/vote']);
+ });
+ }
+ },
+ (err) => {
+ logError(err);
+ this.messageVote = `Vote could not be saved - look at the browser console
+ - maybe there is something there`;
+ }
+ );
+ }
+ getVoterFirstLastName(cred: VoteCredentials) {
+ const firstName = cred.voterId.firstName;
+ const lastName = cred.voterId.lastName;
+ return firstName + ' ' + lastName;
+ }
+
+ clearSearch() {
+ this.searchField.nativeElement.value = '';
+ this.clearSearch$.next('');
+ }
+
+ quadrantSelected(quadrant: string) {
+ this.quadrantSelected$.next(quadrant);
+ }
+ isQuadrantSelected(quadrant: string) {
+ return this.quadrantSelectedToggle$.pipe(map((q) => q === quadrant));
+ }
+
+ truncatedName(name: string) {
+ const maxLength = 30;
+ let shortName = name;
+ if (name.length > maxLength) {
+ shortName =
+ _(name.substring(0, maxLength).split(' '))
+ .tap(function(array) {
+ array.pop();
+ })
+ .join(' ') + '...';
+ }
+ return shortName;
+ }
+
+ isAlreadyVoted(value: string) {
+ const existingVote = this.votes.filter((vote) => vote.technology.name === value);
+ return existingVote.length !== 0;
+ }
+}
diff --git a/src/app/services/backend.service.spec.ts b/src/app/services/backend.service.spec.ts
new file mode 100644
index 0000000..02911d8
--- /dev/null
+++ b/src/app/services/backend.service.spec.ts
@@ -0,0 +1,721 @@
+import { TestBed, inject } from '@angular/core/testing';
+import { HttpClientTestingModule } from '@angular/common/http/testing';
+import { HttpClientModule, HttpClient } from '@angular/common/http';
+
+import { BackendService } from './backend.service';
+import { of, forkJoin } from 'rxjs';
+import { tap, switchMap, catchError, map, concatMap } from 'rxjs/operators';
+
+import { VoteCredentials } from '../models/vote-credentials';
+import { ERRORS } from './errors';
+import { VotingEvent } from '../models/voting-event';
+import { Technology } from '../models/technology';
+import { environment } from '../../environments/environment';
+import { Vote } from '../models/vote';
+import { JwtModule } from '@auth0/angular-jwt';
+import { apiDomain } from '../app.module';
+import { logError } from '../utils/utils';
+
+describe('BackendService', () => {
+ let testToken;
+ let httpClient: HttpClient;
+
+ function getTestToken() {
+ return testToken;
+ }
+ const validUser = { user: 'abc', pwd: '123' };
+
+ beforeEach(() => {
+ TestBed.configureTestingModule({
+ imports: [
+ HttpClientModule,
+ JwtModule.forRoot({
+ config: {
+ tokenGetter: getTestToken,
+ whitelistedDomains: [apiDomain()]
+ }
+ })
+ ],
+ providers: [HttpClient]
+ });
+ inject([HttpClient], (service1: HttpClient) => {
+ httpClient = service1;
+ })();
+ });
+
+ it('should be created', () => {
+ const service: BackendService = TestBed.get(BackendService);
+ expect(service).toBeTruthy();
+ });
+
+ describe('2 BackendService - focused integration tests', () => {
+ it('2.1 test the entire voting cycle', (done) => {
+ const service: BackendService = TestBed.get(BackendService);
+ const votingEventName = 'thisTestVotingEvent';
+ const commentOnVote = 'it is crap';
+ const votes1 = [
+ { ring: 'adopt', technology: null },
+ {
+ ring: 'hold',
+ technology: null,
+ comment: { text: commentOnVote }
+ }
+ ];
+ const credentials1: VoteCredentials = {
+ voterId: { firstName: 'fv1', lastName: 'lv1' },
+ votingEvent: null
+ };
+ const votes2 = [{ ring: 'adopt', technology: null }, { ring: 'trial', technology: null }];
+ const credentials2: VoteCredentials = {
+ voterId: { firstName: 'fv2', lastName: 'lv2' },
+ votingEvent: null
+ };
+ const votes3 = [{ ring: 'trial', technology: null }];
+
+ let votingEvent;
+ service
+ .authenticate(validUser.user, validUser.pwd)
+ .pipe(
+ tap((resp) => (testToken = resp)),
+ concatMap((resp) => service.getVotingEvents({ all: true })), // first delete any votingEvent with the same name
+ map((votingEvents) => {
+ const vEvents = votingEvents.filter((ve) => ve.name === votingEventName);
+ return vEvents.map((ve) => service.cancelVotingEvent(ve._id, true));
+ }),
+ switchMap((cancelVERequests) => (cancelVERequests.length > 0 ? forkJoin(cancelVERequests) : of(null)))
+ )
+ .pipe(
+ switchMap(() => service.createVotingEvent(votingEventName)),
+ switchMap(() => service.getVotingEvents()),
+ tap((votingEvents) => {
+ const vEvents = votingEvents.filter((ve) => ve.name === votingEventName);
+ expect(vEvents.length).toBe(1);
+ expect(vEvents[0].status).toBe('closed');
+ votingEvent = vEvents[0];
+ credentials1.votingEvent = votingEvent;
+ }),
+ switchMap(() => service.openVotingEvent(votingEvent._id)),
+ switchMap(() => service.hasAlreadyVoted(credentials1)),
+ tap((hasVoted) => {
+ expect(hasVoted).toBeFalsy();
+ }),
+ switchMap(() => service.getVotingEvent(votingEvent._id)),
+ tap((vEvent) => {
+ expect(vEvent.status).toBe('open');
+ votes1[0].technology = vEvent.technologies[0];
+ votes1[1].technology = vEvent.technologies[1];
+ votes2[0].technology = vEvent.technologies[0];
+ votes2[1].technology = vEvent.technologies[1];
+ credentials1.votingEvent = vEvent;
+ credentials2.votingEvent = vEvent;
+ }),
+ switchMap(() => service.saveVote(votes1, credentials1)),
+ switchMap(() => service.saveVote(votes2, credentials2)),
+ switchMap(() => service.getVotes(votingEvent._id)),
+ tap((votesFromBE) => {
+ expect(votesFromBE.length).toBe(4);
+ const votesWithNoRound = votesFromBE.filter((vote) => typeof vote.eventRound === 'undefined');
+ expect(votesWithNoRound.length).toBe(0);
+ expect(votesFromBE.filter((v) => v.comment).length).toBe(1);
+ expect(votesFromBE.filter((v) => v.comment)[0].comment.text).toBe(commentOnVote);
+ }),
+ switchMap(() => service.hasAlreadyVoted(credentials1)),
+ tap((hasVoted) => {
+ expect(hasVoted).toBeTruthy();
+ }),
+ switchMap(() => service.getVoters(votingEvent)),
+ tap((voters) => {
+ expect(voters.length).toBe(2);
+ }),
+ switchMap(() => service.calculateBlips(votingEvent)),
+ tap((blips) => {
+ expect(blips.length).toBe(2);
+ expect(blips.filter((b) => b.forRevote).length).toBe(1);
+ }),
+ switchMap(() => service.getVotingEvent(votingEvent._id)),
+ tap((event) => {
+ votingEvent = event;
+ expect(event.blips.length).toBe(2);
+ expect(event.technologies).toBeDefined();
+ expect(event.technologies.filter((t) => t.forRevote).length).toBe(1);
+ }),
+ switchMap(() => service.saveVote(votes2, credentials2)),
+ catchError((err) => {
+ expect(err.errorCode).toBe(ERRORS.voteAlreadyPresent);
+ return of(null);
+ }),
+ switchMap(() => service.openForRevote(votingEvent)),
+ switchMap(() => service.getVotingEvent(votingEvent._id)),
+ tap((vEvent: VotingEvent) => {
+ expect(vEvent.openForRevote).toBe(true);
+ expect(vEvent.hasTechnologiesForRevote).toBe(true);
+ expect(vEvent.technologies.filter((t) => t.forRevote).length).toBe(1);
+ votes3[0].technology = vEvent.technologies[1];
+ credentials1.votingEvent = vEvent;
+ }),
+ switchMap(() => service.saveVote(votes3, credentials1)),
+ switchMap(() => service.cancelVotingEvent(votingEvent._id)),
+ switchMap(() => service.getVotingEvents()),
+ tap((votingEvents) => {
+ expect(votingEvents.filter((ve) => ve.name === votingEventName).length).toBe(0);
+ })
+ )
+ .subscribe({
+ error: (err) => {
+ logError('2.1 test the entire voting cycle ' + err);
+ done();
+ throw new Error('the voting cycle does not work');
+ },
+ complete: () => done()
+ });
+ }, 100000);
+ });
+
+ describe('3 BackendService - get aggregated votes', () => {
+ // it('3.1 test the vote aggregation logic', done => {
+ // const service: BackendService = TestBed.get(BackendService);
+ // const votingEventName = 'theAggregationVotingEvent';
+ // // there are 3 voters casting votes on 2 technologies, tech1 and tech2
+ // // tech1 has 2 adopt and 1 hold
+ // // tech2 has 1 hold and 2 assess
+ // const techName1 = 'tech1';
+ // const techName2 = 'tech2';
+ // const votes1 = [
+ // {ring: 'adopt', technology: {id: '1', name: techName1, description: 'desc1', quadrant: 'tools', isnew: true}},
+ // {ring: 'hold', technology: {id: '2', name: techName2, description: 'desc2', quadrant: 'platforms', isnew: false}}
+ // ];
+ // const credentials1: VoteCredentials = {
+ // voterId: {firstName: 'fv1', lastName: 'lv1'},
+ // votingEvent: null
+ // };
+ // const votes2 = [
+ // {ring: 'adopt', technology: {id: '1', name: techName1, description: 'desc1', quadrant: 'tools', isnew: true}},
+ // {ring: 'assess', technology: {id: '2', name: techName2, description: 'desc2', quadrant: 'platforms', isnew: false}}
+ // ];
+ // const credentials2: VoteCredentials = {
+ // voterId: {firstName: 'fv2', lastName: 'lv2'},
+ // votingEvent: null
+ // };
+ // const votes3 = [
+ // {ring: 'hold', technology: {id: '1', name: techName1, description: 'desc1', quadrant: 'tools', isnew: true}},
+ // {ring: 'assess', technology: {id: '2', name: techName2, description: 'desc2', quadrant: 'platforms', isnew: false}}
+ // ];
+ // const credentials3: VoteCredentials = {
+ // voterId: {firstName: 'fv3', lastName: 'lv3'},
+ // votingEvent: null
+ // };
+ // let votingEvent;
+ // service.cancelVotingEvent(votingEventName, true)
+ // .pipe(
+ // switchMap(() => service.createVotingEvent(votingEventName)),
+ // switchMap(() => service.getVotingEvents()),
+ // tap(votingEvents => {
+ // votingEvent = votingEvents.find(ve => ve.name === votingEventName);
+ // credentials1.votingEvent = votingEvent;
+ // credentials2.votingEvent = votingEvent;
+ // credentials3.votingEvent = votingEvent;
+ // }),
+ // switchMap(() => service.openVotingEvent(votingEvent._id)),
+ // switchMap(() => service.saveVote(votes1, credentials1)),
+ // switchMap(() => service.saveVote(votes2, credentials2)),
+ // switchMap(() => service.saveVote(votes3, credentials3)),
+ // switchMap(() => service.getAggregatedVotes(votingEvent)),
+ // )
+ // .subscribe(
+ // aggregatesVotes => {
+ // expect(aggregatesVotes.length).toBe(4);
+ // const aggVotesTech1 = aggregatesVotes.filter(av => av.technology.name === techName1);
+ // expect(aggVotesTech1.length).toBe(2);
+ // expect(aggVotesTech1.find(av => av.count === 2).ring).toBe('adopt');
+ // expect(aggVotesTech1.find(av => av.count === 1).ring).toBe('hold');
+ // const aggVotesTech2 = aggregatesVotes.filter(av => av.technology.name === techName2);
+ // expect(aggVotesTech2.length).toBe(2);
+ // expect(aggVotesTech2.find(av => av.count === 2).ring).toBe('assess');
+ // expect(aggVotesTech2.find(av => av.count === 1).ring).toBe('hold');
+ // },
+ // err => {
+ // logError('3.1 test the vote aggregation logic', err);
+ // done();
+ // throw(new Error('the vote aggregation logic has some issues'));
+ // },
+ // () => done()
+ // );
+ // }, 20000);
+ });
+
+ // describe('4 BackendService - calculate blips', () => {
+ // let httpClient: HttpClient;
+
+ // beforeEach(() => {
+ // TestBed.configureTestingModule({
+ // imports: [HttpClientModule],
+ // providers: [HttpClient]
+ // });
+ // inject([HttpClient], (service1: HttpClient) => {
+ // httpClient = service1;
+ // })();
+ // });
+
+ // it('4.1 test the blip calculation logic', (done) => {
+ // const service: BackendService = TestBed.get(BackendService);
+ // const votingEventName = 'theCalculateBlipsEvent';
+ // // there are 3 voters casting votes on 2 technologies, tech1 and tech2
+ // // tech1 has 2 adopt and 1 hold
+ // // tech2 has 1 hold and 2 assess
+ // const techName1 = 'tech1';
+ // const techName2 = 'tech2';
+ // const votes1 = [
+ // { ring: 'adopt', technology: { id: '1', name: techName1, description: 'desc1', quadrant: 'tools', isnew: true } },
+ // { ring: 'hold', technology: { id: '2', name: techName2, description: 'desc2', quadrant: 'platforms', isnew: false } }
+ // ];
+ // const credentials1: VoteCredentials = {
+ // voterId: { firstName: 'fv1', lastName: 'lv1' },
+ // votingEvent: null
+ // };
+ // const votes2 = [
+ // { ring: 'adopt', technology: { id: '1', name: techName1, description: 'desc1', quadrant: 'tools', isnew: true } },
+ // { ring: 'assess', technology: { id: '2', name: techName2, description: 'desc2', quadrant: 'platforms', isnew: false } }
+ // ];
+ // const credentials2: VoteCredentials = {
+ // voterId: { firstName: 'fv2', lastName: 'lv2' },
+ // votingEvent: null
+ // };
+ // const votes3 = [
+ // { ring: 'hold', technology: { id: '1', name: techName1, description: 'desc1', quadrant: 'tools', isnew: true } },
+ // { ring: 'assess', technology: { id: '2', name: techName2, description: 'desc2', quadrant: 'platforms', isnew: false } }
+ // ];
+ // const credentials3: VoteCredentials = {
+ // voterId: { firstName: 'fv3', lastName: 'lv3' },
+ // votingEvent: null
+ // };
+
+ // let votingEvent;
+ // service
+ // .cancelVotingEvent(votingEventName, true)
+ // .pipe(
+ // switchMap(() => service.createVotingEvent(votingEventName)),
+ // switchMap(() => service.getVotingEvents()),
+ // tap((votingEvents) => {
+ // votingEvent = votingEvents.find((ve) => ve.name === votingEventName);
+ // credentials1.votingEvent = votingEvent;
+ // credentials2.votingEvent = votingEvent;
+ // credentials3.votingEvent = votingEvent;
+ // }),
+ // switchMap(() => service.openVotingEvent(votingEvent._id)),
+ // switchMap(() => service.saveVote(votes1, credentials1)),
+ // switchMap(() => service.saveVote(votes2, credentials2)),
+ // switchMap(() => service.saveVote(votes3, credentials3)),
+ // switchMap(() => service.calculateBlips(votingEvent))
+ // )
+ // .subscribe(
+ // (blips) => {
+ // expect(blips.length).toBe(2);
+ // const blipTech1 = blips.find((b) => b.name === techName1);
+ // expect(blipTech1).toBeDefined();
+ // expect(blipTech1.ring).toBe('adopt');
+ // const blipTech2 = blips.find((b) => b.name === techName2);
+ // expect(blipTech2).toBeDefined();
+ // expect(blipTech2.ring).toBe('assess');
+ // },
+ // (err) => {
+ // logError('4.1 test the blip calculation logic', err);
+ // done();
+ // throw new Error('the blip calculation logic has some issues');
+ // },
+ // () => done()
+ // );
+ // }, 20000);
+ // });
+
+ describe('5 BackendService - authenticate', () => {
+ it(`5.1 authenticate a valid user. It assumes that the users used in the test are correctly loaded in the backend`, (done) => {
+ const service: BackendService = TestBed.get(BackendService);
+ service.authenticate(validUser.user, validUser.pwd).subscribe(
+ (resp) => {
+ expect(resp).toBeTruthy();
+ },
+ (err) => {
+ logError('5.1 authenticate a valid user ' + err);
+ done();
+ throw new Error('the authenticate logic has some issues');
+ },
+ () => done()
+ );
+ }, 10000);
+
+ it(`5.2 tries to authenticate a user with the wrong password.
+ It assumes that the users used in the test are correctly loaded in the backend`, (done) => {
+ const service: BackendService = TestBed.get(BackendService);
+ const invalidUser = { user: 'abc', pwd: '321' };
+
+ service.authenticate(invalidUser.user, invalidUser.pwd).subscribe(
+ (resp) => {
+ logError('5.2 authenticate a user with wrong password ' + resp);
+ done();
+ throw new Error('the authenticate logic has some issues');
+ },
+ (err) => {
+ expect(err.errorCode).toBe(ERRORS.pwdInvalid);
+ done();
+ },
+ () => done()
+ );
+ }, 10000);
+
+ it(`5.3 tries to authenticate a user that does not exist.
+ It assumes that the users used in the test are correctly loaded in the backend`, (done) => {
+ const service: BackendService = TestBed.get(BackendService);
+ const invalidUser = { user: 'not existing user', pwd: '321' };
+
+ service.authenticate(invalidUser.user, invalidUser.pwd).subscribe(
+ (resp) => {
+ logError('5.3 authenticate a user that does not exist ' + resp);
+ done();
+ throw new Error('the authenticate logic has some issues');
+ },
+ (err) => {
+ expect(err.errorCode).toBe(ERRORS.userUnknown);
+ done();
+ },
+ () => done()
+ );
+ }, 10000);
+ });
+
+ describe('6 BackendService - getConfiguration', () => {
+ it(`6.1 retrieve the configuration without specifying a user.
+ It assumes that the configuration has been correctly loaded on the backend
+ This can be achieved using the command node ./dist/src/mongodb/scripts/set-configuration-collection DEV`, (done) => {
+ const service: BackendService = TestBed.get(BackendService);
+
+ service.getConfiguration().subscribe(
+ (configuration) => {
+ expect(configuration.revoteToggle).toBeFalsy();
+ expect(configuration.secondValue).toBe('second');
+ expect(configuration.thirdValue).toBeUndefined();
+ },
+ (err) => {
+ logError('6.1 retrieve the configuration without specifying a user ' + err);
+ done();
+ throw new Error('the getConfiguration logic has some issues');
+ },
+ () => done()
+ );
+ }, 10000);
+
+ it(`6.2 retrieve the configuration specifying a user.
+ It assumes that the configuration has been correctly loaded on the backend
+ This can be achieved using the command node ./dist/src/mongodb/scripts/set-configuration-collection DEV`, (done) => {
+ const service: BackendService = TestBed.get(BackendService);
+
+ service.getConfiguration('abc').subscribe(
+ (configuration) => {
+ expect(configuration.revoteToggle).toBeTruthy();
+ expect(configuration.secondValue).toBe('second');
+ expect(configuration.thirdValue).toBe('third');
+ },
+ (err) => {
+ logError('6.1 retrieve the configuration without specifying a user ' + err);
+ done();
+ throw new Error('the getConfiguration logic has some issues');
+ },
+ () => done()
+ );
+ }, 10000);
+ });
+
+ describe('7 BackendService - saveLogInfo', () => {
+ it(`7.1 saves some info in the logCollection of the backend`, (done) => {
+ const service: BackendService = TestBed.get(BackendService);
+
+ const reason = 'I am the reason I send the log';
+ const logData = 'I am something the client wants to log on the server';
+
+ service.saveLogInfo(reason, logData).subscribe(
+ (logId) => {
+ expect(logId[0]).toBe('ObjectID');
+ },
+ (err) => {
+ logError('7.1 saveLogInfo should not raise an error ' + err);
+ done();
+ throw new Error('the saveLogInfo logic has some issues');
+ },
+ () => done()
+ );
+ }, 10000);
+ });
+
+ describe('8 BackendService - crud on Technology', () => {
+ it(`8.1 adds a technology, then reads it, then updates it`, (done) => {
+ const service: BackendService = TestBed.get(BackendService);
+
+ const technology: Technology = {
+ name: 'the new tech to add',
+ description: 'I am a tech that the client wants to add',
+ isnew: true,
+ quadrant: 'tools'
+ };
+ const newDescriptionForUpdate = 'this is the new description of the technology';
+
+ service
+ .authenticate(validUser.user, validUser.pwd)
+ .pipe(
+ tap((resp) => (testToken = resp)),
+ concatMap((resp) => service.getTechnologies())
+ )
+ .pipe(
+ map((technologies) => {
+ const techs = technologies.filter((tech) => tech.name === technology.name);
+ return techs.map((tech) => service.deleteTechnology(tech._id));
+ }),
+ switchMap((cancelTechRequests) => (cancelTechRequests.length > 0 ? forkJoin(cancelTechRequests) : of(null)))
+ )
+ .pipe(
+ // add a technology
+ switchMap(() => service.addTechnology(technology)),
+ tap((data) => {
+ expect(data).toBeDefined();
+ }),
+ // read the technology just added
+ switchMap(() => service.getTechnology(technology.name)),
+ tap((tech: Technology) => {
+ expect(tech.description).toBe(technology.description);
+ }),
+ // update the technology just read
+ switchMap((tech: Technology) => {
+ const techForUpdate = tech;
+ techForUpdate.description = newDescriptionForUpdate;
+ return service.updateTechnology(techForUpdate);
+ }),
+ switchMap(() => service.getTechnology(technology.name)), // read again to see the effect of the update
+ tap((tech: Technology) => {
+ expect(tech.description).toBe(newDescriptionForUpdate);
+ })
+ )
+ .subscribe({
+ error: (err) => {
+ logError('8.1 addTechnology should not raise an error ' + err);
+ done();
+ throw new Error('the addTechnology logic has some issues');
+ },
+ complete: () => done()
+ });
+ }, 10000);
+ });
+
+ describe('9 BackendService - test adding a technology to a voting event', () => {
+ it('9.1 create a voting event and add a technology to it', (done) => {
+ const service: BackendService = TestBed.get(BackendService);
+ const votingEventName = 'theVotingEventForANewTech';
+
+ const newTech: Technology = {
+ name: 'the new tech to add',
+ description: 'I am the cool new tech to add',
+ isnew: true,
+ quadrant: 'tools'
+ };
+
+ let votingEvent;
+ service
+ .authenticate(validUser.user, validUser.pwd)
+ .pipe(
+ tap((resp) => (testToken = resp)),
+ concatMap((resp) => service.getVotingEvents({ all: true })),
+ map((votingEvents) => {
+ const vEvents = votingEvents.filter((ve) => ve.name === votingEventName);
+ return vEvents.map((ve) => service.cancelVotingEvent(ve._id, true));
+ }),
+ switchMap((cancelVERequests) => (cancelVERequests.length > 0 ? forkJoin(cancelVERequests) : of(null)))
+ )
+ .pipe(
+ switchMap(() => service.createVotingEvent(votingEventName)),
+ switchMap(() => service.getVotingEvents()),
+ tap((votingEvents) => {
+ const vEvents = votingEvents.filter((ve) => ve.name === votingEventName);
+ votingEvent = vEvents[0];
+ }),
+ switchMap(() => service.addTechnologyToVotingEvent(votingEvent._id, newTech)),
+ switchMap(() => service.getVotingEvent(votingEvent._id)),
+ tap((vEvent) => {
+ expect(vEvent.technologies.length).toBe(1);
+ expect(vEvent.technologies[0].description).toBe(newTech.description);
+ })
+ )
+ .subscribe({
+ error: (err) => {
+ logError('9.1 test adding technology to an event ' + err);
+ done();
+ throw new Error('adding technology to an event does not work');
+ },
+ complete: () => done()
+ });
+ }, 100000);
+ });
+
+ describe('10 BackendService - vote and then retrieve comments on the votes', () => {
+ it('10.1 add some votes with comments and then retrieve the comments', (done) => {
+ const service: BackendService = TestBed.get(BackendService);
+ const votingEventName = 'a voting event with votes with comments';
+ const commentOnVote1 = 'this is the FIRST comment I made for this test';
+ const commentOnVote2 = 'this is the SECOND comment I made for this test';
+ let votes1;
+ let credentials1: VoteCredentials;
+ let votes2;
+ let credentials2: VoteCredentials;
+ const votes3 = [{ ring: 'trial', technology: null }];
+
+ let votingEvent;
+
+ let tech1: Technology;
+ let tech2: Technology;
+ service
+ .authenticate(validUser.user, validUser.pwd)
+ .pipe(
+ tap((resp) => (testToken = resp)),
+ concatMap((resp) => service.getVotingEvents({ all: true })),
+ map((votingEvents) => {
+ const vEvents = votingEvents.filter((ve) => ve.name === votingEventName);
+ return vEvents.map((ve) => service.cancelVotingEvent(ve._id, true));
+ }),
+ switchMap((cancelVERequests) => (cancelVERequests.length > 0 ? forkJoin(cancelVERequests) : of(null)))
+ )
+ .pipe(
+ switchMap(() => service.createVotingEvent(votingEventName)),
+ switchMap(() => service.getVotingEvents()),
+ tap((votingEvents) => {
+ const vEvents = votingEvents.filter((ve) => ve.name === votingEventName);
+ expect(vEvents.length).toBe(1);
+ credentials1 = {
+ voterId: { firstName: 'fCommenter1', lastName: 'lCommenter1' },
+ votingEvent: null
+ };
+ credentials2 = {
+ voterId: { firstName: 'fCommenter2', lastName: 'fCommenter2' },
+ votingEvent: null
+ };
+ votingEvent = vEvents[0];
+ credentials1.votingEvent = votingEvent;
+ }),
+ switchMap(() => service.openVotingEvent(votingEvent._id)),
+ switchMap(() => service.getVotingEvent(votingEvent._id)),
+ // the first voter, Commenter1, saves 2 votes, the last one on tech2 with a comment
+ // the second voter, Commenter2, saves 2 votes, the last one on the same technology with a comment
+ tap((vEvent) => {
+ tech1 = vEvent.technologies[0];
+ tech2 = vEvent.technologies[1];
+ votes1 = [
+ { ring: 'adopt', technology: tech1 },
+ {
+ ring: 'hold',
+ technology: tech2,
+ comment: { text: commentOnVote1 }
+ }
+ ];
+ votes2 = [
+ { ring: 'adopt', technology: tech1 },
+ {
+ ring: 'trial',
+ technology: tech2,
+ comment: { text: commentOnVote2 }
+ }
+ ];
+ credentials1.votingEvent = vEvent;
+ credentials2.votingEvent = vEvent;
+ }),
+ switchMap(() => service.saveVote(votes1, credentials1)),
+ switchMap(() => service.saveVote(votes2, credentials2)),
+ switchMap(() => service.getVotesWithCommentsForTechAndEvent(tech2._id, votingEvent._id)),
+ tap((votesWithComments: Vote[]) => {
+ expect(votesWithComments.length).toBe(2);
+ expect(votesWithComments.filter((v) => v.comment.text === commentOnVote1).length).toBe(1);
+ expect(votesWithComments.filter((v) => v.comment.text === commentOnVote2).length).toBe(1);
+ })
+ )
+ .subscribe({
+ error: (err) => {
+ logError('2.1 test the entire voting cycle ' + err);
+ done();
+ throw new Error('the voting cycle does not work');
+ },
+ complete: () => done()
+ });
+ }, 100000);
+ });
+});
+
+describe('redirect to radar page', () => {
+ beforeEach(() =>
+ TestBed.configureTestingModule({
+ imports: [HttpClientTestingModule]
+ })
+ );
+
+ it('should create proper query params for getting all blips', function() {
+ const service: BackendService = TestBed.get(BackendService);
+ const windowOpenSpy = spyOn(window, 'open');
+ service.url = 'service-url/';
+ environment.radarURL = 'radar-url/';
+ service.getBlipsForAllEvent({ siteName: 'site-name' });
+ expect(windowOpenSpy).toHaveBeenCalledWith(
+ 'radar-url/?title=site-name&sheetId=service-url%2Fvotes%2Fblips.csv%3FserviceUrl%3Dservice-url%2F%26radarUrl%3Dradar-url%2F%26type%3Dcsv',
+ '_blank'
+ );
+ });
+
+ it('should create title param with default sitename when site name not given in config', function() {
+ const service: BackendService = TestBed.get(BackendService);
+ const windowOpenSpy = spyOn(window, 'open');
+ service.url = 'service-url/';
+ environment.radarURL = 'radar-url/';
+ service.getBlipsForAllEvent({});
+ expect(windowOpenSpy).toHaveBeenCalledWith(
+ 'radar-url/?title=BUILD YOUR OWN RADAR&sheetId=service-url%2Fvotes%2Fblips.csv%3FserviceUrl%3Dservice-url%2F%26radarUrl%3Dradar-url%2F%26type%3Dcsv',
+ '_blank'
+ );
+ });
+
+ it('should create proper query params for getting blips for event', function() {
+ const service: BackendService = TestBed.get(BackendService);
+ const windowOpenSpy = spyOn(window, 'open');
+ service.url = 'service-url/';
+ environment.radarURL = 'radar-url/';
+ const votingEvent: VotingEvent = {
+ _id: '54ee1f2d33335326d70987df',
+ name: 'codemotion',
+ status: 'open',
+ round: 1,
+ creationTS: '2019-02-14T14:08:10.410Z'
+ };
+
+ service.getBlipsForSelectedEvent(votingEvent, {
+ siteName: 'site-name',
+ thresholdForRevote: 10
+ });
+ expect(windowOpenSpy).toHaveBeenCalledWith(
+ 'radar-url/?title=codemotion&subtitle=site-name&sheetId=service-url%2Fvotes%2F54ee1f2d33335326d70987df%2Fblips.csv%3FthresholdForRevote%3D10%26type%3Dcsv',
+ '_blank'
+ );
+ });
+
+ it('should create proper query params for getting blips for revote', function() {
+ const service: BackendService = TestBed.get(BackendService);
+ const windowOpenSpy = spyOn(window, 'open');
+ service.url = 'service-url';
+ environment.radarURL = 'radar-url/';
+ const votingEvent: VotingEvent = {
+ _id: '54ee1f2d33335326d70987df',
+ name: 'codemotion',
+ status: 'open',
+ round: 1,
+ creationTS: '2019-02-14T14:08:10.410Z'
+ };
+ service.techForRevote(votingEvent, {
+ siteName: 'site-name',
+ thresholdForRevote: 10
+ });
+ expect(windowOpenSpy).toHaveBeenCalledWith(
+ 'radar-url/?title=codemotion&subtitle=site-name&sheetId=service-urlvotes%2F54ee1f2d33335326d70987df%2Frevote%2Fblips.csv%3FthresholdForRevote%3D10%26type%3Dcsv',
+ '_blank'
+ );
+ });
+});
diff --git a/src/app/services/backend.service.ts b/src/app/services/backend.service.ts
new file mode 100644
index 0000000..3bbb775
--- /dev/null
+++ b/src/app/services/backend.service.ts
@@ -0,0 +1,428 @@
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+
+import { Observable, throwError } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+
+import { environment } from '../../environments/environment';
+import { ServiceNames } from './service-names';
+
+import { Technology } from '../models/technology';
+import { Vote } from '../models/vote';
+import { VotingEvent } from '../models/voting-event';
+import { VoteCredentials } from '../models/vote-credentials';
+import { Blip } from '../models/blip';
+import { ERRORS } from './errors';
+import { logError } from '../utils/utils';
+import { inspect } from 'util';
+
+interface BackEndError {
+ errorCode: string;
+ message: string;
+ mongoErrorCode: number;
+}
+interface RespFromBackend {
+ data: any;
+ error: BackEndError;
+ serviceName: string;
+ code: number;
+}
+// interface RespFromBackend {
+// data: T;
+// error: BackEndError;
+// serviceName: string;
+// code: number;
+// }
+
+@Injectable({
+ providedIn: 'root'
+})
+export class BackendService {
+ url = environment.serviceUrl;
+ private defaultSiteName = 'BUILD YOUR OWN RADAR';
+
+ constructor(private http: HttpClient) {}
+
+ getTechnologies(): Observable> {
+ const payload = this.buildPostPayloadForService(ServiceNames.getTechnologies);
+ return (
+ this.http
+ .post(this.url, payload)
+ // .post>>(url, payload)
+ .pipe(
+ map((resp: any) => {
+ return resp.data.technologies;
+ }),
+ catchError(this.handleError)
+ )
+ );
+ }
+
+ addTechnology(technology: Technology) {
+ const payload = this.buildPostPayloadForService(ServiceNames.addTechnology);
+ payload['technology'] = technology;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: RespFromBackend) => {
+ return this.handleReponseDefault(resp);
+ }),
+ catchError(this.handleError)
+ );
+ }
+ getTechnology(name: string) {
+ const payload = this.buildPostPayloadForService(ServiceNames.getTechnology);
+ payload['name'] = name;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: RespFromBackend) => {
+ return this.handleReponseDefault(resp);
+ }),
+ catchError(this.handleError)
+ );
+ }
+ updateTechnology(technology: Technology) {
+ const payload = this.buildPostPayloadForService(ServiceNames.updateTechnology);
+ payload['technology'] = technology;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: RespFromBackend) => {
+ return this.handleReponseDefault(resp);
+ }),
+ catchError(this.handleError)
+ );
+ }
+ deleteTechnology(_id: string) {
+ const payload = this.buildPostPayloadForService(ServiceNames.deleteTechnology);
+ payload['_id'] = _id;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: RespFromBackend) => {
+ return this.handleReponseDefault(resp);
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ hasAlreadyVoted(credentials: VoteCredentials): Observable {
+ const payload = this.buildPostPayloadForService(ServiceNames.hasAlreadyVoted);
+ // reduce the size of the payload
+ const _credentials = {
+ voterId: credentials.voterId,
+ votingEvent: {
+ _id: credentials.votingEvent._id
+ }
+ };
+ payload['credentials'] = _credentials;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: RespFromBackend) => {
+ return resp.data;
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ getVotes(votingEventId: string): Observable> {
+ const payload = this.buildPostPayloadForService(ServiceNames.getVotes);
+ payload['eventId'] = votingEventId;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: any) => {
+ return resp.data;
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ saveVote(votes: Array, credentials: VoteCredentials) {
+ const payload = this.buildPostPayloadForService(ServiceNames.saveVotes);
+ payload['votes'] = votes;
+ payload['credentials'] = credentials;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: RespFromBackend) => {
+ return this.handleReponseDefault(resp);
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ getVotesWithCommentsForTechAndEvent(technologyId: string, eventId: string) {
+ const payload = this.buildPostPayloadForService(ServiceNames.getVotesWithCommentsForTechAndEvent);
+ payload['technologyId'] = technologyId;
+ payload['eventId'] = eventId;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: any) => {
+ return resp.data;
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ // getAggregatedVotes(votingEvent: VotingEvent): Observable> {
+ // const payload = this.buildPostPayloadForService(ServiceNames.aggregateVotes);
+ // payload['votingEvent'] = votingEvent;
+ // return this.http
+ // .post(this.url, payload)
+ // .pipe(
+ // map((resp: any) => {
+ // return resp.data;
+ // }),
+ // catchError(this.handleError),
+ // );
+ // }
+
+ calculateBlips(votingEvent: VotingEvent, thresholdForRevote?: number): Observable> {
+ const payload = this.buildPostPayloadForService(ServiceNames.calculateBlips);
+ // reduce the size of the payload
+ const _votingEvent = { _id: votingEvent._id };
+ payload['votingEvent'] = _votingEvent;
+ if (thresholdForRevote) {
+ payload['thresholdForRevote'] = thresholdForRevote;
+ }
+ return this.http.post(this.url, payload).pipe(
+ map((resp: any) => {
+ return this.handleReponseDefault(resp);
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ calculateBlipsFromAllEvents() {
+ const payload = this.buildPostPayloadForService(ServiceNames.calculateBlipsFromAllEvents);
+ return this.http.post(this.url, payload).pipe(
+ map((resp: any) => {
+ return this.handleReponseDefault(resp);
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ openForRevote(votingEvent: VotingEvent): Observable> {
+ const payload = this.buildPostPayloadForService(ServiceNames.openForRevote);
+ // reduce the size of the payload to the bare minimum
+ payload['_id'] = votingEvent._id;
+ payload['round'] = votingEvent.round;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: any) => {
+ return resp.data;
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ closeForRevote(votingEvent: VotingEvent): Observable> {
+ const payload = this.buildPostPayloadForService(ServiceNames.closeForRevote);
+ // reduce the size of the payload to the bare minimum
+ payload['_id'] = votingEvent._id;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: any) => {
+ return resp.data;
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ getVotingEvents(params?: { all: boolean }): Observable> {
+ const payload = this.buildPostPayloadForService(ServiceNames.getVotingEvents);
+ if (params && params.all) {
+ payload['all'] = true;
+ }
+ return this.http.post(this.url, payload).pipe(
+ map((resp: any) => {
+ return this.handleReponseDefault(resp);
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ getVotingEvent(eventId: string): Observable {
+ const payload = this.buildPostPayloadForService(ServiceNames.getVotingEvent);
+ payload['_id'] = eventId;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: any) => {
+ return this.handleReponseDefault(resp);
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ createVotingEvent(name: string) {
+ const payload = this.buildPostPayloadForService(ServiceNames.createVotingEvent);
+ payload['name'] = name;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: RespFromBackend) => {
+ return resp;
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ openVotingEvent(id: string) {
+ const payload = this.buildPostPayloadForService(ServiceNames.openVotingEvent);
+ payload['_id'] = id;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: any) => {
+ return resp.data;
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ closeVotingEvent(id: string) {
+ const payload = this.buildPostPayloadForService(ServiceNames.closeVotingEvent);
+ payload['_id'] = id;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: any) => {
+ return resp.data;
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ cancelVotingEvent(_id: string, hard?: boolean) {
+ const payload = this.buildPostPayloadForService(ServiceNames.cancelVotingEvent);
+ payload['_id'] = _id;
+ if (hard) {
+ payload['hard'] = hard;
+ }
+ return this.http.post(this.url, payload).pipe(catchError(this.handleError));
+ }
+
+ addTechnologyToVotingEvent(_id: string, technology: Technology) {
+ const payload = this.buildPostPayloadForService(ServiceNames.addNewTechnologyToEvent);
+ payload['_id'] = _id;
+ payload['technology'] = technology;
+ return this.http.post(this.url, payload).pipe(catchError(this.handleError));
+ }
+
+ getVoters(votingEvent: VotingEvent) {
+ const payload = this.buildPostPayloadForService(ServiceNames.getVoters);
+ payload['votingEvent'] = votingEvent;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: any) => {
+ return resp.data;
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ authenticate(user: string, pwd: string) {
+ const payload = this.buildPostPayloadForService(ServiceNames.authenticate);
+ payload['user'] = user;
+ payload['pwd'] = pwd;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: any) => {
+ const r = this.handleReponseDefault(resp);
+ return r;
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ getConfiguration(user?: string) {
+ const payload = this.buildPostPayloadForService(ServiceNames.getConfiguration);
+ payload['user'] = user;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: any) => {
+ return this.handleReponseDefault(resp);
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ saveLogInfo(reason: string, logInfo: string) {
+ const payload = this.buildPostPayloadForService(ServiceNames.saveLogInfo);
+ payload['logInfo'] = logInfo;
+ payload['reason'] = reason;
+ return this.http.post(this.url, payload).pipe(
+ map((resp: any) => {
+ return this.handleReponseDefault(resp);
+ }),
+ catchError(this.handleError)
+ );
+ }
+
+ private handleReponseDefault(resp: RespFromBackend) {
+ if (resp.error) {
+ throw resp.error;
+ }
+ return resp.data;
+ }
+
+ private handleError(error: any) {
+ let _err;
+ let errorMessage = 'Something bad happened; please try again later. You may take a look at the browser console to get a hint.';
+ if (error.status === 0) {
+ logError('Server is unreacheable ...');
+ logError('The error details: ' + inspect(error));
+ return throwError({ message: 'Server is unreacheable ...', errorCode: ERRORS.serverUnreacheable });
+ } else if (error.error instanceof ErrorEvent) {
+ // A client-side or network error occurred. Handle it accordingly.
+ errorMessage = 'An error occurred: ' + error.error.message;
+ logError(errorMessage);
+ _err = errorMessage;
+ }
+ // an error with 'errorCode' is an error raised from our application logic
+ else if (error.errorCode) {
+ errorMessage = 'An error occurred: ' + error.message;
+ if (error.serviceName) {
+ errorMessage = errorMessage + ' on service ' + error.serviceName;
+ }
+ logError(errorMessage);
+ _err = error;
+ }
+ // if the error contains a message and a stack than it comes from the backend
+ else if (error.message && error.stack) {
+ errorMessage = 'An error on the backend occurred: ' + error.message;
+ if (error.serviceName) {
+ errorMessage = errorMessage + ' on service ' + error.serviceName;
+ }
+ errorMessage = errorMessage + '\n' + 'STACK TRACE' + '\n' + error.stack;
+ logError(errorMessage);
+ _err = errorMessage;
+ } else if (error.message) {
+ errorMessage = 'An error occurred: ' + error.message;
+ if (error.serviceName) {
+ errorMessage = errorMessage + ' on service ' + error.serviceName;
+ }
+ logError(errorMessage);
+ _err = errorMessage;
+ } else {
+ // The backend returned an unsuccessful response code.
+ // The response body may contain clues as to what went wrong,
+ errorMessage = `Backend returned code ${error.status}, ` + `body was: ${JSON.stringify(error)}`;
+ logError(errorMessage);
+ _err = errorMessage;
+ }
+ // tslint:disable-next-line:no-console
+ // logErrortrace();
+ // return an ErrorObservable with a user-facing error message
+ return throwError(_err);
+ }
+
+ private buildPostPayloadForService(serviceName: ServiceNames) {
+ const service = ServiceNames[serviceName];
+ return { service };
+ }
+
+ getBlipsForSelectedEvent(votingEvent: VotingEvent, config: any) {
+ const subtitle = config.siteName || this.defaultSiteName;
+ const backendUrlWithParams = encodeURIComponent(
+ this.url + 'votes/' + votingEvent._id + '/blips.csv?thresholdForRevote=' + config.thresholdForRevote + '&type=csv'
+ );
+ const radarUrl = environment.radarURL + '?title=' + votingEvent.name + '&subtitle=' + subtitle + '&sheetId=' + backendUrlWithParams;
+ window.open(radarUrl, '_blank');
+ }
+
+ getBlipsForAllEvent(config: any) {
+ const title = config.siteName || this.defaultSiteName;
+ const backendUrlWithParams = encodeURIComponent(
+ this.url + 'votes/blips.csv?serviceUrl=' + this.url + '&radarUrl=' + environment.radarURL + '&type=csv'
+ );
+ const radarURL = environment.radarURL + '?title=' + title + '&sheetId=' + backendUrlWithParams;
+ window.open(radarURL, '_blank');
+ }
+
+ techForRevote(votingEvent: VotingEvent, config: any) {
+ const subtitle = config.siteName || this.defaultSiteName;
+ const backendUrlWithParams = encodeURIComponent(
+ this.url + 'votes/' + votingEvent._id + '/revote/blips.csv?thresholdForRevote=' + config.thresholdForRevote + '&type=csv'
+ );
+ const radarUrl = environment.radarURL + '?title=' + votingEvent.name + '&subtitle=' + subtitle + '&sheetId=' + backendUrlWithParams;
+ window.open(radarUrl, '_blank');
+ }
+}
diff --git a/src/app/services/configuration.service.spec.ts b/src/app/services/configuration.service.spec.ts
new file mode 100644
index 0000000..bbdbfad
--- /dev/null
+++ b/src/app/services/configuration.service.spec.ts
@@ -0,0 +1,24 @@
+import { TestBed } from '@angular/core/testing';
+import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
+
+import { ConfigurationService } from './configuration.service';
+
+describe('ConfigurationService', () => {
+ let httpTestingController: HttpTestingController;
+
+ beforeEach(() => {
+ TestBed.configureTestingModule({
+ imports: [
+ HttpClientTestingModule
+ ],
+ });
+
+ // Inject the http service and test controller for each test
+ httpTestingController = TestBed.get(HttpTestingController);
+ });
+
+ it('should be created', () => {
+ const service: ConfigurationService = TestBed.get(ConfigurationService);
+ expect(service).toBeTruthy();
+ });
+});
diff --git a/src/app/services/configuration.service.ts b/src/app/services/configuration.service.ts
new file mode 100644
index 0000000..deacee5
--- /dev/null
+++ b/src/app/services/configuration.service.ts
@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+
+import {BackendService} from '../services/backend.service';
+import { shareReplay } from 'rxjs/operators';
+import { Observable } from 'rxjs';
+
+@Injectable({
+ providedIn: 'root'
+})
+export class ConfigurationService {
+ private defaultConfiguration$: Observable;
+ private usersConfigurations$ = new Map>();
+
+ constructor(
+ private backend: BackendService,
+ ) { }
+
+ defaultConfiguration() {
+ if (!this.defaultConfiguration$) {
+ this.defaultConfiguration$ = this.backend.getConfiguration()
+ .pipe(
+ shareReplay(1)
+ );
+ }
+ return this.defaultConfiguration$;
+ }
+ configurationForUser(user: string) {
+ if (!this.usersConfigurations$.get(user)) {
+ const userConfig$ = this.backend.getConfiguration(user)
+ .pipe(
+ shareReplay(1)
+ );
+ this.usersConfigurations$.set(user, userConfig$);
+ }
+ return this.usersConfigurations$.get(user);
+ }
+
+}
diff --git a/src/app/services/error.service.spec.ts b/src/app/services/error.service.spec.ts
new file mode 100644
index 0000000..d7f7396
--- /dev/null
+++ b/src/app/services/error.service.spec.ts
@@ -0,0 +1,15 @@
+import { TestBed } from '@angular/core/testing';
+
+import { ErrorService } from './error.service';
+import { HttpClientModule } from '@angular/common/http';
+
+describe('ErrorService', () => {
+ beforeEach(() => TestBed.configureTestingModule({
+ imports: [HttpClientModule]
+ }));
+
+ it('should be created', () => {
+ const service: ErrorService = TestBed.get(ErrorService);
+ expect(service).toBeTruthy();
+ });
+});
diff --git a/src/app/services/error.service.ts b/src/app/services/error.service.ts
new file mode 100644
index 0000000..c4e44b8
--- /dev/null
+++ b/src/app/services/error.service.ts
@@ -0,0 +1,69 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { ServiceNames } from './service-names';
+import { HandleError, HttpErrorHandler } from '../shared/http-error-handler/http-error-handler.service';
+import { HttpClient } from '@angular/common/http';
+import { environment } from '../../environments/environment';
+
+@Injectable({
+ providedIn: 'root'
+})
+export class ErrorService {
+ private error$ = new BehaviorSubject(new Error('Unknown Error - try to check on the browser console for more details'));
+
+ private readonly handleError: HandleError;
+ private defaultMessage = 'Something went wrong; Please try again';
+
+ constructor(private http: HttpClient, httpErrorHandler: HttpErrorHandler) {
+ this.handleError = httpErrorHandler.createHandleError('ErrorsService');
+ }
+
+ private errorMessage: string;
+
+ getError() {
+ return this.error$.asObservable();
+ }
+ setError(error: Error) {
+ this.error$.next(error);
+ }
+
+ setErrorMessage(error: Error) {
+ if (error.message) {
+ this.errorMessage = error.message;
+ }
+
+ this.errorMessage = "Error occurred, please try again"
+ }
+
+ getErrorMessage() {
+ return this.errorMessage;
+ }
+
+ saveErrorInfo(reason: string, logInfo: string) {
+ const payload = {
+ service: ServiceNames[ServiceNames.saveLogInfo],
+ logInfo: logInfo,
+ reason: reason,
+ };
+
+ this.http
+ .post(environment.serviceUrl, payload)
+ .pipe(
+ catchError(this.handleError(this.defaultMessage)),
+ ).subscribe();
+ }
+
+ getErrorMessageHtml() {
+ return this.error$
+ .pipe(
+ map(e => {
+ if (e.message) {
+ return e.message;
+ }
+ return e;
+ })
+ );
+ }
+
+}
diff --git a/src/app/services/errors.ts b/src/app/services/errors.ts
new file mode 100644
index 0000000..874b52a
--- /dev/null
+++ b/src/app/services/errors.ts
@@ -0,0 +1,8 @@
+
+export const ERRORS = {
+ votingEventAlreadyPresent: 'V-E-01',
+ voteAlreadyPresent: 'V-01',
+ pwdInvalid: 'A-01',
+ userUnknown: 'A-02',
+ serverUnreacheable: 'S-01',
+};
diff --git a/src/app/services/events.service.spec.ts b/src/app/services/events.service.spec.ts
new file mode 100644
index 0000000..92eb5f9
--- /dev/null
+++ b/src/app/services/events.service.spec.ts
@@ -0,0 +1,175 @@
+import { TestBed } from '@angular/core/testing';
+import { HttpClient } from '@angular/common/http';
+import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
+import { EventsService } from './events.service';
+import { HttpErrorHandler } from '../shared/http-error-handler/http-error-handler.service';
+import { environment } from '../../environments/environment';
+import { VotingEvent } from '../models/voting-event';
+
+describe('EventsService', () => {
+ let httpClient: HttpClient;
+ let httpTestingController: HttpTestingController;
+ const url = environment.serviceUrl;
+
+ const eventId = 'myEventId';
+ const eventName = 'myEvent';
+ const myEvent: VotingEvent = {
+ _id: eventId,
+ name: eventName,
+ status: 'open',
+ creationTS: '2019-03-30T14:59:18.334Z',
+ round: 2,
+ };
+ const response = { data: myEvent };
+
+ beforeEach(() => {
+ TestBed.configureTestingModule({
+ imports: [ HttpClientTestingModule ],
+ providers: [EventsService, HttpErrorHandler]
+ });
+
+ httpClient = TestBed.get(HttpClient);
+ httpTestingController = TestBed.get(HttpTestingController);
+ });
+
+ afterEach(() => {
+ httpTestingController.verify();
+ });
+
+ it('sets and gets the selected event', () => {
+ const service: EventsService = TestBed.get(EventsService);
+
+ service.setSelectedEvent(myEvent);
+
+ expect(service.getSelectedEvent()).toEqual(myEvent);
+ });
+
+ it('fetches the Voting Event', () => {
+ const service: EventsService = TestBed.get(EventsService);
+
+ service.fetchVotingEvent(eventId).subscribe(
+ event => expect(event.name).toEqual(eventName),
+ fail
+ );
+
+ const req = httpTestingController.expectOne(url);
+ expect(req.request.method).toEqual('POST');
+ expect(req.request.body.service).toEqual('getVotingEvent');
+ expect(req.request.body._id).toEqual(eventId);
+
+ req.flush(response);
+ });
+
+ it('gets all the events', () => {
+ const service: EventsService = TestBed.get(EventsService);
+
+ service.getEvents().subscribe(
+ event => expect(event[0].name).toEqual(eventName),
+ fail
+ );
+
+ const req = httpTestingController.expectOne(url);
+ expect(req.request.method).toEqual('POST');
+ expect(req.request.body.service).toEqual('getVotingEvents');
+
+ req.flush({data: [myEvent]});
+ });
+
+ it('creates the events for voting', () => {
+ const service: EventsService = TestBed.get(EventsService);
+
+ service.createVotingEvent('myEvent').subscribe(
+ (event: any) => { expect(event.name).toEqual(eventName);},
+ fail
+ );
+
+ const req = httpTestingController.expectOne(url);
+ expect(req.request.method).toEqual('POST');
+ expect(req.request.body.service).toEqual('createVotingEvent');
+ expect(req.request.body.name).toEqual('myEvent');
+
+ req.flush(response);
+ });
+
+ it('opens the events for voting', () => {
+ const service: EventsService = TestBed.get(EventsService);
+
+ service.openVotingEvent(eventId).subscribe(
+ (event: any) => { expect(event.name).toEqual(eventName);},
+ fail
+ );
+
+ const req = httpTestingController.expectOne(url);
+ expect(req.request.method).toEqual('POST');
+ expect(req.request.body.service).toEqual('openVotingEvent');
+ expect(req.request.body._id).toEqual(eventId);
+
+ req.flush(response);
+ });
+
+ it('closes the events for voting', () => {
+ const service: EventsService = TestBed.get(EventsService);
+
+ service.closeVotingEvent(eventId).subscribe(
+ (event: any) => { expect(event.name).toEqual(eventName);},
+ fail
+ );
+
+ const req = httpTestingController.expectOne(url);
+ expect(req.request.method).toEqual('POST');
+ expect(req.request.body.service).toEqual('closeVotingEvent');
+ expect(req.request.body._id).toEqual(eventId);
+
+ req.flush(response);
+ });
+
+ it('cancels the events', () => {
+ const service: EventsService = TestBed.get(EventsService);
+
+ service.cancelVotingEvent(eventName).subscribe(
+ (event: any) => { expect(event.name).toEqual(eventName);},
+ fail
+ );
+
+ const req = httpTestingController.expectOne(url);
+ expect(req.request.method).toEqual('POST');
+ expect(req.request.body.service).toEqual('cancelVotingEvent');
+ expect(req.request.body.name).toEqual(eventName);
+ expect(req.request.body.hard).toEqual(false);
+
+ req.flush(response);
+ });
+
+ it('opens the events for revote', () => {
+ const service: EventsService = TestBed.get(EventsService);
+
+ service.openForRevote(myEvent).subscribe(
+ (event: any) => { expect(event.name).toEqual(eventName);},
+ fail
+ );
+
+ const req = httpTestingController.expectOne(url);
+ expect(req.request.method).toEqual('POST');
+ expect(req.request.body.service).toEqual('openForRevote');
+ expect(req.request.body._id).toEqual(eventId);
+ expect(req.request.body.round).toEqual(2);
+
+ req.flush(response);
+ });
+
+ it('closes the events for revote', () => {
+ const service: EventsService = TestBed.get(EventsService);
+
+ service.closeForRevote(myEvent).subscribe(
+ (event: any) => { expect(event.name).toEqual(eventName);},
+ fail
+ );
+
+ const req = httpTestingController.expectOne(url);
+ expect(req.request.method).toEqual('POST');
+ expect(req.request.body.service).toEqual('closeForRevote');
+ expect(req.request.body._id).toEqual(eventId);
+
+ req.flush(response);
+ });
+});
diff --git a/src/app/services/events.service.ts b/src/app/services/events.service.ts
new file mode 100644
index 0000000..707c23a
--- /dev/null
+++ b/src/app/services/events.service.ts
@@ -0,0 +1,116 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ServiceNames } from './service-names';
+import { catchError, map } from 'rxjs/operators';
+import { environment } from '../../environments/environment';
+import { HttpClient } from '@angular/common/http';
+import { HandleError, HttpErrorHandler } from '../shared/http-error-handler/http-error-handler.service';
+import { VotingEvent } from '../models/voting-event';
+import { Blip } from '../models/blip';
+import { getDataFrom } from '../utils/response.util';
+
+
+@Injectable({
+ providedIn: 'root'
+})
+export class EventsService {
+ private readonly handleError: HandleError;
+ private defaultMessage = 'Something went wrong; Please try again';
+
+ private selectedEvent: VotingEvent;
+
+ constructor(private http: HttpClient, httpErrorHandler: HttpErrorHandler) {
+ this.handleError = httpErrorHandler.createHandleError('EventsService');
+ }
+
+ setSelectedEvent(event: VotingEvent) {
+ this.selectedEvent = event;
+ }
+
+ getSelectedEvent() {
+ return this.selectedEvent;
+ }
+
+
+ fetchVotingEvent(eventId: string): Observable {
+ const payload = {
+ service: ServiceNames[ServiceNames.getVotingEvent],
+ _id: eventId
+ };
+
+ return this.httpPost(payload);
+ }
+
+ getEvents(): Observable> {
+ const payload = {
+ service: ServiceNames[ServiceNames.getVotingEvents]
+ };
+
+ return this.httpPost(payload);
+ }
+
+ createVotingEvent(name: string) {
+ const payload = {
+ service: ServiceNames[ServiceNames.createVotingEvent],
+ name: name
+ };
+
+ return this.httpPost(payload);
+ }
+
+ openVotingEvent(id: string) {
+ const payload = {
+ service: ServiceNames[ServiceNames.openVotingEvent],
+ _id: id
+ };
+
+ return this.httpPost(payload);
+ }
+
+ closeVotingEvent(id: string) {
+ const payload = {
+ service: ServiceNames[ServiceNames.closeVotingEvent],
+ _id: id
+ };
+
+ return this.httpPost(payload);
+ }
+
+ cancelVotingEvent(name: string, hard: boolean = false) {
+ const payload = {
+ service: ServiceNames[ServiceNames.cancelVotingEvent],
+ name: name,
+ hard: hard
+ };
+
+ return this.httpPost(payload);
+ }
+
+ openForRevote(votingEvent: VotingEvent): Observable> {
+ const payload = {
+ service: ServiceNames[ServiceNames.openForRevote],
+ _id: votingEvent._id,
+ round: votingEvent.round
+ };
+
+ return this.httpPost(payload);
+ }
+
+ closeForRevote(votingEvent: VotingEvent): Observable> {
+ const payload = {
+ service: ServiceNames[ServiceNames.closeForRevote],
+ _id: votingEvent._id
+ };
+
+ return this.httpPost(payload);
+ }
+
+ httpPost(payload: any): Observable {
+ return this.http
+ .post(environment.serviceUrl, payload)
+ .pipe(
+ map((resp: any) => getDataFrom(resp)),
+ catchError(this.handleError(this.defaultMessage))
+ );
+ }
+}
diff --git a/src/app/services/service-names.ts b/src/app/services/service-names.ts
new file mode 100644
index 0000000..b6bc224
--- /dev/null
+++ b/src/app/services/service-names.ts
@@ -0,0 +1,27 @@
+export enum ServiceNames {
+ getTechnologies,
+ addTechnology,
+ getTechnology,
+ updateTechnology,
+ deleteTechnology,
+ hasAlreadyVoted,
+ getVotes,
+ saveVotes,
+ aggregateVotes,
+ getVotesWithCommentsForTechAndEvent,
+ getVotingEvents,
+ getVotingEvent,
+ createVotingEvent,
+ openVotingEvent,
+ closeVotingEvent,
+ cancelVotingEvent,
+ addNewTechnologyToEvent,
+ getVoters,
+ calculateBlips,
+ calculateBlipsFromAllEvents,
+ openForRevote,
+ closeForRevote,
+ getConfiguration,
+ authenticate,
+ saveLogInfo
+}
diff --git a/src/app/shared/http-error-handler/http-error-handler.service.spec.ts b/src/app/shared/http-error-handler/http-error-handler.service.spec.ts
new file mode 100644
index 0000000..b1b20fa
--- /dev/null
+++ b/src/app/shared/http-error-handler/http-error-handler.service.spec.ts
@@ -0,0 +1,57 @@
+import { TestBed } from '@angular/core/testing';
+
+import { HttpErrorHandler } from './http-error-handler.service';
+import { HttpErrorResponse } from '@angular/common/http';
+import { HttpClientTestingModule } from '@angular/common/http/testing';
+
+describe('HttpErrorHandler', () => {
+ beforeEach(() => TestBed.configureTestingModule({
+ imports: [HttpClientTestingModule],
+ providers: [HttpErrorHandler]
+ }));
+
+ it('should be created', () => {
+ const service: HttpErrorHandler = TestBed.get(HttpErrorHandler);
+ expect(service).toBeTruthy();
+ });
+
+ it('handles client side errors', () => {
+ let returnedValue = '';
+ const service: HttpErrorHandler = TestBed.get(HttpErrorHandler);
+ const handler = service.handleError('Test', 'Dummy default data');
+
+ const errEvent: ErrorEvent = document.createEvent('ErrorEvent');
+ const httpErrorRes = new HttpErrorResponse({ error: errEvent });
+ handler(httpErrorRes).subscribe(value => {
+ returnedValue = value;
+ });
+
+ expect(returnedValue).toBe('Dummy default data');
+ });
+
+ it('handles backend errors', () => {
+ let returnedValue = '';
+ const service: HttpErrorHandler = TestBed.get(HttpErrorHandler);
+ const handler = service.handleError('Test', 'Dummy default data');
+
+ const httpErrorRes = new HttpErrorResponse({});
+ handler(httpErrorRes).subscribe(value => {
+ returnedValue = value;
+ });
+
+ expect(returnedValue).toBe('Dummy default data');
+ });
+
+ it('creates a handler', () => {
+ let returnedValue = '';
+ const service: HttpErrorHandler = TestBed.get(HttpErrorHandler);
+ const handler = service.createHandleError('Test')('Dummy default data');
+
+ const httpErrorRes = new HttpErrorResponse({});
+ handler(httpErrorRes).subscribe(value => {
+ returnedValue = value;
+ });
+
+ expect(returnedValue).toBe('Dummy default data');
+ });
+});
diff --git a/src/app/shared/http-error-handler/http-error-handler.service.ts b/src/app/shared/http-error-handler/http-error-handler.service.ts
new file mode 100644
index 0000000..cd2632f
--- /dev/null
+++ b/src/app/shared/http-error-handler/http-error-handler.service.ts
@@ -0,0 +1,25 @@
+import { Injectable } from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+import { Observable, of } from 'rxjs';
+import { logError } from 'src/app/utils/utils';
+
+export type HandleError = (result?: T) => (error: HttpErrorResponse) => Observable;
+
+@Injectable({
+ providedIn: 'root'
+})
+export class HttpErrorHandler {
+ createHandleError = (serviceName = '') => (result = {} as T) => this.handleError(serviceName, result);
+
+ handleError(serviceName = '', result = {} as T) {
+ return (error: HttpErrorResponse): Observable => {
+ if (error.error instanceof ErrorEvent) {
+ logError(`An error occurred for ${serviceName} : ${error.error.message}`);
+ } else {
+ logError(`Backend returned code ${error.status} for ${serviceName}, body was: ${error.error}`);
+ }
+
+ return of(result);
+ };
+ }
+}
diff --git a/src/app/styles/abstracts/_functions.scss b/src/app/styles/abstracts/_functions.scss
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/styles/abstracts/_mixins.scss b/src/app/styles/abstracts/_mixins.scss
new file mode 100644
index 0000000..09b7c69
--- /dev/null
+++ b/src/app/styles/abstracts/_mixins.scss
@@ -0,0 +1,35 @@
+@mixin clearfix {
+ &::after {
+ content: "";
+ display: table;
+ clear: both;
+ }
+}
+
+@mixin absCenter {
+ position: absolute;
+ top: 50%;
+ left: 50%;
+ transform: translate(-50%, -50%);
+}
+
+@mixin byor-input {
+ display: inline-block;
+ height: 3.8rem;
+ padding: .5rem 1.5rem;
+ margin-bottom: .5rem;
+ font-size: 1.6rem;
+ border-width: 0;
+ border-radius: 0;
+
+ color: #666;
+ background-color: #ebebeb;
+ border-bottom: 2px solid #d7d7d7;
+
+ &:focus {
+ -webkit-box-shadow: inset 0 0 1px #000;
+ box-shadow: inset 0 0 1px #000;
+ outline: 0;
+ border-color: #666;
+ }
+}
diff --git a/src/app/styles/abstracts/_variables.scss b/src/app/styles/abstracts/_variables.scss
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/styles/base/_animations.scss b/src/app/styles/base/_animations.scss
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/styles/base/_typography.scss b/src/app/styles/base/_typography.scss
new file mode 100644
index 0000000..e69de29
diff --git a/src/app/styles/base/_utilities.scss b/src/app/styles/base/_utilities.scss
new file mode 100644
index 0000000..e0b50ce
--- /dev/null
+++ b/src/app/styles/base/_utilities.scss
@@ -0,0 +1,19 @@
+.u-center-text {
+ text-align: center;
+}
+
+.u-margin-bottom-big {
+ margin-bottom: 8rem;
+}
+
+.u-margin-bottom-medium {
+ margin-bottom: 4rem;
+}
+
+.u-margin-bottom-small {
+ margin-bottom: 1.5rem;
+}
+
+.u-margin-top-big {
+ margin-top: 8rem;
+}
diff --git a/src/app/styles/theme/_colors.scss b/src/app/styles/theme/_colors.scss
new file mode 100644
index 0000000..b6d445c
--- /dev/null
+++ b/src/app/styles/theme/_colors.scss
@@ -0,0 +1,18 @@
+$green: #86b782;
+$blue: #1ebccd;
+$orange: #f38a3e;
+$violet: #b32059;
+$pink: #ee0b77;
+
+$grey-darkest: #bababa;
+$grey-dark: #cacaca;
+$grey-even-darker: #d7d7d7;
+$grey: #dadada;
+$grey-light: #eee;
+$grey-lightest: #fafafa;
+
+$white: #fff;
+$black: #000;
+$grey-text: rgb(51, 51, 51);
+
+$grey-alpha-03: rgba(255, 255, 255, 0.3);
diff --git a/src/app/utils/response.util.spec.ts b/src/app/utils/response.util.spec.ts
new file mode 100644
index 0000000..086946d
--- /dev/null
+++ b/src/app/utils/response.util.spec.ts
@@ -0,0 +1,52 @@
+import { getDataFrom } from './response.util';
+import { of } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+describe('Response util', () => {
+ describe('when data is present', () => {
+ const resp = { data: 'text data' };
+
+ it('return data from response', () => {
+ expect(getDataFrom(resp)).toBe('text data');
+ });
+
+ it('provides to the invoking observable', () => {
+ const obs = of(resp);
+
+ return obs.pipe(
+ map(res => getDataFrom(res))
+ ).subscribe(
+ (text) => {
+ expect(text).toBe('text data');
+ })
+ });
+ });
+
+ describe('when data is not present', () => {
+ it('throws an error', () => {
+ expect(getDataFrom).toThrowError('No data found in response');
+ });
+
+ it('makes observable to throw error', () => {
+ return of({})
+ .pipe(
+ map(res => getDataFrom(res))
+ )
+ .subscribe(
+ () => { expect(true).toEqual(false); },
+ (error1 => { expect(error1.message).toEqual('No data found in response')})
+ )
+ });
+
+ it('makes observable to throw error on error', () => {
+ return of({error: {message : 'no data'}})
+ .pipe(
+ map(res => getDataFrom(res))
+ )
+ .subscribe(
+ () => { expect(true).toEqual(false); },
+ (error1 => { expect(error1.message).toEqual('no data')})
+ )
+ });
+ });
+});
diff --git a/src/app/utils/response.util.ts b/src/app/utils/response.util.ts
new file mode 100644
index 0000000..e2b6636
--- /dev/null
+++ b/src/app/utils/response.util.ts
@@ -0,0 +1,11 @@
+export function getDataFrom(resp) {
+ if (resp && resp.error) {
+ throw resp.error;
+ }
+
+ if (!(resp && resp.data)) {
+ throw new Error("No data found in response");
+ }
+
+ return resp.data;
+}
diff --git a/src/app/utils/utils.spec.ts b/src/app/utils/utils.spec.ts
new file mode 100644
index 0000000..3d0d620
--- /dev/null
+++ b/src/app/utils/utils.spec.ts
@@ -0,0 +1,75 @@
+
+import {domainName, googleSheetId, integer, floating} from './utils';
+
+describe('1.1 domainName function', () => {
+
+ it('should find the domain name', () => {
+ const domain = 'https://docs.google.com/spreadsheets/d/1waDG0_W3-yNiAaUfxcZhTKvl7AUCgXwQw8mdPjCz86U/edit#gid=0';
+ const name = domainName(domain);
+ expect(name).toEqual('docs.google.com');
+ });
+
+ it('should NOT find the domain name, because the string does not contain a domain name', () => {
+ const domain = 'I do not contain a domain name';
+ const name = domainName(domain);
+ expect(name).toBeNull();
+ });
+
+});
+
+describe('1.2 googleSheetId function', () => {
+
+ it('returns the google sheet id out of the url reference', () => {
+ const sheetId = '1waDG0_W3-yNiAaUfxcZhTKvl7AUCgXwQw8mdPjCz86U';
+ const url = 'https://docs.google.com/spreadsheets/d/' + sheetId + '/edit#gid=0';
+ const caclulatedSheetId = googleSheetId(url);
+ expect(caclulatedSheetId).toEqual(sheetId);
+ });
+
+ it('returns the google sheet id passed as input with no specific calculation', () => {
+ const sheetId = '1waDG0_W3-yNiAaUfxcZhTKvl7AUCgXwQw8mdPjCz86U';
+ const caclulatedSheetId = googleSheetId(sheetId);
+ expect(caclulatedSheetId).toEqual(sheetId);
+ });
+
+});
+
+describe('1.3 integer function', () => {
+
+ it('returns an integer between min and max', () => {
+ const min = 3;
+ const max = 10;
+ const randomInteger = integer(min, max);
+ expect(randomInteger).toBeGreaterThanOrEqual(min);
+ expect(randomInteger).toBeLessThanOrEqual(max);
+ });
+
+ it('returns an integer which is equal to min, since min is set equal to max', () => {
+ const min = 5;
+ const max = 5;
+ const randomInteger = integer(min, max);
+ expect(randomInteger).toBe(min);
+ });
+
+ it('throws an exception since min is greater than max', () => {
+ const min = 6;
+ const max = 1;
+ expect(() => integer(min, max)).toThrowError();
+ });
+
+});
+
+describe('1.4 floating function', () => {
+
+ it('returns a floating number with a certain number of digits precision', () => {
+ const min = 10;
+ const max = 100;
+ const fixed = 3;
+ const randomFloat = floating(min, max, fixed);
+ const decimalPart = (randomFloat + '').split('.')[1];
+ expect(randomFloat).toBeGreaterThanOrEqual(min);
+ expect(randomFloat).toBeLessThanOrEqual(max);
+ expect(decimalPart.length).toBeLessThanOrEqual(fixed);
+ });
+
+});
diff --git a/src/app/utils/utils.ts b/src/app/utils/utils.ts
new file mode 100644
index 0000000..80fafab
--- /dev/null
+++ b/src/app/utils/utils.ts
@@ -0,0 +1,55 @@
+import { environment } from 'src/environments/environment';
+
+export function domainName(url) {
+ const search = /.+:\/\/([^\/]+)/;
+ const match = search.exec(decodeURIComponent(url.replace(/\+/g, ' ')));
+ return match == null ? null : match[1];
+}
+
+export function googleSheetId(googleSheetReference: string) {
+ const matches = googleSheetReference.match('https:\\/\\/docs.google.com\\/spreadsheets\\/d\\/(.*?)($|\\/$|\\/.*|\\?.*)');
+ return matches !== null ? matches[1] : googleSheetReference;
+}
+
+export function integer(min: number, max: number) {
+ if (min > max) {
+ throw new Error('Min cannot be greater than Max.');
+ }
+ return Math.floor(Math.random() * (max - min + 1) + min);
+}
+
+export function floating(min: number, max: number, fixed: number) {
+ const MAX_INT = 9007199254740992;
+ const fixedPow = Math.pow(10, fixed);
+
+ const num = integer(min * fixedPow, max * fixedPow);
+ const num_fixed = (num / fixedPow).toFixed(fixed);
+
+ return parseFloat(num_fixed);
+}
+
+export const _log = (message: string, level?: string) => {
+ const levels = { ERROR: -1, INFO: 0, WARNING: 2, DEBUG: 3, TRACE: 4 };
+ const sysLevel = environment.traceLevel || 'INFO';
+ const msgLevel = level || 'INFO';
+ const msgOutput = '-->[' + msgLevel + '] ' + message;
+ if (levels[sysLevel] >= levels[msgLevel]) {
+ if (msgLevel === 'ERROR') console.error(msgOutput);
+ else console.log(msgOutput);
+ }
+};
+export const logError = (message: string) => {
+ _log(message, 'ERROR');
+};
+export const logInfo = (message: string) => {
+ _log(message, 'INFO');
+};
+export const logWarning = (message: string) => {
+ _log(message, 'WARNING');
+};
+export const logDebug = (message: string) => {
+ _log(message, 'DEBUG');
+};
+export const logTrace = (message: string) => {
+ _log(message, 'TRACE');
+};
diff --git a/src/app/version.ts b/src/app/version.ts
new file mode 100644
index 0000000..adadbc5
--- /dev/null
+++ b/src/app/version.ts
@@ -0,0 +1,2 @@
+declare var __NPM_PACKAGE_VERSION__: string;
+export const version = __NPM_PACKAGE_VERSION__;
diff --git a/src/assets/images/banner.png b/src/assets/images/banner.png
new file mode 100644
index 0000000..d051783
Binary files /dev/null and b/src/assets/images/banner.png differ
diff --git a/src/assets/images/favicon.ico b/src/assets/images/favicon.ico
new file mode 100644
index 0000000..1b59bc5
Binary files /dev/null and b/src/assets/images/favicon.ico differ
diff --git a/src/assets/images/logo.png b/src/assets/images/logo.png
new file mode 100644
index 0000000..20dabdc
Binary files /dev/null and b/src/assets/images/logo.png differ
diff --git a/src/assets/images/radar_legend.png b/src/assets/images/radar_legend.png
new file mode 100644
index 0000000..fa13a1b
Binary files /dev/null and b/src/assets/images/radar_legend.png differ
diff --git a/src/assets/images/tech-radar-landing-page-wide.png b/src/assets/images/tech-radar-landing-page-wide.png
new file mode 100644
index 0000000..6e1dfb9
Binary files /dev/null and b/src/assets/images/tech-radar-landing-page-wide.png differ
diff --git a/src/assets/images/tw-logo.png b/src/assets/images/tw-logo.png
new file mode 100644
index 0000000..943ec4c
Binary files /dev/null and b/src/assets/images/tw-logo.png differ
diff --git a/src/browserslist b/src/browserslist
new file mode 100644
index 0000000..37371cb
--- /dev/null
+++ b/src/browserslist
@@ -0,0 +1,11 @@
+# This file is currently used by autoprefixer to adjust CSS to support the below specified browsers
+# For additional information regarding the format and rule options, please see:
+# https://github.com/browserslist/browserslist#queries
+#
+# For IE 9-11 support, please remove 'not' from the last line of the file and adjust as needed
+
+> 0.5%
+last 2 versions
+Firefox ESR
+not dead
+not IE 9-11
\ No newline at end of file
diff --git a/src/environments/environment.prod.ts b/src/environments/environment.prod.ts
new file mode 100644
index 0000000..8183896
--- /dev/null
+++ b/src/environments/environment.prod.ts
@@ -0,0 +1,9 @@
+declare var __BACKEND_SERVICE_URL__: string;
+declare var __RADAR_SERVICE_URL__: string;
+export const environment = {
+ production: true,
+ serviceUrl: __BACKEND_SERVICE_URL__,
+ radarURL: __RADAR_SERVICE_URL__,
+ traceLevel: 'INFO',
+ maxNumberOfVotes: 10
+};
diff --git a/src/environments/environment.ts b/src/environments/environment.ts
new file mode 100644
index 0000000..c4d7678
--- /dev/null
+++ b/src/environments/environment.ts
@@ -0,0 +1,22 @@
+// This file can be replaced during build by using the `fileReplacements` array.
+// `ng build --prod` replaces `environment.ts` with `environment.prod.ts`.
+// The list of file replacements can be found in `angular.json`.
+
+declare var __BACKEND_SERVICE_URL__: string;
+declare var __RADAR_SERVICE_URL__: string;
+export const environment = {
+ production: false,
+ serviceUrl: __BACKEND_SERVICE_URL__,
+ radarURL: __RADAR_SERVICE_URL__,
+ traceLevel: 'TRACE',
+ maxNumberOfVotes: 10
+};
+
+/*
+ * For easier debugging in development mode, you can import the following file
+ * to ignore zone related error stack frames such as `zone.run`, `zoneDelegate.invokeTask`.
+ *
+ * This import should be commented out in production mode because it will have a negative impact
+ * on performance if an error is thrown.
+ */
+// import 'zone.js/dist/zone-error'; // Included with Angular CLI.
diff --git a/src/index.html b/src/index.html
new file mode 100644
index 0000000..0115a53
--- /dev/null
+++ b/src/index.html
@@ -0,0 +1,20 @@
+
+
+
+
+
+ Build Your Own Radar
+
+
+
+ {{truncatedName('Add as a new '+ quadrant)}}
+
+
+
+
+ {{truncatedName('Already voted')}}
+
+
+
+
+
+
+
+
+ Votes
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/app/modules/vote/vote/vote.component.scss b/src/app/modules/vote/vote/vote.component.scss
new file mode 100644
index 0000000..fe2ab37
--- /dev/null
+++ b/src/app/modules/vote/vote/vote.component.scss
@@ -0,0 +1,141 @@
+@import "../../../styles/theme/colors";
+
+$boxes_padding: 1.3rem;
+
+:host {
+ position: relative;
+}
+
+.technology-card-list {
+ padding-top: 30px;
+ overflow: auto;
+ background-color: rgba(0,0,0,.06);
+ -webkit-overflow-scrolling: touch;
+
+ display: flex;
+ flex-wrap: wrap;
+ justify-content: center;
+}
+
+.technology-card {
+ height: 8rem;
+ width: 15rem;
+ margin: 1rem;
+ display: flex;
+ flex-direction: column;
+ font-size: 16px;
+ text-align: center;
+ line-height: 1.4;
+ color: white;
+ justify-content: space-evenly;
+}
+
+.new-ribbon {
+ position: absolute;
+ top: 0;
+ right: 0;
+}
+
+.technology-title {
+ font-weight: bold;
+ height: 50px;
+}
+
+.technology-description {
+ font-size: x-small;
+ overflow: auto;
+ -webkit-overflow-scrolling: touch;
+}
+
+.vote-chip {
+ color: #fff;
+}
+
+.search-field {
+ width: 100%;
+}
+
+.input-field {
+ // this is to override the thoughtworks screen.css which specifies a differen box-shadow for input.focus
+ // which causes the input field to get a grey border
+ box-shadow: inset 0 0 1px #fdfafafc;
+}
+
+.quadrant-buttons, .search-section {
+ display: flex;
+ flex-wrap: wrap;
+ justify-content: center;
+ max-width: 700px;
+ margin: 0 auto;
+ padding: 0 $boxes_padding;
+}
+
+.quadrant-button {
+ margin: 1rem;
+ color: white;
+}
+
+.selected-quadrant-button {
+ background-color: #3f51b5;
+}
+
+.card-actions {
+ display: flex;
+ flex-wrap: wrap;
+ margin: 10px 0;
+ justify-content: center;
+}
+
+.ring-button {
+ width: 40%;
+ margin: 10px !important;
+ padding: 0;
+}
+
+.votes-information {
+ position: fixed;
+ left: 0;
+ bottom: 0;
+ width: 100%;
+ background: #fff;
+ .mat-expansion-panel-header {
+ flex-direction: row-reverse;
+ .mat-expansion-panel-header-title {
+ align-items: center;
+ }
+ .mat-expansion-panel-header-description {
+ flex-grow: 0;
+ margin-right: 0;
+ }
+ }
+ .selection-list > div {
+ padding: $boxes_padding 0 0 0;
+ }
+}
+
+.tools {
+ background-color: $green;
+}
+
+.technique {
+ background-color: $blue;
+}
+
+.platforms {
+ background-color: $orange;
+}
+
+.languages {
+ background-color: $violet;
+}
+
+.help-dialogue-button {
+ border: none;
+ position: absolute;
+ top: 15px;
+ right: 15px;
+}
+
+.vote-comment {
+ width: 100%
+}
diff --git a/src/app/modules/vote/vote/vote.component.spec.ts b/src/app/modules/vote/vote/vote.component.spec.ts
new file mode 100644
index 0000000..bf8d08b
--- /dev/null
+++ b/src/app/modules/vote/vote/vote.component.spec.ts
@@ -0,0 +1,220 @@
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { HttpClientTestingModule, } from '@angular/common/http/testing';
+import { RouterTestingModule } from '@angular/router/testing';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { of, asyncScheduler } from 'rxjs';
+import { observeOn } from 'rxjs/operators';
+
+import { AppMaterialModule } from '../../../app-material.module';
+
+import { VoteService } from '../services/vote.service';
+import { VoteComponent } from './vote.component';
+import { BackendService } from '../../../services/backend.service';
+import { TwRings } from 'src/app/models/ring';
+
+const TEST_TECHNOLOGIES = [
+ {
+ id: '0001', name: 'Babel', quadrant: 'Tools', isnew: true,
+ description: 'Description of Babel'
+ },
+ {
+ id: '0002', name: 'Ember.js', quadrant: 'Languages & Frameworks', isnew: true,
+ description: 'Description of Ember.js'
+ },
+ {
+ id: '0003', name: 'Docker', quadrant: 'Platforms', isnew: false,
+ description: 'Description of Docker'
+ },
+ {
+ id: '0004', name: 'Consumer-driven contract testing', quadrant: 'Techniques', isnew: true,
+ description: 'Description of Consumer-driven contract testin'
+ },
+ {
+ id: '0005', name: 'LambdaCD', quadrant: 'Tools', isnew: true,
+ description: 'Description of LambdaCD'
+ },
+];
+class MockBackEndService {
+ getVotingEvent() {
+ const votingEvent = { technologies: TEST_TECHNOLOGIES, name: null, status: 'closed', _id: null, creationTS: null };
+ return of(votingEvent).pipe(observeOn(asyncScheduler));
+ }
+}
+class MockVoteService {
+ credentials;
+
+ constructor() {
+ this.credentials = {
+ voterId: null,
+ votingEvent: { technologies: TEST_TECHNOLOGIES, name: null, status: 'closed', _id: null, creationTS: null }
+ };
+ }
+}
+
+describe('VoteComponent', () => {
+ let component: VoteComponent;
+ let fixture: ComponentFixture
+
+
+
+
+ {{ vote.technology.name }}
+ cancel
+
+
+
+