funky-framadate-front/src/app/core/services/poll.service.ts

125 lines
4.4 KiB
TypeScript
Raw Normal View History

import { Injectable } from '@angular/core';
2020-06-18 16:15:26 +02:00
import { ActivatedRouteSnapshot, Resolve, Router, RouterStateSnapshot } from '@angular/router';
import { BehaviorSubject, Observable } from 'rxjs';
2020-06-12 19:17:39 +02:00
import { Answer } from '../enums/answer.enum';
2020-05-12 19:16:23 +02:00
import { Choice } from '../models/choice.model';
import { Poll } from '../models/poll.model';
2020-05-12 19:16:23 +02:00
import { User } from '../models/user.model';
import { ApiService } from './api.service';
import { ToastService } from './toast.service';
2020-06-25 22:42:26 +02:00
import { UserService } from './user.service';
import { UuidService } from './uuid.service';
@Injectable({
providedIn: 'root',
})
2020-06-18 16:15:26 +02:00
export class PollService implements Resolve<Poll> {
private _poll: BehaviorSubject<Poll | undefined> = new BehaviorSubject<Poll | undefined>(undefined);
2020-04-22 12:56:18 +02:00
public readonly poll: Observable<Poll | undefined> = this._poll.asObservable();
2020-06-25 22:42:26 +02:00
constructor(
private router: Router,
private apiService: ApiService,
private userService: UserService,
private uuidService: UuidService,
private toastService: ToastService
) {}
2020-06-18 16:15:26 +02:00
public async resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<Poll> {
2020-06-25 22:42:26 +02:00
const segments: string[] = state.url.split('/');
const wantedSlug: string = segments.includes('poll') ? segments[segments.indexOf('poll') + 1] : '';
2020-06-18 16:15:26 +02:00
if (!wantedSlug && state.url.includes('administration')) {
// creation of new poll
2020-06-25 22:42:26 +02:00
const poll = new Poll(this.userService.getCurrentUser(), this.uuidService.getUUID(), '');
this._poll.next(poll);
this.router.navigate(['poll/' + poll.slug + '/administration']);
2020-06-18 16:15:26 +02:00
}
if (!this._poll.getValue() || !this._poll.getValue().slug || this._poll.getValue().slug !== wantedSlug) {
await this.loadPollBySlug(wantedSlug);
}
if (this._poll.getValue()) {
return this._poll.getValue();
} else {
this.router.navigate(['page-not-found']);
return;
}
}
2020-06-18 16:15:26 +02:00
public async loadPollBySlug(slug: string): Promise<void> {
2020-05-12 19:16:23 +02:00
const poll: Poll | undefined = await this.apiService.getPollBySlug(slug);
2020-06-25 22:42:26 +02:00
console.log({ loadPollBySlugResponse: poll });
2020-05-12 19:16:23 +02:00
this.updateCurrentPoll(poll);
}
2020-06-18 16:15:26 +02:00
public updateCurrentPoll(poll: Poll): void {
this._poll.next(poll);
}
2020-05-12 19:16:23 +02:00
public async saveCurrentPoll(): Promise<void> {
const pollUrl: string = await this.apiService.createPoll(this._poll.getValue());
// TODO: Maybe handle the url to update currentPoll according to backend response
if (pollUrl) {
this.toastService.display('Le sondage a été enregistré.');
2020-05-12 19:16:23 +02:00
} else {
this.toastService.display('Le sondage na été correctement enregistré, veuillez ré-essayer.');
2020-05-12 19:16:23 +02:00
}
}
2020-06-12 19:17:39 +02:00
public saveParticipation(choice: Choice, user: User, response: Answer): void {
2020-05-12 19:16:23 +02:00
const currentPoll = this._poll.getValue();
2020-06-12 19:17:39 +02:00
currentPoll.choices.find((c) => c.label === choice.label)?.updateParticipation(user, response);
2020-05-12 19:16:23 +02:00
this.updateCurrentPoll(currentPoll);
this.apiService.createParticipation(currentPoll.slug, choice.label, user.pseudo, response);
2020-06-25 22:42:26 +02:00
this.toastService.display('Votre participation au sondage a été enregistrée.');
}
2020-05-12 19:16:23 +02:00
public async deleteAllAnswers(): Promise<void> {
await this.apiService.deletePollAnswers(this._poll.getValue().slug);
2020-06-25 22:42:26 +02:00
this.toastService.display('Les participations des votants à ce sondage ont été supprimées.');
2020-05-01 19:10:17 +02:00
}
2020-05-12 19:16:23 +02:00
public async addComment(comment: string): Promise<void> {
await this.apiService.createComment(this._poll.getValue().slug, comment);
this.toastService.display('Votre commentaire a été enregistré.');
2020-05-12 19:16:23 +02:00
}
public async deleteComments(): Promise<void> {
await this.apiService.deletePollComments(this._poll.getValue().slug);
this.toastService.display('Les commentaires de ce sondage ont été supprimés.');
}
2020-06-12 19:17:39 +02:00
public buildAnswersByChoiceLabelByPseudo(poll: Poll): Map<string, Map<string, Answer>> {
const pseudos: Set<string> = new Set();
poll.choices.forEach((choice: Choice) => {
choice.participants.forEach((users: Set<User>) => {
users.forEach((user: User) => {
pseudos.add(user.pseudo);
});
});
});
const list = new Map<string, Map<string, Answer>>();
pseudos.forEach((pseudo: string) => {
list.set(
pseudo,
new Map<string, Answer>(
poll.choices.map((choice: Choice) => {
return [choice.label, undefined];
})
)
);
});
poll.choices.forEach((choice: Choice) => {
choice.participants.forEach((users: Set<User>, answer: Answer) => {
users.forEach((user: User) => {
list.get(user.pseudo).set(choice.label, answer);
});
});
});
return list;
}
}