feat: fourthwall update command

src/discord/commands.ts

@@ -422,4 +422,34 @@ export class DiscordCommands {
 
     return interaction.reply({ content: `Successfully removed ${url}.`, flags: [MessageFlags.SuppressEmbeds] });
   }
+
+  @Slash({ name: 'fourthwall', description: 'Fourthwall related commmands' })
+  async handleFourthwall(
+    @SlashChoice('update')
+    @SlashOption({
+      name: 'action',
+      description: 'update: Updates Fourthwall orders',
+      required: true,
+      type: ApplicationCommandOptionType.String,
+    })
+    action: 'update',
+    @SlashOption({
+      name: 'id',
+      description: 'Id of a specific order to update',
+      type: ApplicationCommandOptionType.String,
+      required: false,
+    })
+    id: string | null,
+    interaction: CommandInteraction,
+  ) {
+    switch (action) {
+      case 'update': {
+        await this.service.updateFourthwallOrders(id);
+        return interaction.reply({
+          content: 'Successfully updated Fourthwall orders',
+          flags: [MessageFlags.Ephemeral],
+        });
+      }
+    }
+  }
 }

src/interfaces/database.interface.ts

@@ -132,6 +132,7 @@ export interface IDatabaseRepository {
   createFourthwallOrder(entity: NewFourthwallOrder): Promise<void>;
   updateFourthwallOrder(entity: UpdateFourthwallOrder): Promise<void>;
   getTotalFourthwallOrders(options?: ReportOptions): Promise<{ revenue: number; profit: number }>;
+  streamFourthwallOrders(): AsyncIterableIterator<{ id: string }>;
   createRSSFeed(entity: NewRSSFeed): Promise<void>;
   getRSSFeeds(channelId?: string): Promise<RSSFeed[]>;
   removeRSSFeed(url: string, channelId: string): Promise<void>;

src/repositories/database.repository.ts

@@ -196,6 +196,10 @@ export class DatabaseRepository implements IDatabaseRepository {
     return { revenue: Number(revenue) || 0, profit: Number(profit) || 0 };
   }
 
+  streamFourthwallOrders() {
+    return this.db.selectFrom('fourthwall_orders').select('id').stream();
+  }
+
   async createRSSFeed(entity: NewRSSFeed): Promise<void> {
     await this.db.insertInto('rss_feeds').values(entity).execute();
   }

src/services/discord.service.spec.ts

@@ -1,5 +1,6 @@
 import { IDatabaseRepository } from 'src/interfaces/database.interface';
 import { IDiscordInterface } from 'src/interfaces/discord.interface';
+import { IFourthwallRepository } from 'src/interfaces/fourthwall.interface';
 import { IGithubInterface } from 'src/interfaces/github.interface';
 import { IOutlineInterface } from 'src/interfaces/outline.interface';
 import { DiscordService } from 'src/services/discord.service';
@@ -48,28 +49,35 @@ const newDatabaseMockRepository = (): Mocked<IDatabaseRepository> => ({
   updateDiscordMessage: vitest.fn(),
   createFourthwallOrder: vitest.fn(),
   getTotalFourthwallOrders: vitest.fn(),
+  streamFourthwallOrders: vitest.fn(),
   updateFourthwallOrder: vitest.fn(),
   createRSSFeed: vitest.fn(),
   getRSSFeeds: vitest.fn(),
   updateRSSFeed: vitest.fn(),
   removeRSSFeed: vitest.fn(),
 });
 
+const newFourthwallMockRepository = (): Mocked<IFourthwallRepository> => ({
+  getOrder: vitest.fn(),
+});
+
 describe('Bot test', () => {
   let sut: DiscordService;
 
   let discordMock: Mocked<IDiscordInterface>;
+  let fourthwallMock: Mocked<IFourthwallRepository>;
   let githubMock: Mocked<IGithubInterface>;
   let outlineMock: Mocked<IOutlineInterface>;
   let databaseMock: Mocked<IDatabaseRepository>;
 
   beforeEach(() => {
     discordMock = newDiscordMockRepository();
+    fourthwallMock = newFourthwallMockRepository();
     githubMock = newGithubMockRepository();
     outlineMock = newOutlineMockRepository();
     databaseMock = newDatabaseMockRepository();
 
-    sut = new DiscordService(databaseMock, discordMock, githubMock, outlineMock);
+    sut = new DiscordService(databaseMock, discordMock, fourthwallMock, githubMock, outlineMock);
   });
 
   it('should work', () => {

src/services/discord.service.ts

@@ -9,6 +9,7 @@ import { IDatabaseRepository } from 'src/interfaces/database.interface';
 import { DiscordChannel, IDiscordInterface } from 'src/interfaces/discord.interface';
 import { IGithubInterface } from 'src/interfaces/github.interface';
 import { IOutlineInterface } from 'src/interfaces/outline.interface';
+import { FourthwallRepository } from 'src/repositories/fourthwall.repository';
 import { formatCommand, logError, shorten } from 'src/util';
 
 const PREVIEW_BLACKLIST = [Constants.Urls.Immich, Constants.Urls.GitHub, Constants.Urls.MyImmich];
@@ -58,6 +59,7 @@ export class DiscordService {
   constructor(
     @Inject(IDatabaseRepository) private database: IDatabaseRepository,
     @Inject(IDiscordInterface) private discord: IDiscordInterface,
+    @Inject(FourthwallRepository) private fourthwall: FourthwallRepository,
     @Inject(IGithubInterface) private github: IGithubInterface,
     @Inject(IOutlineInterface) private outline: IOutlineInterface,
   ) {}
@@ -464,4 +466,33 @@ export class DiscordService {
       }
     }
   }
+
+  async updateFourthwallOrders(id?: string | null) {
+    const {
+      fourthwall: { user, password },
+    } = getConfig();
+
+    if (id) {
+      await this.updateOrder({ id, user, password });
+      return;
+    }
+
+    for await (const { id } of this.database.streamFourthwallOrders()) {
+      await this.updateOrder({ id, user, password });
+    }
+  }
+
+  private async updateOrder({ id, user, password }: { id: string; user: string; password: string }) {
+    const order = await this.fourthwall.getOrder({ id, user, password });
+
+    await this.database.updateFourthwallOrder({
+      id,
+      discount: order.discount,
+      status: order.status,
+      total: order.totalPrice.value,
+      profit: order.profit.value,
+      shipping: order.currentAmounts.shipping.value,
+      tax: order.currentAmounts.tax.value,
+    });
+  }
 }

src/services/webhook.service.ts

@@ -201,12 +201,21 @@ export class WebhookService {
   }
 
   async onFourthwallOrder(dto: FourthwallOrderCreateWebhook | FourthwallOrderUpdateWebhook, slug: string) {
-    const { slugs, fourthwall } = getConfig();
+    const { slugs } = getConfig();
     if (!slugs.fourthwallWebhook || slug !== slugs.fourthwallWebhook) {
       throw new UnauthorizedException();
     }
+
+    void this.handleFourthwallOrder(dto);
+  }
+
+  private async handleFourthwallOrder(dto: FourthwallOrderCreateWebhook | FourthwallOrderUpdateWebhook) {
+    const { fourthwall } = getConfig();
+
     const dtoOrder = dto.type === 'ORDER_PLACED' ? dto.data : dto.data.order;
 
+    await new Promise((resolve) => setTimeout(resolve, 10_000));
+
     let order = await this.fourthwall.getOrder({
       id: dtoOrder.id,
       user: fourthwall.user,