Skip to content
Snippets Groups Projects
Select Git revision
  • 613d8e4bebc0089423c8a1536c14945a2bcb38b2
  • main default protected
2 results

partService.js

Blame
  • partService.js 3.07 KiB
    import { columnMapping } from '../constants/columnMapping.js';
    import { ReportableError } from '../errors.js';
    import PartRepository from '../repositories/partRepository.js';
    
    const PartService = {
      cleanEntity(entity) {
        return entity;
      },
      async getById(id, detail = false) {
        if (!id || id <= 0)
          throw new ReportableError(400, '올바르지 않은 id 입니다.');
    
        const part = await PartRepository.findById(id);
        if (!part) throw new ReportableError(404, '해당 부품을 찾을 수 없습니다');
    
        if (detail) {
          // eslint-disable-next-line no-unused-vars
          const { part_id, ...infos } = await PartRepository.findMetaByTypeAndId(
            part.type.toLowerCase(),
            id
          );
          const description = Object.values(infos).join(' / ');
          part['description'] = description;
        }
    
        return this.cleanEntity(part);
      },
      async getFilters() {
        const types = Object.keys(columnMapping);
        const filters = {};
    
        for (const type of types) {
          const columns = await PartRepository.getColumnsByType(type);
    
          filters[type.toUpperCase()] = {};
          for (const column of columns) {
            const koreanName = columnMapping[type]?.[column];
            if (koreanName) {
              const filterValues =
                await PartRepository.getFilterDataByTypeAndColumn(type, column);
    
              filters[type.toUpperCase()][koreanName] = {
                column,
                values: filterValues,
              };
            }
          }
        }
    
        return filters;
      },
    
      async getParts(partType, filters) {
        if (!partType) {
          throw new ReportableError(400, '파트 타입이 필요합니다.');
        }
    
        let parsedFilters;
        try {
          parsedFilters = filters ? JSON.parse(filters) : {};
        } catch {
          throw new ReportableError(400, '잘못된 JSON 형태입니다.');
        }
    
        const whereClauses = Object.entries(parsedFilters)
          .map(([key], index) => `${key} = $${index + 1}`)
          .join(' AND ');
        const queryValues = Object.values(parsedFilters);
    
        const parts = await PartRepository.getPartsByFilters(
          partType,
          whereClauses,
          queryValues
        );
        return parts;
      },
    
      async getCombinations() {
        const allCombinations = await PartRepository.getAllCombinations();
        return allCombinations;
      },
    
      async getFilteredCombinations(filters) {
        if (typeof filters.partId === 'string') {
          filters.partId = filters.partId.split(',').map((id) => id.trim());
        }
    
        if (
          !filters ||
          !Array.isArray(filters.partId) ||
          filters.partId.length === 0
        ) {
          throw new ReportableError(400, '유효한 partId 값이 필요합니다.');
        }
    
        const validFilters = filters.partId.filter((value) => value != null);
        if (validFilters.length === 0) {
          throw new ReportableError(400, '유효한 partId 값이 없습니다.');
        }
    
        const queryValues = [validFilters];
        const filteredCombinations =
          await PartRepository.getFilteredCombinations(queryValues);
    
        return filteredCombinations.map((combination) => ({
          partIds: combination.partids,
        }));
      },
    };
    
    export default PartService;