Codenarc integration

applications/accounting/groovyScripts/admin/AcctgAdminServices.groovy

@@ -25,45 +25,47 @@ import org.apache.ofbiz.entity.GenericValue
 import org.apache.ofbiz.entity.util.EntityUtil
 import org.apache.ofbiz.service.ModelService
 
-
-def createPartyAcctgPreference() {
+Map createPartyAcctgPreference() {
     //check that the party is an INTERNAL_ORGANIZATION, as defined in PartyRole
-    partyRole = select().from('PartyRole').where([partyId:parameters.partyId,roleTypeId:"INTERNAL_ORGANIZATIO"]).queryOne()
+    partyRole = select().from('PartyRole').where([partyId: parameters.partyId, roleTypeId: 'INTERNAL_ORGANIZATIO']).queryOne()
     if (!partyRole) {
-        String errorMessage = UtilProperties.getMessage("AccountingUiLabels","AccountingPartyMustBeInternalOrganization", locale)
+        String errorMessage = UtilProperties.getMessage('AccountingUiLabels', 'AccountingPartyMustBeInternalOrganization', locale)
         logError(errorMessage)
         return error(errorMessage)
     }
     //Does not check if the Party is actually a company because real people have to pay taxes too
 
     //TODO: maybe check to make sure that all fields are not null
-    newEntity = delegator.makeValidValue("PartyAcctgPreference", parameters)
+    newEntity = delegator.makeValidValue('PartyAcctgPreference', parameters)
     delegator.create(newEntity)
     return success()
 }
 
-def getPartyAccountingPreferences() {
+Map getPartyAccountingPreferences() {
     Map result = success()
-    GenericValue aggregatedPartyAcctgPref = delegator.makeValidValue("PartyAcctgPreference", parameters)
+    GenericValue aggregatedPartyAcctgPref = delegator.makeValidValue('PartyAcctgPreference', parameters)
     String currentOrganizationPartyId = parameters.organizationPartyId
     Boolean containsEmptyFields = true
 
     while (currentOrganizationPartyId && containsEmptyFields) {
-        GenericValue currentPartyAcctgPref = select().from('PartyAcctgPreference').where([partyId:currentOrganizationPartyId]).queryOne()
+        GenericValue currentPartyAcctgPref = select().from('PartyAcctgPreference').where([partyId: currentOrganizationPartyId]).queryOne()
         containsEmptyFields = false
         if (currentPartyAcctgPref) {
             for (String entityKey : currentPartyAcctgPref.keySet()) {
                 Object entityValue = currentPartyAcctgPref.get(entityKey)
                 if (entityValue) {
-                    aggregatedPartyAcctgPref.put(entityKey,entityValue)
+                    aggregatedPartyAcctgPref.put(entityKey, entityValue)
                 } else {
                     containsEmptyFields = true
                 }
             }
         } else {
             containsEmptyFields = true
         }
-        List<GenericValue> parentPartyRelationships = select().from('PartyRelationship').where([partyIdTo:currentOrganizationPartyId, partyRelationshipTypeId:"GROUP_ROLLUP", roleTypeIdFrom:"_NA_", roleTypeIdTo:"_NA_"]).filterByDate().queryList()
+        List<GenericValue> parentPartyRelationships = select().from('PartyRelationship')
+                .where([partyIdTo: currentOrganizationPartyId, partyRelationshipTypeId: 'GROUP_ROLLUP', roleTypeIdFrom: '_NA_',
+                        roleTypeIdTo: '_NA_'])
+                .filterByDate().queryList()
         if (parentPartyRelationships) {
             GenericValue parentPartyRelationship = EntityUtil.getFirst(parentPartyRelationships)
             currentOrganizationPartyId = parentPartyRelationship.partyIdFrom
@@ -73,34 +75,32 @@ def getPartyAccountingPreferences() {
     }
 
     if (aggregatedPartyAcctgPref) {
-        aggregatedPartyAcctgPref.put("partyId",parameters.organizationPartyId)
-        result.put("partyAccountingPreference", aggregatedPartyAcctgPref)
+        aggregatedPartyAcctgPref.put('partyId', parameters.organizationPartyId)
+        result.put('partyAccountingPreference', aggregatedPartyAcctgPref)
     }
     return result
 }
 
-def setAcctgCompany() {
+Map setAcctgCompany() {
     Map result = success()
     //Set user preference
     GenericValue partyAcctgPreference = select().from('PartyAcctgPreference').where([partyId: parameters.organizationPartyId]).queryOne()
     if (partyAcctgPreference) {
-        result = runService("setUserPreference", [userPrefValue: parameters.organizationPartyId, userPrefGroupTypeId: "GLOBAL_PREFERENCES", userPrefTypeId: "ORGANIZATION_PARTY"])
+        result = runService('setUserPreference',
+                [userPrefValue: parameters.organizationPartyId, userPrefGroupTypeId: 'GLOBAL_PREFERENCES', userPrefTypeId: 'ORGANIZATION_PARTY'])
     }
-    result.put("organizationPartyId", parameters.organizationPartyId)
+    result.put('organizationPartyId', parameters.organizationPartyId)
 
     return result
 }
 
-def updateFXConversion() {
+Map updateFXConversion() {
     //Set the FX rate changes as of now
-    Timestamp nowTimestamp = parameters.asOfTimestamp
-    if (!nowTimestamp) {
-        nowTimestamp = UtilDateTime.nowTimestamp()
-    }
+    Timestamp nowTimestamp = parameters.asOfTimestamp ?: UtilDateTime.nowTimestamp()
 
     //find the existing exchange rates for this currency pair
     exprBldr = new EntityConditionBuilder()
-    condition = exprBldr.AND() {
+    condition = exprBldr.AND {
         EQUALS(uomId: parameters.uomId)
         EQUALS(uomIdTo: parameters.uomIdTo)
     }
@@ -109,38 +109,35 @@ def updateFXConversion() {
             EQUALS(purposeEnumId: parameters.purposeEnumId)
         }
     }
-    List<GenericValue> uomConversions = select().from('UomConversionDated').where(condition).orderBy("-fromDate").filterByDate().queryList()
+    List<GenericValue> uomConversions = select().from('UomConversionDated').where(condition).orderBy('-fromDate').filterByDate().queryList()
 
     //expire all of them
     for (GenericValue uomConversion : uomConversions) {
-        if (!parameters.fromDate) {
-            uomConversion.put("thruDate", nowTimestamp)
+        if (parameters.fromDate) {
+            uomConversion.put('thruDate', parameters.fromDate)
         } else {
-            uomConversion.put("thruDate", parameters.fromDate)
+            uomConversion.put('thruDate', nowTimestamp)
         }
     }
     delegator.storeAll(uomConversions)
 
     //now create a new conversion relationship
-    Map createParams = dispatcher.getDispatchContext().makeValidContext("createUomConversionDated", ModelService.IN_PARAM, parameters)
+    Map createParams = dispatcher.getDispatchContext().makeValidContext('createUomConversionDated', ModelService.IN_PARAM, parameters)
     if (!parameters.fromDate) {
-        createParams.put("fromDate", nowTimestamp)
+        createParams.put('fromDate', nowTimestamp)
     }
-    result = runService("createUomConversionDated", createParams)
+    result = runService('createUomConversionDated', createParams)
 
     return success()
 }
 
-def getFXConversion() {
+Map getFXConversion() {
     Map result = success()
-    Timestamp asOfTimestamp = parameters.asOfTimestamp
-    if (!asOfTimestamp) {
-        asOfTimestamp = UtilDateTime.nowTimestamp()
-    }
+    Timestamp asOfTimestamp = parameters.asOfTimestamp ?: UtilDateTime.nowTimestamp()
 
     //find the existing exchange rates
     exprBldr = new EntityConditionBuilder()
-    thruDateCondition = exprBldr.OR() {
+    thruDateCondition = exprBldr.OR {
         EQUALS(thruDate: null)
         GREATER_THAN_EQUAL_TO(thruDate: asOfTimestamp)
     }
@@ -154,20 +151,20 @@ def getFXConversion() {
             EQUALS(purposeEnumId: parameters.purposeEnumId)
         }
     }
-    List<GenericValue> rates = select().from('UomConversionDated').where(condition).orderBy("-fromDate").filterByDate().queryList()
+    List<GenericValue> rates = select().from('UomConversionDated').where(condition).orderBy('-fromDate').filterByDate().queryList()
 
     BigDecimal conversionRate
     int decimalScale = 2
     int roundingMode = BigDecimal.ROUND_HALF_UP
     if (rates) {
-        conversionFactor = EntityUtil.getFirst(rates).getBigDecimal("conversionFactor")
+        conversionFactor = EntityUtil.getFirst(rates).getBigDecimal('conversionFactor')
         BigDecimal originalValue = BigDecimal.ONE
         conversionRate = originalValue.divide(conversionFactor, decimalScale, roundingMode)
     } else {
-        String errorMessage = "Could not find conversion rate"
+        String errorMessage = 'Could not find conversion rate'
         logError(errorMessage)
         return error(errorMessage)
     }
-    result.put("conversionRate",conversionRate)
+    result.put('conversionRate', conversionRate)
     return result
-}
+}

applications/accounting/groovyScripts/admin/FilterOutReceipts.groovy

@@ -20,4 +20,4 @@
 
 import org.apache.ofbiz.accounting.util.UtilAccounting
 
-context.payments.removeAll{UtilAccounting.isReceipt(it)}
+context.payments.removeAll { UtilAccounting.isReceipt(it) }

applications/accounting/groovyScripts/admin/ListInvoiceItemTypesGlAccount.groovy

@@ -20,8 +20,8 @@
 import org.apache.ofbiz.entity.condition.EntityConditionBuilder
 
 // Optional prefix parameter to filter InvoiceItemTypes by (i.e. "INV" or "PINV") defaults to INV
-invItemTypePrefix = context.invItemTypePrefix ?: "INV"
-invItemTypePrefix += "_%"
+invItemTypePrefix = context.invItemTypePrefix ?: 'INV'
+invItemTypePrefix += '_%'
 
 organizationPartyId = parameters.organizationPartyId
 exprBldr = new EntityConditionBuilder()
@@ -30,25 +30,25 @@ invoiceItemTypes = from('InvoiceItemType').where(exprBldr.LIKE(invoiceItemTypeId
 context.invoiceItemTypes = invoiceItemTypes.collect { invoiceItemType ->
     defaultAccount = true
     glAccount = null
-    invoiceItemTypeOrgs = invoiceItemType.getRelated("InvoiceItemTypeGlAccount", [organizationPartyId : organizationPartyId], null, false)
+    invoiceItemTypeOrgs = invoiceItemType.getRelated('InvoiceItemTypeGlAccount', [organizationPartyId: organizationPartyId], null, false)
     overrideGlAccountId = null
     if (invoiceItemTypeOrgs) {
         invoiceItemTypeOrg = invoiceItemTypeOrgs[0]
         overrideGlAccountId = invoiceItemTypeOrg.glAccountId
 
-        glAccounts = invoiceItemTypeOrg.getRelated("GlAccount", null, null, false)
+        glAccounts = invoiceItemTypeOrg.getRelated('GlAccount', null, null, false)
         if (glAccounts) {
             glAccount = glAccounts[0]
             defaultAccount = false
         }
     } else {
-        glAccount = invoiceItemType.getRelatedOne("DefaultGlAccount", false)
+        glAccount = invoiceItemType.getRelatedOne('DefaultGlAccount', false)
     }
 
-    return [invoiceItemTypeId : invoiceItemType.invoiceItemTypeId,
-                  description : invoiceItemType.description,
-                  defaultGlAccountId : invoiceItemType.defaultGlAccountId,
-                  overrideGlAccountId : overrideGlAccountId,
-                  defaultAccount : defaultAccount,
-                  activeGlDescription : glAccount?.accountName]
+    return [invoiceItemTypeId: invoiceItemType.invoiceItemTypeId,
+            description: invoiceItemType.description,
+            defaultGlAccountId: invoiceItemType.defaultGlAccountId,
+            overrideGlAccountId: overrideGlAccountId,
+            defaultAccount: defaultAccount,
+            activeGlDescription: glAccount?.accountName]
 }

applications/accounting/groovyScripts/agreement/AgreementServices.groovy

@@ -17,56 +17,63 @@
  * under the License.
  */
 
-import org.apache.ofbiz.service.ModelService;
+import org.apache.ofbiz.service.ModelService
 import org.apache.ofbiz.service.ServiceUtil
 
 /**
  * Copy an existing Agreement
  */
 
-def copyAgreement() {
-    agreement = from('Agreement').where('agreementId', parameters.agreementId).queryOne();
+Map copyAgreement() {
+    agreement = from('Agreement').where('agreementId', parameters.agreementId).queryOne()
     serviceResult = success()
     if (agreement) {
         Map createAgreementInMap = dispatcher.getDispatchContext().makeValidContext('createAgreement', ModelService.IN_PARAM, agreement)
         result = run service: 'createAgreement', with: createAgreementInMap
-        if (ServiceUtil.isError(result)) return result
+        if (ServiceUtil.isError(result)) {
+            return result
+        }
         agreementIdTo = result.agreementId
         agreementItems = agreement.getRelated('AgreementItem', null, null, false)
         agreementItems.each { agreementItem ->
-            Map createAgreementItemInMap = dispatcher.getDispatchContext().makeValidContext('createAgreementItem', ModelService.IN_PARAM, agreementItem)
+            Map createAgreementItemInMap = dispatcher.getDispatchContext().makeValidContext('createAgreementItem',
+                    ModelService.IN_PARAM, agreementItem)
             createAgreementItemInMap.agreementId = agreementIdTo
             result = run service: 'createAgreementItem', with: createAgreementItemInMap
         }
-        if ('Y' == parameters.copyAgreementTerms) {
+        if (parameters.copyAgreementTerms == 'Y') {
             agreementTerms = agreement.getRelated('AgreementTerm', null, null, false)
             agreementTerms.each { agreementTerm ->
-                Map createAgreementTermInMap = dispatcher.getDispatchContext().makeValidContext('createAgreementTerm', ModelService.IN_PARAM, agreementTerm)
+                Map createAgreementTermInMap = dispatcher.getDispatchContext().makeValidContext('createAgreementTerm',
+                        ModelService.IN_PARAM, agreementTerm)
                 createAgreementTermInMap.agreementId = agreementIdTo
-                createAgreementTermInMap.remove("agreementTermId")
+                createAgreementTermInMap.remove('agreementTermId')
                 result = run service: 'createAgreementTerm', with: createAgreementTermInMap
             }
         }
-        if ('Y' == parameters.copyAgreementProducts) {
+        if (parameters.copyAgreementProducts == 'Y') {
             agreementProductAppls = agreement.getRelated('AgreementProductAppl', null, null, false)
             agreementProductAppls.each { agreementProductAppl ->
-                Map createAgreementProductApplInMap = dispatcher.getDispatchContext().makeValidContext('createAgreementProductAppl', ModelService.IN_PARAM, agreementProductAppl)
+                Map createAgreementProductApplInMap = dispatcher.getDispatchContext().makeValidContext('createAgreementProductAppl',
+                        ModelService.IN_PARAM, agreementProductAppl)
                 createAgreementProductApplInMap.agreementId = agreementIdTo
                 result = run service: 'createAgreementProductAppl', with: createAgreementProductApplInMap
             }
         }
-        if ('Y' == parameters.copyAgreementFacilities) {
+        if (parameters.copyAgreementFacilities == 'Y') {
             agreementFacilityAppls = agreement.getRelated('AgreementFacilityAppl', null, null, false)
             agreementFacilityAppls.each { agreementFacilityAppl ->
-                Map createAgreementFacilityApplInMap = dispatcher.getDispatchContext().makeValidContext('createAgreementFacilityAppl', ModelService.IN_PARAM, agreementFacilityAppl)
+                Map createAgreementFacilityApplInMap = dispatcher.getDispatchContext().makeValidContext('createAgreementFacilityAppl',
+                        ModelService.IN_PARAM, agreementFacilityAppl)
                 createAgreementFacilityApplInMap.agreementId = agreementIdTo
                 result = run service: 'createAgreementFacilityAppl', with: createAgreementFacilityApplInMap
             }
         }
-        if ('Y' == parameters.copyAgreementParties) {
+        if (parameters.copyAgreementParties == 'Y') {
             agreementPartyApplics = agreement.getRelated('AgreementPartyApplic', null, null, false)
             agreementPartyApplics.each { agreementPartyApplic ->
-                Map createAgreementPartyApplicInMap = dispatcher.getDispatchContext().makeValidContext('createAgreementPartyApplic', ModelService.IN_PARAM, agreementPartyApplic)
+                Map createAgreementPartyApplicInMap = dispatcher.getDispatchContext().makeValidContext('createAgreementPartyApplic',
+                        ModelService.IN_PARAM, agreementPartyApplic)
                 createAgreementPartyApplicInMap.agreementId = agreementIdTo
                 result = run service: 'createAgreementPartyApplic', with: createAgreementPartyApplicInMap
             }

applications/accounting/groovyScripts/agreement/GetPartyNameForDate.groovy

@@ -17,8 +17,8 @@
  * under the License.
  *******************************************************************************/
 if (partyIdFrom) {
-    context.partyNameResultFrom = runService("getPartyNameForDate", [partyId: partyIdFrom, compareDate: agreementDate, lastNameFirst: "Y"])
+    context.partyNameResultFrom = runService('getPartyNameForDate', [partyId: partyIdFrom, compareDate: agreementDate, lastNameFirst: 'Y'])
 }
 if (partyIdTo) {
-    context.partyNameResultTo = runService("getPartyNameForDate", [partyId: partyIdTo, compareDate: agreementDate, lastNameFirst: "Y"])
-}
+    context.partyNameResultTo = runService('getPartyNameForDate', [partyId: partyIdTo, compareDate: agreementDate, lastNameFirst: 'Y'])
+}