All files / src/interfaces/mobile-api/employee mdm-mobile.controller.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
import {
  Controller,
  Get,
  Param,
  Query,
  UseGuards,
  Request,
} from '@nestjs/common';
import { PermissionGuard } from '../../../platform/permissions/permission.guard';
import { RequirePermission } from '../../../platform/permissions/permission.decorator';
import { MasterDataResolverService } from '../../../domains/mdm/application/services/master-data-resolver.service';
import { GlobalReferenceService } from '../../../domains/mdm/application/services/global-reference.service';
import { CurrencyService } from '../../../domains/mdm/application/services/currency.service';
import { UnitOfMeasureService } from '../../../domains/mdm/application/services/unit-of-measure.service';
import { StatusReasonService } from '../../../domains/mdm/application/services/status-reason.service';
import { ApiTags, ApiOperation, ApiResponse } from '@nestjs/swagger';
 
@Controller('mobile-api/employee/mdm')
@UseGuards(PermissionGuard)
@ApiTags('MdmMobile')
export class MdmMobileController {
  constructor(
    private readonly resolver: MasterDataResolverService,
    private readonly globalRef: GlobalReferenceService,
    private readonly currencyService: CurrencyService,
    private readonly uomService: UnitOfMeasureService,
    private readonly statusReasonService: StatusReasonService,
  ) {}
 
  @Get('lookups/:definitionKey')
  @RequirePermission('mobile_lookup', 'read')
  @ApiOperation({ summary: 'Resolve lookup operation' })
  @ApiResponse({ status: 200, description: 'Operation successful' })
  async resolveLookup(
    @Request() req: any,
    @Param('definitionKey') definitionKey: string,
    @Query('code') code?: string,
    @Query('search') search?: string,
  ) {
    const context = {
      tenantId: req.user.tenantId,
      userId: req.user.userId,
      countryCode: req.user.countryCode,
    };
 
    if (code) {
      const resolved = await this.resolver.resolve(
        definitionKey,
        code,
        context,
      );
      return { data: resolved ? [resolved] : [] };
    }
 
    const listResult = await this.resolver.list(definitionKey, context, {
      search,
    });
    // Map to compact mobile DTO format (saving bandwidth)
    const compact = listResult.records.map((r) => ({
      code: r.recordCode,
      name: r.recordName,
      extra: r.attributes,
    }));
 
    return { data: compact, total: listResult.total };
  }
 
  @Get('countries')
  @RequirePermission('mobile_lookup', 'read')
  @ApiOperation({ summary: 'Get countries operation' })
  @ApiResponse({ status: 200, description: 'Operation successful' })
  async getCountries(@Query('search') search?: string) {
    const list = await this.globalRef.listCountries({ search, active: true });
    return list.map((c) => ({
      code: c.isoAlpha2,
      name: c.countryName,
      callingCode: c.callingCode,
      emoji: c.flagEmoji,
    }));
  }
 
  @Get('currencies')
  @RequirePermission('mobile_lookup', 'read')
  @ApiOperation({ summary: 'Get currencies operation' })
  @ApiResponse({ status: 200, description: 'Operation successful' })
  async getCurrencies() {
    const list = await this.currencyService.listCurrencies({ active: true });
    return list.map((c) => ({
      code: c.currencyCode,
      name: c.currencyName,
      symbol: c.symbol,
    }));
  }
 
  @Get('units')
  @RequirePermission('mobile_lookup', 'read')
  @ApiOperation({ summary: 'Get units operation' })
  @ApiResponse({ status: 200, description: 'Operation successful' })
  async getUnits(@Query('category') category?: string) {
    const list = await this.uomService.listUnits(category);
    return list.map((u) => ({
      code: u.unitCode,
      name: u.unitName,
      symbol: u.unitSymbol,
      category: u.categoryCode,
    }));
  }
 
  @Get('reasons/:groupCode')
  @RequirePermission('mobile_lookup', 'read')
  @ApiOperation({ summary: 'Get reasons operation' })
  @ApiResponse({ status: 200, description: 'Operation successful' })
  async getReasons(@Request() req: any, @Param('groupCode') groupCode: string) {
    const list = await this.statusReasonService.listReasons(
      groupCode,
      req.user.tenantId,
    );
    return list.map((r) => ({
      code: r.reasonCode,
      name: r.reasonName,
    }));
  }
}