Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  javax.jcr.Node
 *  javax.jcr.NodeIterator
 *  javax.jcr.Session
 *  javax.jcr.Workspace
 *  javax.jcr.nodetype.NodeType
 *  javax.jcr.query.Query
 *  javax.jcr.query.QueryManager
 *  javax.jcr.query.QueryResult
 *  org.apache.sling.api.resource.ModifiableValueMap
 *  org.apache.sling.api.resource.PersistenceException
 *  org.apache.sling.api.resource.Resource
 *  org.apache.sling.api.resource.ResourceResolver
 *  org.slf4j.Logger
 *  org.slf4j.LoggerFactory
 */
package com.adobe.cq.commerce.impl.classification;

import com.adobe.cq.commerce.api.CommerceException;
import com.adobe.cq.commerce.api.Product;
import com.adobe.cq.commerce.api.classification.Classification;
import com.adobe.cq.commerce.api.classification.ClassificationAttribute;
import com.adobe.cq.commerce.api.classification.ClassificationCategory;
import com.adobe.cq.commerce.api.classification.ClassificationManager;
import com.adobe.cq.commerce.impl.classification.ClassificationAttributeImpl;
import com.adobe.cq.commerce.impl.classification.ClassificationCategoryImpl;
import com.adobe.cq.commerce.impl.classification.ClassificationImpl;
import java.util.Calendar;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.Session;
import javax.jcr.Workspace;
import javax.jcr.nodetype.NodeType;
import javax.jcr.query.Query;
import javax.jcr.query.QueryManager;
import javax.jcr.query.QueryResult;
import org.apache.sling.api.resource.ModifiableValueMap;
import org.apache.sling.api.resource.PersistenceException;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ClassificationManagerImpl
implements ClassificationManager {
    protected static final String DEFAULT_CLASSIFICATION_ROOT = "/etc/commerce/classifications";
    protected final Logger log = LoggerFactory.getLogger(ClassificationManagerImpl.class);
    private ResourceResolver resolver;

    public ClassificationManagerImpl(ResourceResolver resolver) {
        this.resolver = resolver;
    }

    @Override
    public Classification getClassification(String path) {
        ClassificationImpl classification = null;
        Resource classificationRes = this.resolver.getResource(path);
        if (classificationRes == null) {
            return null;
        }
        try {
            classification = new ClassificationImpl(classificationRes);
        }
        catch (CommerceException e) {
            this.log.error("The resource at " + classificationRes.getPath() + " is not a classification", (Throwable)e);
        }
        return classification;
    }

    @Override
    public ClassificationCategory getCategory(String path) {
        ClassificationCategoryImpl category = null;
        Resource categoryRes = this.resolver.getResource(path);
        try {
            category = new ClassificationCategoryImpl(categoryRes);
        }
        catch (CommerceException e) {
            this.log.error("The resource at " + path + " is not a classification category", (Throwable)e);
        }
        return category;
    }

    @Override
    public ClassificationAttribute getAttribute(String path) {
        ClassificationAttributeImpl attribute = null;
        Resource attributeRes = this.resolver.getResource(path);
        try {
            attribute = new ClassificationAttributeImpl(attributeRes);
        }
        catch (CommerceException e) {
            this.log.error("The resource at " + path + " is not a classification category", (Throwable)e);
        }
        return attribute;
    }

    @Override
    public Classification createClassification(String parentPath, String name, Map<String, Object> properties) throws CommerceException {
        Resource classificationRes;
        Resource parentRes = this.resolver.getResource(parentPath);
        try {
            properties.put("cq:commerceType", "classification");
            if (properties.get("jcr:primaryType") == null) {
                properties.put("jcr:primaryType", "nt:unstructured");
            }
            classificationRes = this.resolver.create(parentRes, name, properties);
            this.updateLastModProps(classificationRes);
            this.resolver.commit();
        }
        catch (PersistenceException e) {
            throw new CommerceException("Failed to create a classification below " + parentPath, (Throwable)e);
        }
        return new ClassificationImpl(classificationRes);
    }

    @Override
    public void removeClassification(String path) throws CommerceException {
        Classification classification = this.getClassification(path);
        if (classification == null) {
            throw new CommerceException("The resource at " + path + " is not a classification");
        }
        Resource classificationRes = this.resolver.getResource(path);
        try {
            this.resolver.delete(classificationRes);
            this.resolver.commit();
        }
        catch (PersistenceException e) {
            throw new CommerceException("Failed to remove the classification at " + path, (Throwable)e);
        }
    }

    @Override
    public void updateClassification(String path, Map<String, Object> properties) throws CommerceException {
        Classification classification = this.getClassification(path);
        if (classification == null) {
            throw new CommerceException("The resource at " + path + " is not a classification");
        }
        Resource classificationRes = this.resolver.getResource(path);
        ModifiableValueMap currentProps = (ModifiableValueMap)classificationRes.adaptTo(ModifiableValueMap.class);
        currentProps.putAll(properties);
        this.updateLastModProps(classificationRes);
        try {
            this.resolver.commit();
        }
        catch (PersistenceException pe) {
            throw new CommerceException("Failed to update the classification at " + path, (Throwable)pe);
        }
    }

    @Override
    public ClassificationCategory addRootCategory(String path, Map<String, Object> properties) throws CommerceException {
        Classification classification = this.getClassification(path);
        if (classification == null) {
            throw new CommerceException("The resource at " + path + " is not a classification");
        }
        Resource classificationRes = this.resolver.getResource(path);
        Resource rootCategoryRes = classificationRes.getChild("rootcategory");
        if (rootCategoryRes != null) {
            throw new CommerceException("The classification at " + path + " has already a root category.");
        }
        try {
            properties.put("cq:commerceType", "classification.category");
            rootCategoryRes = this.resolver.create(classificationRes, "rootcategory", properties);
            this.updateLastModProps(rootCategoryRes);
            this.updateLastModProps(classificationRes);
            this.resolver.commit();
        }
        catch (PersistenceException pe) {
            throw new CommerceException("Failed to add the root category to the classification at " + path, (Throwable)pe);
        }
        return new ClassificationCategoryImpl(rootCategoryRes);
    }

    @Override
    public ClassificationCategory addCategory(String parentPath, String name, Map<String, Object> properties) throws CommerceException {
        Resource categoryRes;
        ClassificationCategory parentCategory = this.getCategory(parentPath);
        if (parentCategory == null) {
            this.log.error("The resource at {} is not a category.", (Object)parentPath);
            return null;
        }
        Resource parentCategoryRes = this.resolver.getResource(parentPath);
        Resource categoriesRes = parentCategoryRes.getChild("categories");
        try {
            if (categoriesRes == null) {
                categoriesRes = this.resolver.create(parentCategoryRes, "categories", null);
            }
            properties.put("cq:commerceType", "classification.category");
            categoryRes = this.createUniqueResource(categoriesRes, name, properties);
            this.updateLastModProps(categoryRes);
            if (parentCategory.getClassification() != null) {
                Resource classificationRes = this.resolver.getResource(parentCategory.getClassification().getPath());
                this.updateLastModProps(classificationRes);
            }
            this.resolver.commit();
        }
        catch (PersistenceException pe) {
            throw new CommerceException("Failed to add a sub-category to the category at " + parentPath, (Throwable)pe);
        }
        return new ClassificationCategoryImpl(categoryRes);
    }

    @Override
    public void removeCategory(String path) throws CommerceException {
        ClassificationCategory category = this.getCategory(path);
        if (category == null) {
            this.log.error("The resource at {} is not a category.", (Object)path);
            return;
        }
        Resource categoryRes = this.resolver.getResource(path);
        try {
            if (category.getClassification() != null) {
                Resource classificationRes = this.resolver.getResource(category.getClassification().getPath());
                this.updateLastModProps(classificationRes);
            }
            this.resolver.delete(categoryRes);
            this.resolver.commit();
        }
        catch (PersistenceException pe) {
            throw new CommerceException("Failed to remove the category at " + path, (Throwable)pe);
        }
    }

    @Override
    public void updateCategory(String path, Map<String, Object> properties) throws CommerceException {
        ClassificationCategory category = this.getCategory(path);
        if (category == null) {
            this.log.error("The resource at {} is not a category.", (Object)path);
            return;
        }
        Resource categoryRes = this.resolver.getResource(path);
        ModifiableValueMap currentProps = (ModifiableValueMap)categoryRes.adaptTo(ModifiableValueMap.class);
        currentProps.putAll(properties);
        this.updateLastModProps(categoryRes);
        if (category.getClassification() != null) {
            Resource classificationRes = this.resolver.getResource(category.getClassification().getPath());
            this.updateLastModProps(classificationRes);
        }
        try {
            this.resolver.commit();
        }
        catch (PersistenceException pe) {
            throw new CommerceException("Failed to update the category at " + path, (Throwable)pe);
        }
    }

    @Override
    public ClassificationAttribute addAttribute(String parentPath, String name, Map<String, Object> properties) throws CommerceException {
        Resource attributeRes;
        ClassificationCategory category = this.getCategory(parentPath);
        if (category == null) {
            this.log.error("The resource at {} is not a category.", (Object)parentPath);
            return null;
        }
        Resource categoryRes = this.resolver.getResource(parentPath);
        Resource attributesRes = categoryRes.getChild("attributes");
        try {
            if (attributesRes == null) {
                attributesRes = this.resolver.create(categoryRes, "attributes", null);
            }
            properties.put("cq:commerceType", "classification.attribute");
            attributeRes = this.createUniqueResource(attributesRes, name, properties);
            this.updateLastModProps(attributeRes);
            if (category.getClassification() != null) {
                Resource classificationRes = this.resolver.getResource(category.getClassification().getPath());
                this.updateLastModProps(classificationRes);
            }
            this.resolver.commit();
        }
        catch (PersistenceException pe) {
            throw new CommerceException("Failed to add an attribute to the category at {}" + parentPath, (Throwable)pe);
        }
        return new ClassificationAttributeImpl(attributeRes);
    }

    @Override
    public void removeAttribute(String path) throws CommerceException {
        ClassificationAttribute attribute = this.getAttribute(path);
        if (attribute == null) {
            this.log.error("The resource at {} is not an attribute.", (Object)path);
            return;
        }
        Resource attributeRes = this.resolver.getResource(path);
        try {
            if (this.getClassification(attribute) != null) {
                Resource classificationRes = this.resolver.getResource(this.getClassification(attribute).getPath());
                this.updateLastModProps(classificationRes);
            }
            this.resolver.delete(attributeRes);
            this.resolver.commit();
        }
        catch (PersistenceException pe) {
            throw new CommerceException("Failed to remove the attribute at " + path, (Throwable)pe);
        }
    }

    @Override
    public void updateAttribute(String path, Map<String, Object> properties) throws CommerceException {
        ClassificationAttribute attribute = this.getAttribute(path);
        if (attribute == null) {
            this.log.error("The resource at {} is not an attribute.", (Object)path);
            return;
        }
        Resource attributeRes = this.resolver.getResource(path);
        ModifiableValueMap currentProps = (ModifiableValueMap)attributeRes.adaptTo(ModifiableValueMap.class);
        currentProps.putAll(properties);
        this.updateLastModProps(attributeRes);
        if (this.getClassification(attribute) != null) {
            Resource classificationRes = this.resolver.getResource(this.getClassification(attribute).getPath());
            this.updateLastModProps(classificationRes);
        }
        try {
            this.resolver.commit();
        }
        catch (PersistenceException pe) {
            throw new CommerceException("Failed to update the attribute at " + path, (Throwable)pe);
        }
    }

    @Override
    public void orderBefore(String srcAttributePath, String destAttributePath) throws CommerceException {
        try {
            Session session = (Session)this.resolver.adaptTo(Session.class);
            Node srcNode = session.getNode(srcAttributePath);
            Node destNode = session.getNode(destAttributePath);
            Node parentNode = srcNode.getParent();
            String destName = destNode.getName();
            if (!parentNode.getPrimaryNodeType().hasOrderableChildNodes()) {
                throw new CommerceException("Folder does not support ordering: " + parentNode.getPath());
            }
            if (destName == null || parentNode.hasNode(destName)) {
                parentNode.orderBefore(srcNode.getName(), destName);
                session.save();
            }
        }
        catch (Exception e) {
            throw new CommerceException("Error while ordering " + srcAttributePath + " before " + destAttributePath, e);
        }
    }

    @Override
    public void assignProducts(String path, Map<String, Object> productListDefinition) throws CommerceException {
        ClassificationCategory category = this.getCategory(path);
        if (category == null) {
            this.log.error("The resource at {} is not a category.", (Object)path);
            return;
        }
        Resource categoryRes = this.resolver.getResource(path);
        Resource productsRes = categoryRes.getChild("products");
        try {
            if (productsRes == null) {
                productsRes = this.resolver.create(categoryRes, "products", null);
            }
            ModifiableValueMap currentProps = (ModifiableValueMap)productsRes.adaptTo(ModifiableValueMap.class);
            currentProps.putAll(productListDefinition);
            this.updateLastModProps(productsRes);
            if (category.getClassification() != null) {
                Resource classificationRes = this.resolver.getResource(category.getClassification().getPath());
                this.updateLastModProps(classificationRes);
            }
            this.resolver.commit();
        }
        catch (PersistenceException pe) {
            throw new CommerceException("Failed to assign products to the category at " + path, (Throwable)pe);
        }
    }

    @Override
    public Collection<Classification> getClassifications(Product product) {
        HashSet<Classification> classifications = new HashSet<Classification>();
        Collection<Classification> allClassifications = this.getAllClassifications();
        for (Classification classification : allClassifications) {
            if (!this.isAssigned(product, classification)) continue;
            classifications.add(classification);
        }
        return classifications;
    }

    @Override
    public Collection<ClassificationCategory> getClassificationCategories(Product product) {
        HashSet<ClassificationCategory> classificationCategories = new HashSet<ClassificationCategory>();
        Collection<Classification> allClassifications = this.getAllClassifications();
        for (Classification classification : allClassifications) {
            ClassificationCategory category = this.getClassificationCategory(product, classification);
            if (category == null) continue;
            classificationCategories.add(category);
        }
        return classificationCategories;
    }

    @Override
    public Collection<Classification> getClassifications(List<Product> products) {
        HashSet<String> classificationIds = new HashSet<String>();
        for (Product product : products) {
            Collection<Classification> productClassifications = this.getClassifications(product);
            for (Classification classification : productClassifications) {
                String classificationId = classification.getPath();
                if (classificationIds.contains(classificationId)) continue;
                classificationIds.add(classificationId);
            }
        }
        HashSet<Classification> classifications = new HashSet<Classification>();
        for (String classificationId : classificationIds) {
            Classification c = this.getClassification(classificationId);
            classifications.add(c);
        }
        return classifications;
    }

    @Override
    public Collection<ClassificationCategory> getClassificationCategories(List<Product> products) {
        HashSet<String> categoryIds = new HashSet<String>();
        for (Product product : products) {
            Collection<ClassificationCategory> productClassificationCategories = this.getClassificationCategories(product);
            for (ClassificationCategory category : productClassificationCategories) {
                String categoryId = category.getPath();
                if (categoryIds.contains(categoryId)) continue;
                categoryIds.add(categoryId);
            }
        }
        HashSet<ClassificationCategory> classificationCategories = new HashSet<ClassificationCategory>();
        for (String categoryId : categoryIds) {
            ClassificationCategory c = this.getCategory(categoryId);
            classificationCategories.add(c);
        }
        return classificationCategories;
    }

    private boolean isAssigned(Product product, Classification classification) {
        ClassificationCategory category = this.getClassificationCategory(product, classification);
        return category != null;
    }

    private ClassificationCategory getClassificationCategory(Product product, Classification classification) {
        ClassificationCategory rootCategory = classification.getRootCategory();
        ClassificationCategory category = this.getMatchingCategory(product, rootCategory);
        return category;
    }

    private ClassificationCategory getMatchingCategory(Product product, ClassificationCategory baseCategory) {
        ClassificationCategory matchingCategory = null;
        if (baseCategory != null) {
            if (baseCategory.hasDirectProduct(product)) {
                return baseCategory;
            }
            List<ClassificationCategory> subCategories = baseCategory.getSubCategories();
            if (subCategories != null) {
                for (ClassificationCategory subCategory : subCategories) {
                    if (matchingCategory != null) continue;
                    matchingCategory = this.getMatchingCategory(product, subCategory);
                }
            }
        }
        return matchingCategory;
    }

    private Collection<Classification> getAllClassifications() {
        HashSet<Classification> classifications = new HashSet<Classification>();
        String searchQuery = "/jcr:root/etc/commerce/classifications//element(*,nt:base)[@cq:commerceType='classification']";
        Session session = (Session)this.resolver.adaptTo(Session.class);
        try {
            Query jcrQuery = session.getWorkspace().getQueryManager().createQuery(searchQuery, "xpath");
            NodeIterator iterator = jcrQuery.execute().getNodes();
            while (iterator != null && iterator.hasNext()) {
                Resource r = this.resolver.getResource(iterator.nextNode().getPath());
                Classification c = (Classification)r.adaptTo(Classification.class);
                if (c == null) continue;
                classifications.add(c);
            }
        }
        catch (Exception e) {
            this.log.error("Classification data search failed", (Throwable)e);
        }
        return classifications;
    }

    private Resource createUniqueResource(Resource parent, String nameHint, Map<String, Object> properties) throws PersistenceException {
        String childName;
        Resource child = parent.getChild(nameHint);
        if (child == null) {
            return this.resolver.create(parent, nameHint, properties);
        }
        int i = 0;
        do {
            childName = nameHint + String.valueOf(i);
            ++i;
        } while (parent.getChild(childName) != null);
        return this.resolver.create(parent, childName, properties);
    }

    private void updateLastModProps(Resource resource) {
        if (resource == null) {
            return;
        }
        ModifiableValueMap currentProps = (ModifiableValueMap)resource.adaptTo(ModifiableValueMap.class);
        currentProps.put((Object)"jcr:lastModifiedBy", (Object)this.resolver.getUserID());
        currentProps.put((Object)"jcr:lastModified", (Object)Calendar.getInstance());
    }

    private Classification getClassification(ClassificationAttribute attribute) {
        if (attribute == null) {
            this.log.error("The attribute does not exist");
            return null;
        }
        String attributePath = attribute.getPath();
        Resource attributeRes = this.resolver.getResource(attributePath);
        if (attributeRes == null || attributeRes.getParent() == null || attributeRes.getParent().getParent() == null) {
            this.log.error("The attribute does not belong to a category");
            return null;
        }
        Resource categoryRes = attributeRes.getParent().getParent();
        ClassificationCategory category = this.getCategory(categoryRes.getPath());
        if (category == null) {
            this.log.error("The category of the attribute at {} is not defined", (Object)attribute.getPath());
            return null;
        }
        return category.getClassification();
    }
}