Product Catalog Service - Full Business Capabilities & Domain Architecture

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
@DomainService
public class ProductManagementService {

    public Product createProduct(ProductCreationRequest request) {
        // Validate unique identifiers
        validateUniqueness(request.getSku(), request.getGtin());

        // Create product with variants
        Product product = Product.builder()
            .sku(request.getSku())
            .name(request.getName())
            .description(request.getDescription())
            .category(categoryRepository.find(request.getCategoryId()))
            .attributes(enrichAttributes(request.getAttributes()))
            .status(ProductStatus.DRAFT)
            .build();

        // Generate variants if applicable
        if (request.hasVariantOptions()) {
            List<ProductVariant> variants = variantGenerator
                .generate(product, request.getVariantOptions());
            product.setVariants(variants);
        }

        return productRepository.save(product);
    }

    public Product updateLifecycleState(
        SKU sku,
        ProductStatus newStatus,
        String reason
    ) {
        Product product = productRepository.findBySku(sku);

        // Validate state transition
        if (!product.canTransitionTo(newStatus)) {
            throw new InvalidStateTransitionException(
                product.getStatus(),
                newStatus
            );
        }

        product.updateStatus(newStatus, reason);
        productRepository.save(product);

        // Publish state change event
        eventPublisher.publish(
            new ProductStatusChangedEvent(product, newStatus)
        );

        return product;
    }
}

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
@Entity
public class Category {
    @Id
    private CategoryId id;
    private String name;
    private String displayName;
    private CategoryId parentId;
    private Integer level;
    private String path; // e.g., "/electronics/computers/laptops"
    private List<AttributeDefinition> requiredAttributes;
    private List<AttributeDefinition> optionalAttributes;
    private CategoryStatus status;
    private SortOrder defaultSortOrder;

    public boolean isLeaf() {
        return !hasChildren();
    }

    public List<Category> getAncestors() {
        // Return path from root to this category
    }

    public void validateProduct(Product product) {
        // Check required attributes are present
        requiredAttributes.forEach(attr -> {
            if (!product.hasAttribute(attr.getName())) {
                throw new MissingRequiredAttributeException(attr);
            }
        });
    }
}

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
@Service
public class DigitalAssetService {

    public AssetMetadata uploadProductImage(
        SKU sku,
        MultipartFile file,
        ImageType type
    ) {
        // Validate file
        validateImage(file);

        // Generate variants
        Map<ImageSize, ProcessedImage> variants = imageProcessor
            .processImage(file, IMAGE_SIZE_CONFIGS);

        // Upload to CDN
        Map<ImageSize, String> urls = new HashMap<>();
        variants.forEach((size, image) -> {
            String url = cdnService.upload(
                generatePath(sku, type, size),
                image
            );
            urls.put(size, url);
        });

        // Save metadata
        AssetMetadata metadata = AssetMetadata.builder()
            .sku(sku)
            .type(type)
            .originalFilename(file.getOriginalFilename())
            .urls(urls)
            .uploadedAt(LocalDateTime.now())
            .build();

        return assetRepository.save(metadata);
    }
}

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
@Service
public class ProductSearchService {

    private final ElasticsearchClient elasticsearchClient;

    public SearchResults search(SearchRequest request) {
        // Build Elasticsearch query
        BoolQuery.Builder queryBuilder = new BoolQuery.Builder();

        // Add text search
        if (request.hasSearchTerm()) {
            queryBuilder.must(m -> m
                .multiMatch(mm -> mm
                    .query(request.getSearchTerm())
                    .fields(List.of(
                        "name^3",      // Boost name matches
                        "brand^2",     // Boost brand matches
                        "description",
                        "attributes"
                    ))
                    .type(MultiMatchType.BestFields)
                    .fuzziness(Fuzziness.AUTO)
                )
            );
        }

        // Add filters
        request.getFilters().forEach(filter -> {
            queryBuilder.filter(f -> f
                .term(t -> t
                    .field(filter.getField())
                    .value(filter.getValue())
                )
            );
        });

        // Add facet aggregations
        Map<String, Aggregation> aggregations = buildFacetAggregations(
            request.getFacets()
        );

        // Execute search
        SearchResponse<ProductDocument> response = elasticsearchClient
            .search(s -> s
                .index("products")
                .query(queryBuilder.build()._toQuery())
                .aggregations(aggregations)
                .from(request.getOffset())
                .size(request.getLimit())
                .sort(buildSortOptions(request.getSort())),
                ProductDocument.class
            );

        return mapToSearchResults(response);
    }
}

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
@Service
@Transactional
public class ProductCreationWorkflow {

    public Product createProduct(ProductRequest request) {
        // Step 1: Validate request
        ValidationResult validation = validator.validate(request);
        if (!validation.isValid()) {
            throw new ValidationException(validation.getErrors());
        }

        // Step 2: Check for duplicates
        checkForDuplicates(request);

        // Step 3: Enrich with defaults
        request = enrichWithDefaults(request);

        // Step 4: Create product
        Product product = Product.create(
            request.getSku(),
            request.getName(),
            request.getDescription()
        );

        // Step 5: Set attributes
        request.getAttributes().forEach(attr -> {
            product.setAttribute(attr.getName(), attr.getValue());
        });

        // Step 6: Assign category
        Category category = categoryRepository.find(request.getCategoryId());
        product.assignToCategory(category);

        // Step 7: Validate against category rules
        category.validateProduct(product);

        // Step 8: Save and publish
        Product saved = productRepository.save(product);
        eventPublisher.publish(new ProductCreatedEvent(saved));

        return saved;
    }
}

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
@Component
public class VariantGenerator {

