001// --------------------------------------------------------------------------------
002// Copyright 2002-2026 Echo Three, LLC
003//
004// Licensed under the Apache License, Version 2.0 (the "License");
005// you may not use this file except in compliance with the License.
006// You may obtain a copy of the License at
007//
008//     http://www.apache.org/licenses/LICENSE-2.0
009//
010// Unless required by applicable law or agreed to in writing, software
011// distributed under the License is distributed on an "AS IS" BASIS,
012// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013// See the License for the specific language governing permissions and
014// limitations under the License.
015// --------------------------------------------------------------------------------
016
017package com.echothree.model.control.order.server.logic;
018
019import com.echothree.control.user.order.common.spec.OrderPriorityUniversalSpec;
020import com.echothree.model.control.core.common.ComponentVendors;
021import com.echothree.model.control.core.common.EntityTypes;
022import com.echothree.model.control.core.common.exception.InvalidParameterCountException;
023import com.echothree.model.control.core.server.logic.EntityInstanceLogic;
024import com.echothree.model.control.order.common.exception.DuplicateOrderPriorityNameException;
025import com.echothree.model.control.order.common.exception.UnknownDefaultOrderPriorityException;
026import com.echothree.model.control.order.common.exception.UnknownDefaultOrderTypeException;
027import com.echothree.model.control.order.common.exception.UnknownOrderPriorityNameException;
028import com.echothree.model.control.order.server.control.OrderPriorityControl;
029import com.echothree.model.control.order.server.control.OrderTypeControl;
030import com.echothree.model.data.order.server.entity.OrderPriority;
031import com.echothree.model.data.order.server.entity.OrderType;
032import com.echothree.model.data.order.server.value.OrderPriorityDetailValue;
033import com.echothree.model.data.party.server.entity.Language;
034import com.echothree.util.common.message.ExecutionErrors;
035import com.echothree.util.common.persistence.BasePK;
036import com.echothree.util.server.control.BaseLogic;
037import com.echothree.util.server.message.ExecutionErrorAccumulator;
038import com.echothree.util.server.persistence.EntityPermission;
039import com.echothree.util.server.validation.ParameterUtils;
040import javax.inject.Inject;
041
042public class BaseOrderPriorityLogic
043        extends BaseLogic {
044
045    @Inject
046    OrderPriorityControl orderPriorityControl;
047
048    @Inject
049    OrderTypeControl orderTypeControl;
050
051    @Inject
052    EntityInstanceLogic entityInstanceLogic;
053
054    @Inject
055    OrderTypeLogic orderTypeLogic;
056
057    protected BaseOrderPriorityLogic() {
058        super();
059    }
060
061    public OrderPriority createOrderPriority(final ExecutionErrorAccumulator eea, final String orderTypeName, final String orderPriorityName,
062            final Integer priority, final Boolean isDefault, final Integer sortOrder, final Language language, final String description, final BasePK createdBy) {
063        var orderType = orderTypeLogic.getOrderTypeByName(eea, orderTypeName);
064        OrderPriority orderPriority = null;
065
066        if(eea == null || !eea.hasExecutionErrors()) {
067            orderPriority = createOrderPriority(eea, orderType, orderPriorityName, priority, isDefault, sortOrder, language, description, createdBy);
068        }
069
070        return orderPriority;
071    }
072
073    public OrderPriority createOrderPriority(final ExecutionErrorAccumulator eea, final OrderType orderType, final String orderPriorityName,
074            final Integer priority, final Boolean isDefault, final Integer sortOrder, final Language language, final String description, final BasePK createdBy) {
075        var orderPriority = orderPriorityControl.getOrderPriorityByName(orderType, orderPriorityName);
076
077        if(orderPriority == null) {
078            orderPriority = orderPriorityControl.createOrderPriority(orderType, orderPriorityName, priority, isDefault, sortOrder, createdBy);
079
080            if(description != null) {
081                orderPriorityControl.createOrderPriorityDescription(orderPriority, language, description, createdBy);
082            }
083        } else {
084            handleExecutionError(DuplicateOrderPriorityNameException.class, eea, ExecutionErrors.DuplicateOrderPriorityName.name(),
085                    orderType.getLastDetail().getOrderTypeName(), orderPriorityName);
086        }
087
088        return orderPriority;
089    }
090
091    public OrderPriority getOrderPriorityByName(final ExecutionErrorAccumulator eea, final OrderType orderType, final String orderPriorityName,
092            final EntityPermission entityPermission) {
093        var orderPriority = orderPriorityControl.getOrderPriorityByName(orderType, orderPriorityName, entityPermission);
094
095        if(orderPriority == null) {
096            handleExecutionError(UnknownOrderPriorityNameException.class, eea, ExecutionErrors.UnknownOrderPriorityName.name(),
097                    orderType.getLastDetail().getOrderTypeName(), orderPriorityName);
098        }
099
100        return orderPriority;
101    }
102
103    public OrderPriority getOrderPriorityByName(final ExecutionErrorAccumulator eea, final OrderType orderType, final String orderPriorityName) {
104        return getOrderPriorityByName(eea, orderType, orderPriorityName, EntityPermission.READ_ONLY);
105    }
106
107    public OrderPriority getOrderPriorityByNameForUpdate(final ExecutionErrorAccumulator eea, final OrderType orderType, final String orderPriorityName) {
108        return getOrderPriorityByName(eea, orderType, orderPriorityName, EntityPermission.READ_WRITE);
109    }
110
111    public OrderPriority getOrderPriorityByName(final ExecutionErrorAccumulator eea, final String orderTypeName, final String orderPriorityName,
112            final EntityPermission entityPermission) {
113        var orderType = orderTypeLogic.getOrderTypeByName(eea, orderTypeName);
114        OrderPriority orderPriority = null;
115
116        if(eea == null || !eea.hasExecutionErrors()) {
117            orderPriority = getOrderPriorityByName(eea, orderType, orderPriorityName, entityPermission);
118        }
119
120        return orderPriority;
121    }
122
123    public OrderPriority getOrderPriorityByName(final ExecutionErrorAccumulator eea, final String orderTypeName, final String orderPriorityName) {
124        return getOrderPriorityByName(eea, orderTypeName, orderPriorityName, EntityPermission.READ_ONLY);
125    }
126
127    public OrderPriority getOrderPriorityByNameForUpdate(final ExecutionErrorAccumulator eea, final String orderTypeName, final String orderPriorityName) {
128        return getOrderPriorityByName(eea, orderTypeName, orderPriorityName, EntityPermission.READ_WRITE);
129    }
130
131    public OrderPriority getOrderPriorityByUniversalSpec(final ExecutionErrorAccumulator eea, final OrderPriorityUniversalSpec universalSpec,
132            final boolean allowDefault, final EntityPermission entityPermission) {
133        var orderTypeName = universalSpec.getOrderTypeName();
134        var orderPriorityName = universalSpec.getOrderPriorityName();
135        var nameParameterCount= ParameterUtils.getInstance().countNonNullParameters(orderTypeName, orderPriorityName);
136        var possibleEntitySpecs= entityInstanceLogic.countPossibleEntitySpecs(universalSpec);
137        OrderPriority orderPriority = null;
138
139        if(nameParameterCount < 3 && possibleEntitySpecs == 0) {
140            OrderType orderType = null;
141
142            if(orderTypeName == null) {
143                if(allowDefault) {
144                    orderType = orderTypeControl.getDefaultOrderType();
145
146                    if(orderType == null) {
147                        handleExecutionError(UnknownDefaultOrderTypeException.class, eea, ExecutionErrors.UnknownDefaultOrderType.name());
148                    }
149                } else {
150                    handleExecutionError(InvalidParameterCountException.class, eea, ExecutionErrors.InvalidParameterCount.name());
151                }
152            } else {
153                orderType = orderTypeLogic.getOrderTypeByName(eea, orderTypeName);
154            }
155
156            if(eea == null || !eea.hasExecutionErrors()) {
157                if(orderPriorityName == null) {
158                    if(allowDefault) {
159                        orderPriority = orderPriorityControl.getDefaultOrderPriority(orderType, entityPermission);
160
161                        if(orderPriority == null) {
162                            handleExecutionError(UnknownDefaultOrderPriorityException.class, eea, ExecutionErrors.UnknownDefaultOrderPriority.name());
163                        }
164                    } else {
165                        handleExecutionError(InvalidParameterCountException.class, eea, ExecutionErrors.InvalidParameterCount.name());
166                    }
167                } else {
168                    orderPriority = getOrderPriorityByName(eea, orderType, orderPriorityName, entityPermission);
169                }
170            }
171        } else if(nameParameterCount == 0 && possibleEntitySpecs == 1) {
172            var entityInstance = entityInstanceLogic.getEntityInstance(eea, universalSpec,
173                    ComponentVendors.ECHO_THREE.name(), EntityTypes.OrderPriority.name());
174
175            if(eea == null || !eea.hasExecutionErrors()) {
176                orderPriority = orderPriorityControl.getOrderPriorityByEntityInstance(entityInstance, entityPermission);
177            }
178        } else {
179            handleExecutionError(InvalidParameterCountException.class, eea, ExecutionErrors.InvalidParameterCount.name());
180        }
181
182        return orderPriority;
183    }
184
185    public OrderPriority getOrderPriorityByUniversalSpec(final ExecutionErrorAccumulator eea, final OrderPriorityUniversalSpec universalSpec,
186            boolean allowDefault) {
187        return getOrderPriorityByUniversalSpec(eea, universalSpec, allowDefault, EntityPermission.READ_ONLY);
188    }
189
190    public OrderPriority getOrderPriorityByUniversalSpecForUpdate(final ExecutionErrorAccumulator eea, final OrderPriorityUniversalSpec universalSpec,
191            boolean allowDefault) {
192        return getOrderPriorityByUniversalSpec(eea, universalSpec, allowDefault, EntityPermission.READ_WRITE);
193    }
194
195    public void updateOrderPriorityFromValue(final ExecutionErrorAccumulator eea, OrderPriorityDetailValue orderPriorityDetailValue,
196            BasePK updatedBy) {
197        orderPriorityControl.updateOrderPriorityFromValue(orderPriorityDetailValue, updatedBy);
198    }
199
200    public void deleteOrderPriority(final ExecutionErrorAccumulator eea, final OrderPriority orderPriority,
201            final BasePK deletedBy) {
202        orderPriorityControl.deleteOrderPriority(orderPriority, deletedBy);
203    }
204
205}