Files
ofbiz-framework/framework/common/groovyScripts/CommonServices.groovy
T
Jacques Le Roux e0c8a1f4b0 Fixed: 'FindJob' generates an error
(OFBIZ-11590)

This is due to OFBIZ-11402. Handling a converter for java.time.ZoneRegion is
complicated. Adding a toString() is enough.

Also 2 automated formatting while at it...
2020-04-14 13:42:11 +02:00

356 lines
12 KiB
Groovy

/*
* 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.
*/
import java.math.RoundingMode
import java.sql.Timestamp
import org.apache.ofbiz.base.util.UtilDateTime
import org.apache.ofbiz.base.util.UtilProperties
import org.apache.ofbiz.common.CommonWorkers
import org.apache.ofbiz.entity.GenericValue
/**
* Main permission logic
*/
def commonGenericPermission() {
parameters.primaryPermission = "COMMON"
Map result = run service: "genericBasePermissionCheck", with: parameters
return result
}
/**
* Convert UOM values
*/
def convertUom() {
// base case: if both uomIds are the same, return the original value
Map result = success()
Timestamp asOfDate
GenericValue uomConversion
RoundingMode roundingMode
int decimalScale
BigDecimal convertedValue
// setting up default parameters if not specified
if (!parameters.defaultRoundingMode) {
parameters.defaultRoundingMode = RoundingMode.HALF_EVEN
}
if (!parameters.defaultDecimalScale) {
parameters.defaultDecimalScale = 2
}
if (parameters.uomId == parameters.uomIdTo) {
result.convertedValue = parameters.originalValue
return result
}
asOfDate = parameters.asOfDate ?: UtilDateTime.nowTimestamp()
//first try the UomConversionDated entity
Map condition = [uomId: parameters.uomId,
uomIdTo: parameters.uomIdTo]
if (parameters.purposeEnumId) {
condition.purposeEnumId = parameters.purposeEnumId
}
// sort by descending fromDate to get newest (biggest) first
uomConversion = from("UomConversionDated")
.where(condition)
.orderBy("-fromDate")
.filterByDate(asOfDate)
.cache()
.queryFirst()
// if no conversion found with specified purpose, try w/o purpose
if (!uomConversion) {
if (parameters.purposeEnumId) {
uomConversion = from("UomConversionDated")
.where(uomId: parameters.uomId,
uomIdTo: parameters.uomIdTo)
.orderBy("-fromDate")
.filterByDate(asOfDate)
.cache()
.queryFirst()
}
}
// if not found, try the uom conversion entity
if (!uomConversion) {
uomConversion = from("UomConversion").where(parameters).cache().queryOne()
}
logVerbose("using conversion factor=${uomConversion.conversionFactor}")
if (!uomConversion) {
// if still no uom conversion entity, then no conversion is possible
return error(UtilProperties.getMessage("CommonUiLabels", "CommonNoUomConversionFound", parameters.locale))
}
else {
// Do custom conversion, if we have customMethodId
if (uomConversion.customMethodId) { //custom conversion?
logVerbose("using custom conversion customMethodId=${uomConversion.customMethodId}")
Map customParms = parameters.convertUom
customParms.uomConversion = uomConversion
Map serviceResult = run service: "convertUomCustom", with: customParms
convertedValue = serviceResult.convertedValue
logVerbose("Custom UoM conversion returning convertedValue=${convertedValue}")
}
else { // not custom conversion
// do the conversion
if (parameters.originalValue && uomConversion.conversionFactor) {
convertedValue = (parameters.originalValue).multiply(BigDecimal.valueOf(uomConversion.conversionFactor))
convertedValue = convertedValue.setScale(15, RoundingMode.HALF_EVEN)
}
} //custom conversion?
// round result, if UomConversion[Dated] so specifies
decimalScale = uomConversion.decimalScale ?: parameters.defaultDecimalScale
roundingMode = uomConversion.roundingMode ?: parameters.defaultRoundingMode
if (parameters.defaultRoundingMode != roundingMode) {
convertedValue = convertedValue.setScale(decimalScale, roundingMode)
}
} // no UomConversion or UomConversionDated found
// all done
result.convertedValue = convertedValue
logVerbose("""Uom conversion of [${parameters.originalValue}] from [${parameters.uomId}]
to [${parameters.uomIdTo}] using conversion factor [${uomConversion.conversionFactor}],
result is [${convertedValue}]""")
return result
}
// convertUomCustom: Dispatcher for calling Custom Method for UoM conversion
/**
* Convert UOM values using CustomMethod
*/
def convertUomCustom() {
Map result = success()
Map uomConversion = parameters.uomConversion
String customMethodId = uomConversion.customMethodId
GenericValue customMethod = from("CustomMethod").where(customMethodId: customMethodId).cache().queryOne()
if (!customMethod?.customMethodName) {
return error(UtilProperties.getMessage("CommonUiLabels", "CommonNoCustomMethodName", parameters.locale))
} else {
logVerbose("calling custom method" + customMethod.customMethodName)
Map serviceResult = run service: customMethod.customMethodName, with: [arguments: parameters]
result.convertedValue = serviceResult.convertedValue
}
return result
}
/**
* Look up progress made in File Upload process
*/
def getFileUploadProgressStatus() {
GenericValue uploadProgressListener = parameters.uploadProgressListener
Map result = success()
if (uploadProgressListener) {
result.contentLength = uploadProgressListener.getContentLength
result.bytesRead = uploadProgressListener.getBytesRead
result.hasStarted = uploadProgressListener.hasStarted
result.readPercent = (result.bytesRead * 100) / result.contentLength
}
return result
}
/**
* Get visual theme resources
*/
def getVisualThemeResources() {
Map result = success()
String visualThemeId = parameters.visualThemeId
Map themeResources = parameters.themeResources ?: [:]
List resourceList = from("VisualThemeResource")
.where(visualThemeId: visualThemeId)
.orderBy("resourceTypeEnumId", "sequenceId")
.cache()
.queryList()
if (!resourceList) {
// if not found use the good old initial ofbiz theme so the system will at least start up and will be usable
logWarning("Could not find the ${visualThemeId} theme, reverting back to the good old OFBiz theme...")
visualThemeId = UtilProperties.getPropertyValue("general", "VISUAL_THEME", "FLAT_GREY")
resourceList = from("VisualThemeResource")
.where(visualThemeId: visualThemeId)
.orderBy("resourceTypeEnumId", "sequenceId")
.cache()
.queryList()
}
if (!resourceList) {
return error(UtilProperties.getMessage("CommonUiLabels", "CommonVisualThemeResourcesNotFound", parameters.locale))
}
for (GenericValue resourceRecord : resourceList) {
String resourceTypeEnumId = resourceRecord.resourceTypeEnumId
String resourceValue = resourceRecord.resourceValue
if (!resourceValue) {
logWarning(UtilProperties.getMessage("CommonUiLabels", "CommonVisualThemeInvalidRecord", parameters.locale))
}
else {
themeResources[resourceTypeEnumId] = [resouceTypeEnumId: resourceValue]
}
}
result.themeResources = themeResources
return result
}
/**
* Returns a list of country
*/
def getCountryList() {
Map result = success()
List countryList = []
List geoList = CommonWorkers.getCountryList(delegator)
for (GenericValue countryGeo : geoList) {
countryList << countryGeo.geoName + ": " + countryGeo.geoId
}
result.countryList = countryList
return result
}
/**
* set the state options for selected country
*/
def getAssociatedStateList() {
Map result = success()
List stateList = []
List geoList = CommonWorkers.getAssociatedStateList(delegator, parameters.countryGeoId, parameters.listOrderBy)
for (GenericValue stateGeo : geoList) {
String stateName = stateGeo.geoName + ": " + stateGeo.geoId
stateList << stateName
}
if (!stateList) {
stateList << UtilProperties.getMessage("CommonUiLabels", "CommonNoStatesProvinces", parameters.locale)
}
result.stateList = stateList
return result
}
/**
* Link Geos to another Geo
*/
def linkGeos() {
List oldGeoIds = from("GeoAssoc")
.where(geoId: parameters.geoId,
geoAssocTypeId: parameters.geoAssocTypeId)
.cache()
.getFieldList('geoIdTo')
// Old list contains current values
for (String geoIdTo : parameters.geoIds) {
if (!oldGeoIds?.contains(geoIdTo)) {
// If it already exist, nothing to do and we keep it
GenericValue oldGeoAssoc = from("GeoAssoc").where(geoId: parameters.geoId, geoIdTo: geoIdTo).queryOne()
if (!oldGeoAssoc) {
// Add as it does not exist
GenericValue newGeoAssoc = makeValue("GeoAssoc", [
geoId : parameters.geoId,
geoIdTo : geoIdTo,
geoAssocTypeId : parameters.geoAssocTypeId
])
newGeoAssoc.create()
}
}
}
return success()
}
/**
* get related geos to a geo through a geoAssoc
* @return
*/
def getRelatedGeos() {
Map result = success()
List geoList = from("GeoAssoc")
.where(geoId: parameters.geoId, geoAssocTypeId: parameters.geoAssocTypeId)
.getFieldList('geoIdTo')
if (!geoList) {
geoList << "____"
}
result.geoList = geoList
return result
}
/**
* Returns true if an UomConversion record exists
*/
def checkUomConversion() {
Map result = success()
result.exist = from("UomConversion").where(uomId: parameters.uomId, uomIdTo: parameters.uomIdTo).queryCount() == 1
return result
}
/**
* Returns true if an UomConversionDated record exists
*/
def checkUomConversionDated() {
Map result = success()
Map condition = [
uomId: parameters.uomId,
uomIdTo: parameters.uomIdTo
]
if (parameters.purposeEnumId) {
condition.purposeEnumId = parameters.purposeEnumId
}
result.exist = from("UomConversion").where(condition).filterByDate().queryCount() == 1
return result
}
def getServerTimestamp() {
Map result = success()
result.serverTimestamp = UtilDateTime.nowTimestamp()
return result
}
def getServerTimeZone() {
Map result = success()
result.serverTimeZone = TimeZone.getDefault().toZoneId().toString()
return result
}
def getServerTimestampAsLong() {
Map result = success()
result.serverTimestamp = UtilDateTime.nowTimestamp().getTime()
return result
}
/**
* Create a KeywordThesaurus
* @return
*/
def createKeywordThesaurus() {
GenericValue newEntity = makeValue("KeywordThesaurus", parameters)
newEntity.enteredKeyword = newEntity.enteredKeyword.toLowerCase()
newEntity.alternateKeyword = newEntity.alternateKeyword.toLowerCase()
newEntity.create()
return success()
}
/**
* Delete a complete Entry KeywordThesaurus
* @return
*/
def deleteKeywordThesaurus() {
GenericValue newEntity = makeValue("KeywordThesaurus")
newEntity.enteredKeyword = parameters.enteredKeyword
if (parameters.alternateKeyword) {
newEntity.alternateKeyword = parameters.alternateKeyword
}
delegator.removeByAnd("KeywordThesaurus", newEntity)
return success()
}