/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.ofbiz.manufacturing.techdata;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import org.apache.ofbiz.base.util.Debug;
import org.apache.ofbiz.base.util.UtilDateTime;
import org.apache.ofbiz.base.util.UtilMisc;
import org.apache.ofbiz.base.util.UtilProperties;
import org.apache.ofbiz.base.util.UtilValidate;
import org.apache.ofbiz.entity.Delegator;
import org.apache.ofbiz.entity.GenericEntityException;
import org.apache.ofbiz.entity.GenericValue;
import org.apache.ofbiz.entity.condition.EntityCondition;
import org.apache.ofbiz.entity.condition.EntityExpr;
import org.apache.ofbiz.entity.condition.EntityOperator;
import org.apache.ofbiz.entity.util.EntityQuery;
import org.apache.ofbiz.entity.util.EntityUtil;
import org.apache.ofbiz.service.DispatchContext;
import org.apache.ofbiz.service.ServiceUtil;
import com.ibm.icu.util.Calendar;
/**
* TechDataServices - TechData related Services
*
*/
public class TechDataServices {
public static final String module = TechDataServices.class.getName();
public static final String resource = "ManufacturingUiLabels";
/**
*
* Used to retrieve some RoutingTasks (WorkEffort) selected by Name or MachineGroup ordered by Name
*
* @param ctx the dispatch context
* @param context a map containing workEffortName (routingTaskName) and fixedAssetId (MachineGroup or ANY)
* @return result a map containing lookupResult (list of RoutingTask <=> workEffortId with currentStatusId = "ROU_ACTIVE" and workEffortTypeId = "ROU_TASK"
*/
public static Map<String, Object> lookupRoutingTask(DispatchContext ctx, Map<String, ? extends Object> context) {
Delegator delegator = ctx.getDelegator();
Map<String, Object> result = new HashMap<String, Object>();
Locale locale = (Locale) context.get("locale");
String workEffortName = (String) context.get("workEffortName");
String fixedAssetId = (String) context.get("fixedAssetId");
List<GenericValue> listRoutingTask = null;
List<EntityExpr> constraints = new LinkedList<EntityExpr>();
if (UtilValidate.isNotEmpty(workEffortName)) {
constraints.add(EntityCondition.makeCondition("workEffortName", EntityOperator.GREATER_THAN_EQUAL_TO, workEffortName));
}
if (UtilValidate.isNotEmpty(fixedAssetId) && ! "ANY".equals(fixedAssetId)) {
constraints.add(EntityCondition.makeCondition("fixedAssetId", EntityOperator.EQUALS, fixedAssetId));
}
constraints.add(EntityCondition.makeCondition("currentStatusId", EntityOperator.EQUALS, "ROU_ACTIVE"));
constraints.add(EntityCondition.makeCondition("workEffortTypeId", EntityOperator.EQUALS, "ROU_TASK"));
try {
listRoutingTask = EntityQuery.use(delegator).from("WorkEffort")
.where(constraints)
.orderBy("workEffortName")
.queryList();
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ManufacturingTechDataWorkEffortNotExist", UtilMisc.toMap("errorString", e.toString()), locale));
}
if (listRoutingTask == null) {
listRoutingTask = new LinkedList<GenericValue>();
}
if (listRoutingTask.size() == 0) {
//FIXME is it correct ?
// listRoutingTask.add(UtilMisc.toMap("label","no Match","value","NO_MATCH"));
}
result.put("lookupResult", listRoutingTask);
return result;
}
/**
*
* Used to check if there is not two routing task with the same SeqId valid at the same period
*
* @param ctx The DispatchContext that this service is operating in.
* @param context a map containing workEffortIdFrom (routing) and SeqId, fromDate thruDate
* @return result a map containing sequenceNumNotOk which is equal to "Y" if it's not Ok
*/
public static Map<String, Object> checkRoutingTaskAssoc(DispatchContext ctx, Map<String, ? extends Object> context) {
Delegator delegator = ctx.getDelegator();
Map<String, Object> result = new HashMap<String, Object>();
String sequenceNumNotOk = "N";
Locale locale = (Locale) context.get("locale");
String workEffortIdFrom = (String) context.get("workEffortIdFrom");
String workEffortIdTo = (String) context.get("workEffortIdTo");
String workEffortAssocTypeId = (String) context.get("workEffortAssocTypeId");
Long sequenceNum = (Long) context.get("sequenceNum");
Timestamp fromDate = (Timestamp) context.get("fromDate");
Timestamp thruDate = (Timestamp) context.get("thruDate");
String create = (String) context.get("create");
boolean createProcess = (create !=null && create.equals("Y")) ? true : false;
List<GenericValue> listRoutingTaskAssoc = null;
try {
listRoutingTaskAssoc = EntityQuery.use(delegator).from("WorkEffortAssoc")
.where("workEffortIdFrom", workEffortIdFrom,"sequenceNum",sequenceNum)
.orderBy("fromDate")
.queryList();
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ManufacturingTechDataWorkEffortAssocNotExist", UtilMisc.toMap("errorString", e.toString()), locale));
}
if (listRoutingTaskAssoc != null) {
for (GenericValue routingTaskAssoc : listRoutingTaskAssoc) {
if (! workEffortIdFrom.equals(routingTaskAssoc.getString("workEffortIdFrom")) ||
! workEffortIdTo.equals(routingTaskAssoc.getString("workEffortIdTo")) ||
! workEffortAssocTypeId.equals(routingTaskAssoc.getString("workEffortAssocTypeId")) ||
! sequenceNum.equals(routingTaskAssoc.getLong("sequenceNum"))
) {
if (routingTaskAssoc.getTimestamp("thruDate") == null && routingTaskAssoc.getTimestamp("fromDate") == null) sequenceNumNotOk = "Y";
else if (routingTaskAssoc.getTimestamp("thruDate") == null) {
if (thruDate == null) sequenceNumNotOk = "Y";
else if (thruDate.after(routingTaskAssoc.getTimestamp("fromDate"))) sequenceNumNotOk = "Y";
}
else if (routingTaskAssoc.getTimestamp("fromDate") == null) {
if (fromDate == null) sequenceNumNotOk = "Y";
else if (fromDate.before(routingTaskAssoc.getTimestamp("thruDate"))) sequenceNumNotOk = "Y";
}
else if (fromDate == null && thruDate == null) sequenceNumNotOk = "Y";
else if (thruDate == null) {
if (fromDate.before(routingTaskAssoc.getTimestamp("thruDate"))) sequenceNumNotOk = "Y";
}
else if (fromDate == null) {
if (thruDate.after(routingTaskAssoc.getTimestamp("fromDate"))) sequenceNumNotOk = "Y";
}
else if (routingTaskAssoc.getTimestamp("fromDate").before(thruDate) && fromDate.before(routingTaskAssoc.getTimestamp("thruDate"))) sequenceNumNotOk = "Y";
} else if (createProcess) sequenceNumNotOk = "Y";
}
}
result.put("sequenceNumNotOk", sequenceNumNotOk);
return result;
}
/**
* Used to get the techDataCalendar for a routingTask, if there is a entity exception
* or routingTask associated with no MachineGroup the DEFAULT TechDataCalendar is return.
*
* @param routingTask the routingTask for which we are looking for
* @return the techDataCalendar associated
*/
public static GenericValue getTechDataCalendar(GenericValue routingTask) {
GenericValue machineGroup = null, techDataCalendar = null;
try {
machineGroup = routingTask.getRelatedOne("FixedAsset", true);
} catch (GenericEntityException e) {
Debug.logError("Pb reading FixedAsset associated with routingTask"+e.getMessage(), module);
}
if (machineGroup != null) {
if (machineGroup.getString("calendarId") != null) {
try {
techDataCalendar = machineGroup.getRelatedOne("TechDataCalendar", true);
} catch (GenericEntityException e) {
Debug.logError("Pb reading TechDataCalendar associated with machineGroup"+e.getMessage(), module);
}
} else {
try {
List<GenericValue> machines = machineGroup.getRelated("ChildFixedAsset", null, null, true);
if (machines != null && machines.size()>0) {
GenericValue machine = EntityUtil.getFirst(machines);
techDataCalendar = machine.getRelatedOne("TechDataCalendar", true);
}
} catch (GenericEntityException e) {
Debug.logError("Pb reading machine child from machineGroup"+e.getMessage(), module);
}
}
}
if (techDataCalendar == null) {
try {
Delegator delegator = routingTask.getDelegator();
techDataCalendar = EntityQuery.use(delegator).from("TechDataCalendar").where("calendarId", "DEFAULT").queryOne();
} catch (GenericEntityException e) {
Debug.logError("Pb reading TechDataCalendar DEFAULT"+e.getMessage(), module);
}
}
return techDataCalendar;
}
/** Used to find the fisrt day in the TechDataCalendarWeek where capacity != 0, beginning at dayStart, dayStart included.
*
* @param techDataCalendarWeek The TechDataCalendarWeek cover
* @param dayStart
* @return a map with the capacity (Double) available and moveDay (int): the number of day it's necessary to move to have capacity available
*/
public static Map<String, Object> dayStartCapacityAvailable(GenericValue techDataCalendarWeek, int dayStart) {
Map<String, Object> result = new HashMap<String, Object>();
int moveDay = 0;
Double capacity = null;
Time startTime = null;
while (capacity == null || capacity.doubleValue()==0) {
switch (dayStart) {
case Calendar.MONDAY:
capacity = techDataCalendarWeek.getDouble("mondayCapacity");
startTime = techDataCalendarWeek.getTime("mondayStartTime");
break;
case Calendar.TUESDAY:
capacity = techDataCalendarWeek.getDouble("tuesdayCapacity");
startTime = techDataCalendarWeek.getTime("tuesdayStartTime");
break;
case Calendar.WEDNESDAY:
capacity = techDataCalendarWeek.getDouble("wednesdayCapacity");
startTime = techDataCalendarWeek.getTime("wednesdayStartTime");
break;
case Calendar.THURSDAY:
capacity = techDataCalendarWeek.getDouble("thursdayCapacity");
startTime = techDataCalendarWeek.getTime("thursdayStartTime");
break;
case Calendar.FRIDAY:
capacity = techDataCalendarWeek.getDouble("fridayCapacity");
startTime = techDataCalendarWeek.getTime("fridayStartTime");
break;
case Calendar.SATURDAY:
capacity = techDataCalendarWeek.getDouble("saturdayCapacity");
startTime = techDataCalendarWeek.getTime("saturdayStartTime");
break;
case Calendar.SUNDAY:
capacity = techDataCalendarWeek.getDouble("sundayCapacity");
startTime = techDataCalendarWeek.getTime("sundayStartTime");
break;
}
if (capacity == null || capacity.doubleValue() == 0) {
moveDay +=1;
dayStart = (dayStart==7) ? 1 : dayStart +1;
}
}
result.put("capacity",capacity);
result.put("startTime",startTime);
result.put("moveDay",Integer.valueOf(moveDay));
return result;
}
/** Used to to request the remain capacity available for dateFrom in a TechDataCalenda,
* If the dateFrom (param in) is not in an available TechDataCalendar period, the return value is zero.
*
* @param techDataCalendar The TechDataCalendar cover
* @param dateFrom the date
* @return long capacityRemaining
*/
public static long capacityRemaining(GenericValue techDataCalendar, Timestamp dateFrom) {
GenericValue techDataCalendarWeek = null;
// TODO read TechDataCalendarExcWeek to manage execption week (maybe it's needed to refactor the entity definition
try {
techDataCalendarWeek = techDataCalendar.getRelatedOne("TechDataCalendarWeek", true);
} catch (GenericEntityException e) {
Debug.logError("Pb reading Calendar Week associated with calendar"+e.getMessage(), module);
return 0;
}
// TODO read TechDataCalendarExcDay to manage execption day
Calendar cDateTrav = Calendar.getInstance();
cDateTrav.setTime(dateFrom);
Map<String, Object> position = dayStartCapacityAvailable(techDataCalendarWeek, cDateTrav.get(Calendar.DAY_OF_WEEK));
int moveDay = ((Integer) position.get("moveDay")).intValue();
if (moveDay != 0) return 0;
Time startTime = (Time) position.get("startTime");
Double capacity = (Double) position.get("capacity");
Timestamp startAvailablePeriod = new Timestamp(UtilDateTime.getDayStart(dateFrom).getTime() + startTime.getTime() + cDateTrav.get(Calendar.ZONE_OFFSET) + cDateTrav.get(Calendar.DST_OFFSET));
if (dateFrom.before(startAvailablePeriod)) return 0;
Timestamp endAvailablePeriod = new Timestamp(startAvailablePeriod.getTime()+capacity.longValue());
if (dateFrom.after(endAvailablePeriod)) return 0;
return endAvailablePeriod.getTime() - dateFrom.getTime();
}
/** Used to move in a TechDataCalenda, produce the Timestamp for the begining of the next day available and its associated capacity.
* If the dateFrom (param in) is not in an available TechDataCalendar period, the return value is the next day available
*
* @param techDataCalendar The TechDataCalendar cover
* @param dateFrom the date
* @return a map with Timestamp dateTo, Double nextCapacity
*/
public static Map<String, Object> startNextDay(GenericValue techDataCalendar, Timestamp dateFrom) {
Map<String, Object> result = new HashMap<String, Object>();
Timestamp dateTo = null;
GenericValue techDataCalendarWeek = null;
// TODO read TechDataCalendarExcWeek to manage execption week (maybe it's needed to refactor the entity definition
try {
techDataCalendarWeek = techDataCalendar.getRelatedOne("TechDataCalendarWeek", true);
} catch (GenericEntityException e) {
Debug.logError("Pb reading Calendar Week associated with calendar"+e.getMessage(), module);
return ServiceUtil.returnError("Pb reading Calendar Week associated with calendar");
}
// TODO read TechDataCalendarExcDay to manage execption day
Calendar cDateTrav = Calendar.getInstance();
cDateTrav.setTime(dateFrom);
Map<String, Object> position = dayStartCapacityAvailable(techDataCalendarWeek, cDateTrav.get(Calendar.DAY_OF_WEEK));
Time startTime = (Time) position.get("startTime");
int moveDay = ((Integer) position.get("moveDay")).intValue();
dateTo = (moveDay == 0) ? dateFrom : UtilDateTime.getDayStart(dateFrom,moveDay);
Timestamp startAvailablePeriod = new Timestamp(UtilDateTime.getDayStart(dateTo).getTime() + startTime.getTime() + cDateTrav.get(Calendar.ZONE_OFFSET) + cDateTrav.get(Calendar.DST_OFFSET));
if (dateTo.before(startAvailablePeriod)) {
dateTo = startAvailablePeriod;
}
else {
dateTo = UtilDateTime.getNextDayStart(dateTo);
cDateTrav.setTime(dateTo);
position = dayStartCapacityAvailable(techDataCalendarWeek, cDateTrav.get(Calendar.DAY_OF_WEEK));
startTime = (Time) position.get("startTime");
moveDay = ((Integer) position.get("moveDay")).intValue();
if (moveDay != 0) dateTo = UtilDateTime.getDayStart(dateTo,moveDay);
dateTo.setTime(dateTo.getTime() + startTime.getTime() + cDateTrav.get(Calendar.ZONE_OFFSET) + cDateTrav.get(Calendar.DST_OFFSET));
}
result.put("dateTo",dateTo);
result.put("nextCapacity",position.get("capacity"));
return result;
}
/** Used to move forward in a TechDataCalenda, start from the dateFrom and move forward only on available period.
* If the dateFrom (param in) is not a available TechDataCalendar period, the startDate is the begining of the next day available
*
* @param techDataCalendar The TechDataCalendar cover
* @param dateFrom the start date
* @param amount the amount of millisecond to move forward
* @return the dateTo
*/
public static Timestamp addForward(GenericValue techDataCalendar, Timestamp dateFrom, long amount) {
Timestamp dateTo = (Timestamp) dateFrom.clone();
long nextCapacity = capacityRemaining(techDataCalendar, dateFrom);
if (amount <= nextCapacity) {
dateTo.setTime(dateTo.getTime()+amount);
amount = 0;
} else amount -= nextCapacity;
Map<String, Object> result = new HashMap<String, Object>();
while (amount > 0) {
result = startNextDay(techDataCalendar, dateTo);
dateTo = (Timestamp) result.get("dateTo");
nextCapacity = ((Double) result.get("nextCapacity")).longValue();
if (amount <= nextCapacity) {
dateTo.setTime(dateTo.getTime()+amount);
amount = 0;
} else amount -= nextCapacity;
}
return dateTo;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/** Used to find the last day in the TechDataCalendarWeek where capacity != 0, ending at dayEnd, dayEnd included.
*
* @param techDataCalendarWeek The TechDataCalendarWeek cover
* @param dayEnd
* @return a map with the capacity (Double) available, the startTime and moveDay (int): the number of day it's necessary to move to have capacity available
*/
public static Map<String, Object> dayEndCapacityAvailable(GenericValue techDataCalendarWeek, int dayEnd) {
Map<String, Object> result = new HashMap<String, Object>();
int moveDay = 0;
Double capacity = null;
Time startTime = null;
while (capacity == null || capacity.doubleValue() == 0) {
switch (dayEnd) {
case Calendar.MONDAY:
capacity = techDataCalendarWeek.getDouble("mondayCapacity");
startTime = techDataCalendarWeek.getTime("mondayStartTime");
break;
case Calendar.TUESDAY:
capacity = techDataCalendarWeek.getDouble("tuesdayCapacity");
startTime = techDataCalendarWeek.getTime("tuesdayStartTime");
break;
case Calendar.WEDNESDAY:
capacity = techDataCalendarWeek.getDouble("wednesdayCapacity");
startTime = techDataCalendarWeek.getTime("wednesdayStartTime");
break;
case Calendar.THURSDAY:
capacity = techDataCalendarWeek.getDouble("thursdayCapacity");
startTime = techDataCalendarWeek.getTime("thursdayStartTime");
break;
case Calendar.FRIDAY:
capacity = techDataCalendarWeek.getDouble("fridayCapacity");
startTime = techDataCalendarWeek.getTime("fridayStartTime");
break;
case Calendar.SATURDAY:
capacity = techDataCalendarWeek.getDouble("saturdayCapacity");
startTime = techDataCalendarWeek.getTime("saturdayStartTime");
break;
case Calendar.SUNDAY:
capacity = techDataCalendarWeek.getDouble("sundayCapacity");
startTime = techDataCalendarWeek.getTime("sundayStartTime");
break;
}
if (capacity == null || capacity.doubleValue() == 0) {
moveDay -=1;
dayEnd = (dayEnd==1) ? 7 : dayEnd - 1;
}
}
result.put("capacity",capacity);
result.put("startTime",startTime);
result.put("moveDay",Integer.valueOf(moveDay));
return result;
}
/** Used to request the remaining capacity available for dateFrom in a TechDataCalenda,
* If the dateFrom (param in) is not in an available TechDataCalendar period, the return value is zero.
*
* @param techDataCalendar The TechDataCalendar cover
* @param dateFrom the date
* @return long capacityRemaining
*/
public static long capacityRemainingBackward(GenericValue techDataCalendar, Timestamp dateFrom) {
GenericValue techDataCalendarWeek = null;
// TODO read TechDataCalendarExcWeek to manage exception week (maybe it's needed to refactor the entity definition
try {
techDataCalendarWeek = techDataCalendar.getRelatedOne("TechDataCalendarWeek", true);
} catch (GenericEntityException e) {
Debug.logError("Pb reading Calendar Week associated with calendar"+e.getMessage(), module);
return 0;
}
// TODO read TechDataCalendarExcDay to manage execption day
Calendar cDateTrav = Calendar.getInstance();
cDateTrav.setTime(dateFrom);
Map<String, Object> position = dayEndCapacityAvailable(techDataCalendarWeek, cDateTrav.get(Calendar.DAY_OF_WEEK));
int moveDay = ((Integer) position.get("moveDay")).intValue();
if (moveDay != 0) return 0;
Time startTime = (Time) position.get("startTime");
Double capacity = (Double) position.get("capacity");
Timestamp startAvailablePeriod = new Timestamp(UtilDateTime.getDayStart(dateFrom).getTime() + startTime.getTime() + cDateTrav.get(Calendar.ZONE_OFFSET) + cDateTrav.get(Calendar.DST_OFFSET));
if (dateFrom.before(startAvailablePeriod)) return 0;
Timestamp endAvailablePeriod = new Timestamp(startAvailablePeriod.getTime()+capacity.longValue());
if (dateFrom.after(endAvailablePeriod)) return 0;
return dateFrom.getTime() - startAvailablePeriod.getTime();
}
/** Used to move in a TechDataCalenda, produce the Timestamp for the end of the previous day available and its associated capacity.
* If the dateFrom (param in) is not in an available TechDataCalendar period, the return value is the previous day available
*
* @param techDataCalendar The TechDataCalendar cover
* @param dateFrom the date
* @return a map with Timestamp dateTo, Double previousCapacity
*/
public static Map<String, Object> endPreviousDay(GenericValue techDataCalendar, Timestamp dateFrom) {
Map<String, Object> result = new HashMap<String, Object>();
Timestamp dateTo = null;
GenericValue techDataCalendarWeek = null;
// TODO read TechDataCalendarExcWeek to manage exception week (maybe it's needed to refactor the entity definition
try {
techDataCalendarWeek = techDataCalendar.getRelatedOne("TechDataCalendarWeek", true);
} catch (GenericEntityException e) {
Debug.logError("Pb reading Calendar Week associated with calendar"+e.getMessage(), module);
return ServiceUtil.returnError("Pb reading Calendar Week associated with calendar");
}
// TODO read TechDataCalendarExcDay to manage execption day
Calendar cDateTrav = Calendar.getInstance();
cDateTrav.setTime(dateFrom);
Map<String, Object> position = dayEndCapacityAvailable(techDataCalendarWeek, cDateTrav.get(Calendar.DAY_OF_WEEK));
Time startTime = (Time) position.get("startTime");
int moveDay = ((Integer) position.get("moveDay")).intValue();
Double capacity = (Double) position.get("capacity");
dateTo = (moveDay == 0) ? dateFrom : UtilDateTime.getDayEnd(dateFrom, Long.valueOf(moveDay));
Timestamp endAvailablePeriod = new Timestamp(UtilDateTime.getDayStart(dateTo).getTime() + startTime.getTime() + capacity.longValue() + cDateTrav.get(Calendar.ZONE_OFFSET) + cDateTrav.get(Calendar.DST_OFFSET));
if (dateTo.after(endAvailablePeriod)) {
dateTo = endAvailablePeriod;
}
else {
dateTo = UtilDateTime.getDayStart(dateTo, -1);
cDateTrav.setTime(dateTo);
position = dayEndCapacityAvailable(techDataCalendarWeek, cDateTrav.get(Calendar.DAY_OF_WEEK));
startTime = (Time) position.get("startTime");
moveDay = ((Integer) position.get("moveDay")).intValue();
capacity = (Double) position.get("capacity");
if (moveDay != 0) dateTo = UtilDateTime.getDayStart(dateTo,moveDay);
dateTo.setTime(dateTo.getTime() + startTime.getTime() + capacity.longValue() + cDateTrav.get(Calendar.ZONE_OFFSET) + cDateTrav.get(Calendar.DST_OFFSET));
}
result.put("dateTo",dateTo);
result.put("previousCapacity",position.get("capacity"));
return result;
}
/** Used to move backward in a TechDataCalendar, start from the dateFrom and move backward only on available period.
* If the dateFrom (param in) is not a available TechDataCalendar period, the startDate is the end of the previous day available
*
* @param techDataCalendar The TechDataCalendar cover
* @param dateFrom the start date
* @param amount the amount of millisecond to move backward
* @return the dateTo
*/
public static Timestamp addBackward(GenericValue techDataCalendar, Timestamp dateFrom, long amount) {
Timestamp dateTo = (Timestamp) dateFrom.clone();
long previousCapacity = capacityRemainingBackward(techDataCalendar, dateFrom);
if (amount <= previousCapacity) {
dateTo.setTime(dateTo.getTime()-amount);
amount = 0;
} else amount -= previousCapacity;
Map<String, Object> result = new HashMap<String, Object>();
while (amount > 0) {
result = endPreviousDay(techDataCalendar, dateTo);
dateTo = (Timestamp) result.get("dateTo");
previousCapacity = ((Double) result.get("previousCapacity")).longValue();
if (amount <= previousCapacity) {
dateTo.setTime(dateTo.getTime()-amount);
amount = 0;
} else amount -= previousCapacity;
}
return dateTo;
}
}