    public List<ProductVariant> generate(
        Product product,
        List<VariantOption> options
    ) {
        // Generate all combinations
        List<Map<String, String>> combinations =
            generateCombinations(options);

        return combinations.stream()
            .map(combo -> ProductVariant.builder()
                .masterProduct(product)
                .sku(generateVariantSku(product.getSku(), combo))
                .options(combo)
                .name(generateVariantName(product.getName(), combo))
                .status(VariantStatus.DRAFT)
                .build()
            )
            .collect(Collectors.toList());
    }

    private String generateVariantSku(SKU masterSku, Map<String, String> options) {
        // Example: SHIRT-001 -> SHIRT-001-RED-L
        StringBuilder sku = new StringBuilder(masterSku.getValue());
        options.values().forEach(value -> {
            sku.append("-").append(value.toUpperCase());
        });
        return sku.toString();
    }
}

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
@Service
public class NavigationService {

    public NavigationTree buildNavigation() {
        List<Category> rootCategories = categoryRepository.findRoots();

        return NavigationTree.builder()
            .categories(rootCategories.stream()
                .map(this::buildCategoryNode)
                .collect(Collectors.toList())
            )
            .build();
    }

    private CategoryNode buildCategoryNode(Category category) {
        return CategoryNode.builder()
            .id(category.getId())
            .name(category.getDisplayName())
            .url(category.getUrl())
            .productCount(getProductCount(category))
            .children(category.getChildren().stream()
                .filter(Category::isActive)
                .map(this::buildCategoryNode)
                .collect(Collectors.toList())
            )
            .build();
    }
}

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
@Component
public class ImageProcessingPipeline {

    private static final Map<ImageSize, ImageConfig> SIZE_CONFIGS = Map.of(
        ImageSize.THUMBNAIL, new ImageConfig(150, 150, 85),
        ImageSize.SMALL, new ImageConfig(300, 300, 90),
        ImageSize.MEDIUM, new ImageConfig(600, 600, 90),
        ImageSize.LARGE, new ImageConfig(1200, 1200, 95),
        ImageSize.ORIGINAL, new ImageConfig(null, null, 100)
    );

    public Map<ImageSize, ProcessedImage> process(MultipartFile file) {
        BufferedImage original = ImageIO.read(file.getInputStream());

        return SIZE_CONFIGS.entrySet().stream()
            .collect(Collectors.toMap(
                Map.Entry::getKey,
                entry -> processForSize(original, entry.getValue())
            ));
    }

    private ProcessedImage processForSize(
        BufferedImage original,
        ImageConfig config
    ) {
        if (config.isOriginal()) {
            return new ProcessedImage(original);
        }

        BufferedImage resized = resize(original, config);
        BufferedImage optimized = optimize(resized, config);

        return new ProcessedImage(optimized);
    }
}

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
@Service
public class FacetedSearchService {

    public FacetedSearchResults search(FacetedSearchRequest request) {
        // Build base query
        Query query = buildQuery(request);

        // Add facet aggregations
        SearchSourceBuilder searchSource = new SearchSourceBuilder()
            .query(query)
            .size(request.getPageSize())
            .from(request.getOffset());

        // Add dynamic facets
        request.getRequestedFacets().forEach(facet -> {
            searchSource.aggregation(
                AggregationBuilders
                    .terms(facet.getName())
                    .field(facet.getField())
                    .size(facet.getMaxBuckets())
            );
        });

        // Execute search
        SearchResponse response = elasticsearchClient.search(
            new SearchRequest("products").source(searchSource),
            RequestOptions.DEFAULT
        );

        // Process results
        return FacetedSearchResults.builder()
            .products(extractProducts(response))
            .facets(extractFacets(response))
            .totalCount(response.getHits().getTotalHits().value)
            .build();
    }
}

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
@Component
public class CompletenessScorer {

    public CompletenessScore calculate(Product product) {
        int totalFields = 0;
        int completedFields = 0;

        // Check required fields
        Map<String, Integer> requiredFields = Map.of(
            "name", 10,
            "description", 10,
            "category", 10,
            "primaryImage", 15,
            "price", 10,
            "dimensions", 5,
            "weight", 5
        );

        requiredFields.forEach((field, weight) -> {
            totalFields += weight;
            if (hasField(product, field)) {
                completedFields += weight;
            }
        });

        // Check category-specific attributes
        Category category = product.getCategory();
        category.getRequiredAttributes().forEach(attr -> {
            totalFields += 5;
            if (product.hasAttribute(attr.getName())) {
                completedFields += 5;
            }
        });

        // Calculate score
        double score = (completedFields * 100.0) / totalFields;

        return CompletenessScore.builder()
            .score(score)
            .level(determineLevel(score))
            .missingFields(findMissingFields(product))
            .suggestions(generateSuggestions(product))
            .build();
    }
}