feat(event): adiciona filtro de eventos passados

closed #62, #57

Author: guiseek

packages/event/data-access/src/lib/application/event.facade.ts

@@ -11,6 +11,7 @@ import {
   FindAllEventsUseCase,
   CopyEventUseCase,
   FindMyEventsUseCase,
+  FindEventsUntilUseCase,
 } from '@devmx/event-domain/client';
 
 export class EventFacade extends EntityFacade<Event> {
@@ -26,6 +27,7 @@ export class EventFacade extends EntityFacade<Event> {
     private findEventsUseCase: FindEventsUseCase,
     private findMyEventsUseCase: FindMyEventsUseCase,
     private findAllEventsUseCase: FindAllEventsUseCase,
+    private findEventsUntilUseCase: FindEventsUntilUseCase,
     private findEventByIDUseCase: FindEventByIDUseCase,
     private updateEventUseCase: UpdateEventUseCase,
     private copyEventUseCase: CopyEventUseCase,
@@ -51,6 +53,10 @@ export class EventFacade extends EntityFacade<Event> {
     this.onLoad(this.findAllEventsUseCase.execute(this.state.params));
   }
 
+  loadUntil() {
+    this.onLoad(this.findEventsUntilUseCase.execute(this.state.params));
+  }
+
   loadMyEvents() {
     this.onLoad(this.findMyEventsUseCase.execute(this.state.params));
   }
@@ -94,6 +100,7 @@ export function provideEventFacade() {
     FindEventsUseCase,
     FindMyEventsUseCase,
     FindAllEventsUseCase,
+    FindEventsUntilUseCase,
     FindEventByIDUseCase,
     UpdateEventUseCase,
     CopyEventUseCase,

packages/event/data-access/src/lib/infrastructure/event.http.service.impl.ts

@@ -20,6 +20,11 @@ export class EventHttpServiceImpl
     return this.http.get<Page<Event>>(url.join('?'));
   }
 
+  findUntil(params: QueryParams<Event>) {
+    const url = [`${this.url}/until`, createQueryParams(params)];
+    return this.http.get<Page<Event>>(url.join('?'));
+  }
+
   findMyEvents(params: QueryParams<Event>) {
     const url = [`${this.url}/my`, createQueryParams(params)];
     return this.http.get<Page<Event>>(url.join('?'));

packages/event/data-access/src/lib/providers/event.ts

@@ -6,6 +6,7 @@ import {
   provideDeleteEventUseCase,
   provideFindAllEventsUseCase,
   provideFindEventByIDUseCase,
+  provideFindEventsUntilUseCase,
   provideFindEventsUseCase,
   provideFindMyEventsUseCase,
   provideUpdateEventUseCase,
@@ -19,6 +20,7 @@ export function provideEvent() {
     provideFindEventsUseCase(),
     provideFindMyEventsUseCase(),
     provideFindAllEventsUseCase(),
+    provideFindEventsUntilUseCase(),
     provideFindEventByIDUseCase(),
     provideUpdateEventUseCase(),
     provideDeleteEventUseCase(),

packages/event/data-source/src/lib/application/events.facade.ts

@@ -12,6 +12,7 @@ import {
   DeleteEventUseCase,
   FindEventByIDUseCase,
   FindEventsFromUseCase,
+  FindEventsUntilUseCase,
   FindEventsUseCase,
   FindMyEventsUseCase,
   UpdateEventUseCase,
@@ -28,6 +29,7 @@ export class EventsFacade {
     private findEventsUseCase: FindEventsUseCase,
     private findMyEventsUseCase: FindMyEventsUseCase,
     private findEventsFromUseCase: FindEventsFromUseCase,
+    private findEventsUntilUseCase: FindEventsUntilUseCase,
     private findEventByIDUseCase: FindEventByIDUseCase,
     private updateEventUseCase: UpdateEventUseCase,
     private copyEventUseCase: CopyEventUseCase,
@@ -67,6 +69,15 @@ export class EventsFacade {
     return new PageDto(events, items, pages);
   }
 
+  async findUntil(date: Date, params: QueryParamsDto<Event>) {
+    const { data, items, pages } = await this.findEventsUntilUseCase.execute([
+      date,
+      params,
+    ]);
+    const events = plainToInstance(EventDto, data);
+    return new PageDto(events, items, pages);
+  }
+
   async findOne(id: string) {
     const event = await this.findEventByIDUseCase.execute(id);
     return plainToInstance(EventDto, event);
@@ -89,6 +100,7 @@ export function provideEventsFacade() {
     FindEventsUseCase,
     FindMyEventsUseCase,
     FindEventsFromUseCase,
+    FindEventsUntilUseCase,
     FindEventByIDUseCase,
     UpdateEventUseCase,
     CopyEventUseCase,

packages/event/data-source/src/lib/infrastructure/events.mongo.service.impl.ts

@@ -1,12 +1,12 @@
 import { QueryParams, EditableEntity } from '@devmx/shared-api-interfaces';
+import { Query, RootFilterQuery, SortOrder } from 'mongoose';
 import { EventsService } from '@devmx/event-domain/server';
 import { getModelToken } from '@nestjs/mongoose';
 import { EventCollection } from '../schemas';
-import { Query } from 'mongoose';
 import {
+  objectId,
   MongoService,
   createServiceProvider,
-  objectId,
 } from '@devmx/shared-data-source';
 
 export class EventsMongoServiceImpl
@@ -38,15 +38,38 @@ export class EventsMongoServiceImpl
   }
 
   async findFrom(date: Date, params: QueryParams<EventCollection>) {
-    const { page = 0, size = 10, filter, sort } = params;
+    const { page = 0, size = 10 } = params;
 
     const skip = page * size;
-    const where = this.applyFilter(filter ?? {});
-    const order = this.applySort(sort ?? {});
+    const filter = this.applyFilter(params.filter ?? {});
+    const sort = this.applySort(params.sort ?? {});
+
+    const where = { ...filter, date: { $gte: date } };
+
+    return this.findByWhere(where, sort, skip, size);
+  }
 
+  async findUntil(date: Date, params: QueryParams<EventCollection>) {
+    const { page = 0, size = 10 } = params;
+
+    const skip = page * size;
+    const filter = this.applyFilter(params.filter ?? {});
+    const sort = this.applySort(params.sort ?? {});
+
+    const where = { ...filter, date: { $lte: date } };
+
+    return this.findByWhere(where, sort, skip, size);
+  }
+
+  async findByWhere(
+    where: RootFilterQuery<EventCollection>,
+    sort: Record<string, SortOrder>,
+    skip: number,
+    size: number
+  ) {
     const query = this.entityModel
-      .find({ ...where, date: { $gte: date } })
-      .sort(order)
+      .find(where)
+      .sort(sort)
       .skip(skip)
       .limit(size);
 

packages/event/data-source/src/lib/providers/event.ts

@@ -9,6 +9,7 @@ import {
   provideFindEventsFromUseCase,
   provideCopyEventUseCase,
   provideFindMyEventsUseCase,
+  provideFindEventsUntilUseCase,
 } from '@devmx/event-domain/server';
 
 export function provideEvent() {
@@ -19,6 +20,7 @@ export function provideEvent() {
     provideFindEventsUseCase(),
     provideFindMyEventsUseCase(),
     provideFindEventsFromUseCase(),
+    provideFindEventsUntilUseCase(),
     provideFindEventByIDUseCase(),
     provideUpdateEventUseCase(),
     provideDeleteEventUseCase(),

packages/event/domain/src/client/services/event.ts

@@ -14,6 +14,8 @@ export abstract class EventService extends EntityService<Event> {
 
   abstract findAll(params: QueryParams<Event>): Observable<Page<Event>>;
 
+  abstract findUntil(params: QueryParams<Event>): Observable<Page<Event>>;
+
   abstract findMyEvents(params: QueryParams<Event>): Observable<Page<Event>>;
 
   abstract createRSVP(event: string, status: RSVPStatus): Observable<RSVP>;

packages/event/domain/src/client/use-cases/find-events-until.ts

@@ -0,0 +1,22 @@
+import { createUseCaseProvider } from '@devmx/shared-util-data/client';
+import { EventService } from '../services';
+import {
+  Page,
+  Event,
+  UseCase,
+  QueryParams,
+} from '@devmx/shared-api-interfaces';
+
+export class FindEventsUntilUseCase
+  implements UseCase<QueryParams<Event>, Page<Event>>
+{
+  constructor(private eventService: EventService) {}
+
+  execute(params: QueryParams<Event>) {
+    return this.eventService.findUntil(params);
+  }
+}
+
+export function provideFindEventsUntilUseCase() {
+  return createUseCaseProvider(FindEventsUntilUseCase, [EventService]);
+}

packages/event/domain/src/client/use-cases/index.ts

@@ -4,6 +4,7 @@ export * from './create-rsvp';
 export * from './delete-event';
 export * from './find-all-events';
 export * from './find-event-by-id';
+export * from './find-events-until';
 export * from './find-events';
 export * from './find-my-events';
 export * from './find-rsvp-by-event';

packages/event/domain/src/server/services/events.ts

@@ -7,5 +7,10 @@ export abstract class EventsService extends EntityService<Event> {
     params: QueryParams<Event>
   ): Promise<Page<Event>>;
 
+  abstract findUntil(
+    date: Date,
+    params: QueryParams<Event>
+  ): Promise<Page<Event>>;
+
   abstract findMyEvents(params: QueryParams<Event>): Promise<Page<Event>>;
 }

packages/event/domain/src/server/use-cases/find-events-until.ts

@@ -0,0 +1,48 @@
+import { createUseCaseProvider } from '@devmx/shared-util-data/server';
+import { EventsService } from '../services';
+import {
+  Event,
+  Page,
+  UseCase,
+  QueryParams,
+} from '@devmx/shared-api-interfaces';
+
+export class FindEventsUntilUseCase
+  implements UseCase<[Date, QueryParams<Event>], Page<Event>>
+{
+  constructor(private eventsService: EventsService) {}
+
+  async execute([date, params]: [Date, QueryParams<Event>]) {
+    if (params.filter) {
+      if (params.filter.format) {
+        params.filter.format = new RegExp(params.filter.format, 'i');
+      } else {
+        delete params.filter.format;
+      }
+
+      if (params.filter.title) {
+        params.filter.title = new RegExp(params.filter.title, 'i');
+      } else {
+        delete params.filter.title;
+      }
+
+      if (params.filter.city) {
+        params.filter.city = params.filter.city.toString();
+      } else {
+        delete params.filter.city;
+      }
+
+      if (params.filter.description) {
+        params.filter.description = new RegExp(params.filter.description, 'i');
+      } else {
+        delete params.filter.description;
+      }
+    }
+
+    return await this.eventsService.findUntil(date, params);
+  }
+}
+
+export function provideFindEventsUntilUseCase() {
+  return createUseCaseProvider(FindEventsUntilUseCase, [EventsService]);
+}

packages/event/domain/src/server/use-cases/index.ts

@@ -4,6 +4,7 @@ export * from './create-rsvp';
 export * from './delete-event';
 export * from './find-event-by-id';
 export * from './find-events-from';
+export * from './find-events-until';
 export * from './find-events';
 export * from './find-my-events';
 export * from './find-past-events';

packages/event/feature-shell/src/lib/containers/events/events.container.html

@@ -1,5 +1,9 @@
 <header>
-  <devmx-event-filter (filterChange)="onFilterChange($event)" />
+  <div>
+    <devmx-event-filter (filterChange)="onFilterChange($event)" />
+
+    <devmx-event-time (timeChange)="onTimeChange($event)" />
+  </div>
 
   <devmx-sort-direction (sortChange)="onSortChange($event)" />
 </header>

packages/event/feature-shell/src/lib/containers/events/events.container.ts

@@ -9,6 +9,7 @@ import { AsyncPipe } from '@angular/common';
 import {
   EventCardComponent,
   EventFilterComponent,
+  EventTimeComponent,
 } from '@devmx/event-ui-shared';
 
 @Component({
@@ -18,6 +19,7 @@ import {
   changeDetection: ChangeDetectionStrategy.OnPush,
   imports: [
     PaginatorComponent,
+    EventTimeComponent,
     EventFilterComponent,
     SortDirectionComponent,
     EventCardComponent,
@@ -40,7 +42,7 @@ export class EventsContainer {
   }
 
   onQueryParams = (params: Params) => {
-    const { title = '', format = '', date = 'asc' } = params;
+    const { title = '', format = '', date = 'asc', time = '' } = params;
 
     const { page = 0, size = 10 } = params;
 
@@ -50,14 +52,23 @@ export class EventsContainer {
 
     this.eventFacade.setParams({ page, size, filter, sort });
 
-    this.eventFacade.load();
+    if (time === 'until') {
+      this.eventFacade.loadUntil();
+    } else {
+      this.eventFacade.load();
+    }
   };
 
   onFilterChange(format: string) {
     const queryParams = { format };
     this.router.navigate([], { queryParams });
   }
 
+  onTimeChange(time: string) {
+    const queryParams = { time };
+    this.router.navigate([], { queryParams });
+  }
+
   onSortChange(date: string) {
     const queryParams = { date };
     this.router.navigate([], { queryParams });

packages/event/resource/src/lib/controllers/events.ts

@@ -93,6 +93,20 @@ export class EventsController {
     }
   }
 
+  @Get('until')
+  @Allowed()
+  @ApiPage(EventDto)
+  async findUntil(@Query() params: QueryParamsDto<Event>) {
+    let date = new Date();
+    date = subDays(date, 1);
+
+    try {
+      return await this.eventsFacade.findUntil(date, params);
+    } catch (err) {
+      throw exceptionByError(err);
+    }
+  }
+
   @Get('my')
   @Allowed()
   @ApiPage(EventDto)

packages/event/ui-shared/src/lib/components/event-time/event-time.component.html

@@ -0,0 +1,7 @@
+<mat-chip-listbox (change)="timeChange.emit($event.value)">
+  @for (time of times; track time.value) {
+  <mat-chip-option [value]="time.value">
+    {{ time.viewValue }}
+  </mat-chip-option>
+  }
+</mat-chip-listbox>

packages/event/ui-shared/src/lib/components/event-time/event-time.component.scss

@@ -0,0 +1,20 @@
+import { ChangeDetectionStrategy, Component, output } from '@angular/core';
+import { MatChipsModule } from '@angular/material/chips';
+import { FormOption } from '@devmx/shared-ui-global/forms';
+import { EventFormat } from '@devmx/shared-api-interfaces';
+
+@Component({
+  selector: 'devmx-event-time',
+  templateUrl: './event-time.component.html',
+  styleUrl: './event-time.component.scss',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  imports: [MatChipsModule],
+})
+export class EventTimeComponent {
+  timeChange = output<EventFormat>();
+
+  times: FormOption<'' | 'until'>[] = [
+    { value: '', viewValue: 'Chegando' },
+    { value: 'until', viewValue: 'Passados' },
+  ];
+}