diff --git a/applications/product/groovyScripts/product/catalog/CatalogServices.groovy b/applications/product/groovyScripts/product/catalog/CatalogServices.groovy
new file mode 100644
index 00000000000..67dcf7fc458
--- /dev/null
+++ b/applications/product/groovyScripts/product/catalog/CatalogServices.groovy
@@ -0,0 +1,421 @@
+/*
+ * 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.sql.Timestamp
+import org.apache.ofbiz.base.util.UtilDateTime
+import org.apache.ofbiz.base.util.UtilURL
+import org.apache.ofbiz.entity.GenericValue
+import org.apache.ofbiz.entity.util.EntityUtilProperties
+import org.apache.ofbiz.service.ServiceUtil
+
+/**
+ * get All categories
+ */
+def getAllCategories() {
+    String defaultTopCategoryId = parameters.topCategory ?: EntityUtilProperties.getPropertyValue("catalog", "top.category.default", delegator)
+    Map serviceRes = run service: "getRelatedCategories", with: [parentProductCategoryId: defaultTopCategoryId]
+    return serviceRes
+}
+
+def getRelatedCategories() {
+    Map result = success()
+    List categories = []
+    List rollups = from("ProductCategoryRollup")
+            .where("parentProductCategoryId", parameters.parentProductCategoryId)
+            .orderBy("sequenceNum")
+            .queryList()
+    if (parameters.categories) {
+        categories.addAll(parameters.categories)
+    }
+    if (rollups) {
+        List subCategories = []
+        for (GenericValue parent: rollups) {
+            subCategories << parent.getRelatedOne("CurrentProductCategory", true)
+        }
+        if (subCategories) {
+            Set distinctCategories = categories? [*categories] as Set: [] as Set
+            Map relatedCategoryContext = [categories: subCategories]
+            for (Map subCategory: subCategories) {
+                relatedCategoryContext.parentProductCategoryId = subCategory.productCategoryId
+                Map res = run service: "getRelatedCategories", with: relatedCategoryContext
+                if (res.categories) {
+                    distinctCategories.addAll(res.categories)
+                }
+            }
+            categories = distinctCategories as List
+        }
+    } else {
+        GenericValue productCategory = from("ProductCategory")
+                .where("productCategoryId", parameters.parentProductCategoryId)
+                .queryOne()
+        categories << productCategory
+    }
+    result.categories = categories
+    return result
+}
+
+
+/**
+ * Check if image url exists or not for all categories
+ */
+def checkImageUrlForAllCategories() {
+    Map result = success()
+    Map gacRes = run service: "getAllCategories", with: parameters
+    List categories = gacRes.categories
+    if (categories) {
+        Map categoriesMap = [:]
+        // get the category from categories
+        for (Map category : categories) {
+            Map ciufcapRes = run service: "checkImageUrlForCategoryAndProduct", with: [categoryId: category.productCategoryId]
+            Map fileStatusMap = [fileExists: ciufcapRes.fileExists, fileNotExists: ciufcapRes.fileNotExists]
+            String categoryId = category.productCategoryId
+            categoriesMap[categoryId] = fileStatusMap
+        }
+        result.categoriesMap = categoriesMap
+    }
+    return result
+}
+
+
+/**
+ * Check if image url exists or not for category and product
+ */
+def checkImageUrlForCategoryAndProduct() {
+    Map result = success()
+    Map gpcmRes = run service: "getProductCategoryMembers", with: parameters
+    List categoryMembers = gpcmRes.categoryMembers
+    Map category = gpcmRes.category
+
+    List fileExists = []
+    List fileNotExists = []
+    Map filesImageMap = [:]
+    // Get category images and check it exists or not
+    if (category) {
+        Map ciufcRes = run service: "checkImageUrlForCategory", with: [categoryId: category.productCategoryId]
+        filesImageMap = ciufcRes.filesImageMap
+
+        if (filesImageMap) {
+            fileImageExists("categoryImageUrlMap", "categoryImageUrl", filesImageMap, fileExists, fileNotExists)
+            fileImageExists("linkOneImageUrlMap", "linkOneImageUrl", filesImageMap, fileExists, fileNotExists)
+            fileImageExists("linkTwoImageUrlMap", "linkTwoImageUrl", filesImageMap, fileExists, fileNotExists)
+        }
+    }
+
+    if (categoryMembers) {
+        for (GenericValue productCategoryMember : categoryMembers) {
+            Map ciufpRes = run service: "checkImageUrlForProduct", with: [productId: productCategoryMember.productId]
+            filesImageMap = ciufpRes.filesImageMap
+
+            if (filesImageMap) {
+                fileImageExists("smallImageUrlMap", "smallImageUrl", filesImageMap, fileExists, fileNotExists)
+                fileImageExists("mediumImageUrlMap", "mediumImageUrl", filesImageMap, fileExists, fileNotExists)
+                fileImageExists("largeImageUrlMap", "largeImageUrl", filesImageMap, fileExists, fileNotExists)
+                fileImageExists("detailImageUrlMap", "detailImageUrl", filesImageMap, fileExists, fileNotExists)
+            }
+
+            /* Case for virtual product
+               get related assoc product */
+            Map product = productCategoryMember.getRelatedOne("Product", false)
+            if ("Y" == product.isVirtual) {
+                Map virtualProductContext = [
+                    productId: product.productId,
+                    productAssocTypeId: "PRODUCT_VARIANT"
+                ]
+                List variantProducts = from("ProductAssoc")
+                        .where(virtualProductContext)
+                        .filterByDate()
+                        .queryList()
+                if (variantProducts) {
+                    for (Map variantProduct : variantProducts) {
+                        Map res = run service: "checkImageUrlForProduct", with: [productId: variantProduct.productIdTo]
+                        filesImageMap = res.filesImageMap
+                        if (filesImageMap) {
+                            fileImageExists("smallImageUrlMap", "smallImageUrl", filesImageMap, fileExists, fileNotExists)
+                            fileImageExists("mediumImageUrlMap", "mediumImageUrl", filesImageMap, fileExists, fileNotExists)
+                            fileImageExists("largeImageUrlMap", "largeImageUrl", filesImageMap, fileExists, fileNotExists)
+                            fileImageExists("detailImageUrlMap", "detailImageUrl", filesImageMap, fileExists, fileNotExists)
+                        }
+                    }
+                }
+            }
+        }
+        result.fileExists = fileExists
+        result.fileNotExists = fileNotExists
+    }
+    return result
+}
+
+/**
+ * This Method checks if the images exist and puts them into
+ * the lists filesExist and filesNotExist.
+ * <p>
+ * The lists filesExist and filesNotExist are filled with the new values.
+ * @param map
+ * @param key
+ * @param filesImageMap
+ * @param fileExists
+ * @param fileNotExists
+ */
+def fileImageExists(map, key, filesImageMap, fileExists, fileNotExists) {
+    if (filesImageMap."${map}"?."${key}") {
+        if ("Y" == filesImageMap."${map}".isExists) {
+            fileExists.add(filesImageMap."${map}"."${key}")
+        } else {
+            fileNotExists.add(filesImageMap."${map}"."${key}")
+        }
+    }
+}
+
+/**
+ * This service gets the category id and checks if
+ * all the images of category exists or not
+ */
+def checkImageUrlForCategory() {
+    Map result = success()
+    Map filesImageMap = [:]
+    GenericValue category = from("ProductCategory")
+            .where("productCategoryId", parameters.categoryId)
+            .queryOne()
+    if (category) {
+        // check for category image url
+        imageUrlCheck(category, "categoryImageUrl", filesImageMap)
+        // check for link image url
+        imageUrlCheck(category, "linkOneImageUrl", filesImageMap)
+        // check for link two image url
+        imageUrlCheck(category, "linkTwoImageUrl", filesImageMap)
+        category.store()
+        if (filesImageMap) {
+            result.filesImageMap = filesImageMap
+        }
+    }
+    return result
+}
+
+/**
+ * Check if image url exists or not for product
+ */
+def checkImageUrlForProduct() {
+    Map result = success()
+    Map filesImageMap = [:]
+    if (parameters.productId) {
+        Map product = from("Product").where(parameters).queryOne()
+        // check for small image url
+        imageUrlCheck(product, "smallImageUrl", filesImageMap)
+        // check for medium image url
+        imageUrlCheck(product, "mediumImageUrl", filesImageMap)
+        // check for large image url
+        imageUrlCheck(product, "largeImageUrl", filesImageMap)
+        // check for detail image url
+        imageUrlCheck(product, "detailImageUrl", filesImageMap)
+        if (filesImageMap) {
+            result.filesImageMap = filesImageMap
+        }
+        product.store()
+    }
+    return result
+}
+
+/**
+ * This method fills filesImageMap with the needed content and sets the relevant type in
+ * the prodOrCat (product or category) map to null, if there is no image existent for this type
+ * @param prodOrCat
+ * @param filesImageMap
+ * @param imageType
+ * @return
+ */
+def imageUrlCheck(prodOrCat, imageType, filesImageMap) {
+    if (prodOrCat."${imageType}") {
+        Map res = run service: "checkImageUrl", with: [imageUrl: prodOrCat."${imageType}"]
+        String isExists = res.isExists
+        filesImageMap."${imageType}Map" = [:]
+        filesImageMap."${imageType}Map"."${imageType}" = prodOrCat."${imageType}"
+        filesImageMap."${imageType}Map".isExists = isExists
+        if (isExists == "N") {
+            prodOrCat."${imageType}" = null
+        }
+    }
+}
+
+/**
+ * Check if image url exists or not
+ */
+def checkImageUrl() {
+    def imageUrl = parameters.imageUrl
+    boolean httpFlag = imageUrl.startsWith("http")
+    boolean ftpFlag = imageUrl.startsWith("ftp")
+    String url = httpFlag || ftpFlag
+        ? UtilURL.fromUrlString(imageUrl)
+        : UtilURL.fromOfbizHomePath("/themes/common-theme/webapp" + imageUrl)
+    Map result = success()
+    result.isExists = url ? "Y" : "N"
+    return result
+}
+
+/**
+ * Catalog permission logic
+ */
+def catalogPermissionCheck() {
+    parameters.primaryPermission = "CATALOG"
+    Map result = run service: "genericBasePermissionCheck", with: parameters
+    return result
+}
+
+/**
+ * ProdCatalogToParty permission logic
+ */
+def prodCatalogToPartyPermissionCheck() {
+    parameters.altPermission = "PARTYMGR"
+    return catalogPermissionCheck()
+}
+
+/**
+ * create missing category and product alternative urls
+ */
+def createMissingCategoryAndProductAltUrls() {
+    Timestamp now = UtilDateTime.nowTimestamp()
+    Map result = success()
+    result.prodCatalogId = parameters.prodCatalogId
+    int categoriesNotUpdated = 0
+    int categoriesUpdated = 0
+    int productsNotUpdated = 0
+    int productsUpdated = 0
+    String checkProduct = parameters.product
+    String checkCategory = parameters.category
+    List prodCatalogCategoryList = from("ProdCatalogCategory").where("prodCatalogId", parameters.prodCatalogId).queryList()
+
+    // get all categories
+    List productCategories = []
+    for (GenericValue prodCatalog: prodCatalogCategoryList) {
+        productCategories.addAll(createMissingCategoryAltUrlInline(prodCatalog.productCategoryId))
+    }
+
+    for (Map productCategoryList : productCategories) {
+        // create product category alternative URLs
+        if (checkCategory) {
+            List productCategoryContentAndInfoList = from("ProductCategoryContentAndInfo")
+                    .where("productCategoryId", productCategoryList.productCategoryId,
+                            "prodCatContentTypeId", "ALTERNATIVE_URL")
+                    .filterByDate()
+                    .orderBy("-fromDate")
+                    .cache()
+                    .queryList()
+            if (!productCategoryContentAndInfoList) {
+                Map createSimpleTextContentForCategoryCtx = [
+                    fromDate: now,
+                    prodCatContentTypeId: "ALTERNATIVE_URL",
+                    localeString: "en",
+                    productCategoryId: productCategoryList.productCategoryId
+                ]
+                if (!productCategoryList.categoryName) {
+                    GenericValue productCategoryContent = from("ProductCategoryContentAndInfo")
+                            .where("productCategoryId", productCategoryList.productCategoryId,
+                                    "prodCatContentTypeId", "CATEGORY_NAME")
+                            .filterByDate()
+                            .orderBy("-fromDate")
+                            .cache()
+                            .queryFirst()
+                    if (productCategoryContent) {
+                        Map gcadrRes = run service: "getContentAndDataResource", with: [contentId: productCategoryContent.contentId]
+                        Map resultMap = gcadrRes.resultData
+                        createSimpleTextContentForCategoryCtx.text = resultMap.electronicText.textData
+                    }
+                } else {
+                    createSimpleTextContentForCategoryCtx.text = productCategoryList.categoryName
+                }
+                if (createSimpleTextContentForCategoryCtx.text) {
+                    Map res = run service: "createSimpleTextContentForCategory", with: createSimpleTextContentForCategoryCtx
+                    if (ServiceUtil.isError(res)) {
+                        return res
+                    }
+                    categoriesUpdated += 1
+                }
+            } else {
+                categoriesNotUpdated += 1
+            }
+        }
+
+        // create product alternative URLs
+        if (checkProduct) {
+            List productCategoryMemberList = from("ProductCategoryMember")
+                    .where("productCategoryId", productCategoryList.productCategoryId)
+                    .filterByDate()
+                    .orderBy("-fromDate")
+                    .cache()
+                    .queryList()
+            for (Map productCategoryMember: productCategoryMemberList) {
+                String memberProductId = productCategoryMember.productId
+                List productContentAndInfoList = from("ProductContentAndInfo")
+                        .where("productId", memberProductId, "productContentTypeId", "ALTERNATIVE_URL")
+                        .cache().orderBy("-fromDate")
+                        .filterByDate()
+                        .queryList()
+                if (!productContentAndInfoList) {
+                    GenericValue product = from("Product").where("productId", memberProductId).queryOne()
+                    Map createSimpleTextContentForProductCtx = [
+                        fromDate: now,
+                        productContentTypeId: "ALTERNATIVE_URL",
+                        localeString: "en",
+                        productId: memberProductId
+                    ]
+                    createSimpleTextContentForProductCtx.text = product.internalName ?: product.productName
+                    if (createSimpleTextContentForProductCtx.text) {
+                        Map res = run service: "createSimpleTextContentForProduct", with: createSimpleTextContentForProductCtx
+                        if (ServiceUtil.isError(res)) {
+                            return res
+                        }
+                        productsUpdated += 1
+                    }
+                } else {
+                    productsNotUpdated += 1
+                }
+            }
+        }
+    }
+    result.successMessageList = [
+        "Categories updated: ${categoriesUpdated}",
+        "Products updated: ${productsUpdated}"
+    ]
+    result.categoriesNotUpdated = categoriesNotUpdated
+    result.productsNotUpdated = productsNotUpdated
+    result.categoriesUpdated = categoriesUpdated
+    result.productsUpdated = productsUpdated
+    return result
+}
+
+def createMissingCategoryAltUrlInline(parentProductCategoryId) {
+    List productCategoryRollupIds = from("ProductCategoryRollup")
+            .where("parentProductCategoryId", parentProductCategoryId)
+            .filterByDate()
+            .cache()
+            .getFieldList("productCategoryId")
+    List productCategories = []
+    for (String productCategoryId : productCategoryRollupIds) {
+
+        // append product category to list
+        productCategories << from("ProductCategory")
+                .where("productCategoryId", productCategoryId)
+                .cache()
+                .queryOne()
+
+        // find rollup product categories
+        productCategories.addAll(createMissingCategoryAltUrlInline(productCategoryId))
+    }
+    return productCategories
+}
\ No newline at end of file
diff --git a/applications/product/minilang/product/catalog/CatalogServices.xml b/applications/product/minilang/product/catalog/CatalogServices.xml
deleted file mode 100644
index 45d6eaac265..00000000000
--- a/applications/product/minilang/product/catalog/CatalogServices.xml
+++ /dev/null
@@ -1,595 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<!--
-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.
--->
-
-<simple-methods xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xmlns="http://ofbiz.apache.org/Simple-Method" xsi:schemaLocation="http://ofbiz.apache.org/Simple-Method http://ofbiz.apache.org/dtds/simple-methods.xsd">
-
-    <simple-method method-name="getAllCategories" short-description="get All categories" login-required="false">
-        <if-not-empty field="parameters.topCategory">
-            <set field="defaultTopCategoryId" from-field="parameters.topCategory"/>
-        <else>
-            <property-to-field property="top.category.default" field="defaultTopCategoryId" resource="catalog"/>
-        </else>
-        </if-not-empty>
-        <!--  set field="productCategoryContext.productCategoryId"  from-field="defaultTopCategoryId"/>
-        <find-by-primary-key entity-name="ProductCategory" map="productCategoryContext" value-field="productCategory"/>
-        <field-to-list list="categories" field="productCategory"/>
-        -->
-        <set field="relatedCategoryContext.parentProductCategoryId"  from-field="defaultTopCategoryId"/>
-        <call-service service-name="getRelatedCategories" in-map-name="relatedCategoryContext">
-            <result-to-field result-name="categories" field="resCategories"/>
-        </call-service>
-        <field-to-result field="resCategories" result-name="categories"/>
-        <!-- iterate entry-name="category" list-name="resCategories">
-            <log level="info" message="=========${category.productCategoryId}"/>
-        </iterate -->
-    </simple-method>
-
-    <simple-method method-name="getRelatedCategories" short-description="get All Related categories" login-required="false">
-        <set value="sequenceNum" field="orderByString"/>
-        <field-to-list list="orderByStringList" field="orderByString"/>
-        <set field="productCategoryRollUpContext.parentProductCategoryId" from-field="parameters.parentProductCategoryId"/>
-        <!--set field="categories" from-field="parameters.categories" / -->
-        <find-by-and entity-name="ProductCategoryRollup" list="rollups" map="productCategoryRollUpContext" order-by-list="orderByStringList"/>
-        <if-not-empty field="parameters.categories">
-            <list-to-list list="parameters.categories" to-list="categories"/>
-        </if-not-empty>
-        <if-not-empty field="rollups">
-            <iterate list="rollups" entry="parent">
-                <get-related-one relation-name="CurrentProductCategory" value-field="parent" to-value-field="currentProductCategory"/>
-                <field-to-list list="subCategories" field="currentProductCategory"/>
-            </iterate>
-            <if-not-empty field="subCategories">
-                <set field="relatedCategoryContext.categories"  from-field="subCategories"/>
-                <iterate list="subCategories" entry="subCategory">
-                    <set field="relatedCategoryContext.parentProductCategoryId"  from-field="subCategory.productCategoryId"/>
-                    <call-service service-name="getRelatedCategories" in-map-name="relatedCategoryContext">
-                        <result-to-field result-name="categories" field="relCategories"/>
-                    </call-service>
-                    <if-not-empty field="relCategories">
-                        <if-not-empty field="categories">
-                            <iterate list="relCategories" entry="relCategory">
-                            <call-object-method obj-field="categories" method-name="contains" ret-field="addInCategories" >
-                                <field field="relCategory" type="java.lang.Object"/>
-                            </call-object-method>
-                            <if-compare field="addInCategories" operator="equals" value="false" type="Boolean">
-                                <field-to-list list="categories" field="relCategory"/>
-                            </if-compare>
-                           </iterate>
-                        <else>
-                            <list-to-list list="relCategories" to-list="categories"/>
-                        </else>
-                        </if-not-empty>
-                        <field-to-result field="categories" result-name="categories"/>
-                         <!-- iterate entry-name="category" list-name="categories">
-                            <log level="info" message="Category ${category.productCategoryId}"/>
-                         </iterate -->
-                    </if-not-empty>
-                    <!--   field-to-result field-name="categories" result-name="categories"/ -->
-                </iterate>
-            </if-not-empty>
-        <else>
-            <set field="productCategoryContext.productCategoryId" from-field="parameters.parentProductCategoryId"/>
-            <find-by-primary-key entity-name="ProductCategory" value-field="productCategory" map="productCategoryContext"/>
-            <field-to-list list="categories" field="productCategory"/>
-            <field-to-result field="categories" result-name="categories"/>
-        </else>
-        </if-not-empty>
-        <!-- iterate entry-name="category" list-name="categories">
-           <log level="info" message="Category ${category.productCategoryId}"/>
-        </iterate -->
-        <field-to-result field="categories" result-name="categories"/>
-    </simple-method>
-
-    <simple-method method-name="checkImageUrlForAllCategories" short-description="Check for image url exists or not for All categories" login-required="false">
-        <!-- Get all the categories from top category -->
-        <set-service-fields service-name="getAllCategories" map="parameters" to-map="categoryFindContext"/>
-        <call-service service-name="getAllCategories" in-map-name="categoryFindContext">
-            <result-to-field result-name="categories" field="categories"/>
-        </call-service>
-        <!-- Get the category from categories-->
-        <if-not-empty field="categories">
-            <iterate list="categories" entry="category">
-                <set field="checkImageUrlForCategoryContext.categoryId" from-field="category.productCategoryId"/>
-                <call-service service-name="checkImageUrlForCategoryAndProduct" in-map-name="checkImageUrlForCategoryContext">
-                    <result-to-field result-name="fileExists" field="fileStatusMap.fileExists"/>
-                    <result-to-field result-name="fileNotExists" field="fileStatusMap.fileNotExists"/>
-                </call-service>
-                <set field="categoryId" from-field="category.productCategoryId"/>
-                <set field="categoriesMap[categoryId]" from-field="fileStatusMap"/>
-            </iterate>
-            <field-to-result field="categoriesMap" result-name="categoriesMap"/>
-        </if-not-empty>
-    </simple-method>
-
-    <simple-method method-name="checkImageUrlForCategoryAndProduct" short-description="Check for image url exists or not for category and product " login-required="false">
-        <!--set from-field="parameters.categoryId" field="productCategoryContext.categoryId"/ -->
-        <set-service-fields service-name="getProductCategoryMembers" map="parameters" to-map="productCategoryContext"/>
-        <call-service service-name="getProductCategoryMembers" in-map-name="productCategoryContext" >
-            <result-to-field result-name="categoryMembers" field="categoryMembers"/>
-            <result-to-field result-name="category" field="category"/>
-        </call-service>
-        <!-- Get category images and check it exists or not -->
-        <if-not-empty field="category">
-
-            <set field="checkImageUrlForCategoryContext.categoryId" from-field="category.productCategoryId"/>
-            <call-service service-name="checkImageUrlForCategory" in-map-name="checkImageUrlForCategoryContext">
-                   <result-to-field result-name="filesImageMap" field="filesImageMap"/>
-            </call-service>
-
-            <if-not-empty field="filesImageMap.categoryImageUrlMap.categoryImageUrl">
-                <if-compare field="filesImageMap.categoryImageUrlMap.isExists" operator="equals" value="Y">
-                    <field-to-list field="" list=""/>
-                    <field-to-list list="fileExists" field="filesImageMap.categoryImageUrlMap.categoryImageUrl"/>
-                <else>
-                    <field-to-list list="fileNotExists" field="filesImageMap.categoryImageUrlMap.categoryImageUrl"/>
-                </else>
-                </if-compare>
-            </if-not-empty>
-            <if-not-empty field="filesImageMap.linkOneImageUrlMap.linkOneImageUrl">
-                <if-compare field="filesImageMap.linkOneImageUrlMap.isExists" operator="equals" value="Y">
-                    <field-to-list list="fileExists" field="filesImageMap.linkOneImageUrlMap.linkOneImageUrl"/>
-                <else>
-                     <field-to-list list="fileNotExists" field="filesImageMap.linkOneImageUrlMap.linkOneImageUrl"/>
-                </else>
-                </if-compare>
-            </if-not-empty>
-            <if-not-empty field="filesImageMap.linkTwoImageUrlMap.linkTwoImageUrl">
-                <if-compare field="filesImageMap.linkTwoImageUrlMap.isExists" operator="equals" value="Y">
-                    <field-to-list list="fileExists" field="filesImageMap.linkTwoImageUrlMap.linkTwoImageUrl"/>
-                <else>
-                    <field-to-list list="fileNotExists" field="filesImageMap.linkTwoImageUrlMap.linkTwoImageUrl"/>
-                </else>
-               </if-compare>
-            </if-not-empty>
-        </if-not-empty>
-
-        <if-not-empty field="categoryMembers">
-            <iterate list="categoryMembers" entry="productCategoryMember">
-                <set field="checkImageUrlForProductContext.productId" from-field="productCategoryMember.productId"/>
-                <call-service service-name="checkImageUrlForProduct" in-map-name="checkImageUrlForProductContext">
-                    <result-to-field result-name="filesImageMap" field="filesImageMap"/>
-                </call-service>
-                <if-not-empty field="filesImageMap">
-                    <if-not-empty field="filesImageMap.smallImageUrlMap.smallImageUrl">
-                        <if-compare field="filesImageMap.smallImageUrlMap.isExists" operator="equals" value="Y">
-                            <field-to-list list="fileExists" field="filesImageMap.smallImageUrlMap.smallImageUrl"/>
-                        <else>
-                            <field-to-list list="fileNotExists" field="filesImageMap.smallImageUrlMap.smallImageUrl"/>
-                        </else>
-                        </if-compare>
-                    </if-not-empty>
-                    <if-not-empty field="filesImageMap.mediumImageUrlMap.mediumImageUrl">
-                        <if-compare field="filesImageMap.mediumImageUrlMap.isExists" operator="equals" value="Y">
-                            <field-to-list list="fileExists" field="filesImageMap.mediumImageUrlMap.mediumImageUrl"/>
-                        <else>
-                            <field-to-list list="fileNotExists" field="filesImageMap.mediumImageUrlMap.mediumImageUrl"/>
-                        </else>
-                        </if-compare>
-                    </if-not-empty>
-                    <if-not-empty field="filesImageMap.largeImageUrlMap.largeImageUrl">
-                        <if-compare field="filesImageMap.largeImageUrlMap.isExists" operator="equals" value="Y">
-                            <field-to-list list="fileExists" field="filesImageMap.largeImageUrlMap.largeImageUrl"/>
-                        <else>
-                            <field-to-list list="fileNotExists" field="filesImageMap.largeImageUrlMap.largeImageUrl"/>
-                        </else>
-                        </if-compare>
-                    </if-not-empty>
-                    <if-not-empty field="filesImageMap.detailImageUrlMap.detailImageUrl">
-                        <if-compare field="filesImageMap.detailImageUrl.isExists" operator="equals" value="Y">
-                            <field-to-list list="fileExists" field="filesImageMap.detailImageUrl.detailImageUrl"/>
-                        <else>
-                            <field-to-list list="fileNotExists" field="filesImageMap.detailImageUrl.detailImageUrl"/>
-                        </else>
-                        </if-compare>
-                    </if-not-empty>
-                </if-not-empty>
-                <!--  Case For virtual Product -->
-                <!--  get related assoc product -->
-                <get-related-one relation-name="Product" value-field="productCategoryMember" to-value-field="product"/>
-                <if-compare field="product.isVirtual" operator="equals" value="Y">
-                    <!-- log level="info" message = "Virtual product =====${productCategoryMember.productId}"/ -->
-                    <set field="virtualProductContext.productId" from-field="product.productId"/>
-                    <set field="virtualProductContext.productAssocTypeId" value="PRODUCT_VARIANT"/>
-                    <find-by-and entity-name="ProductAssoc" map="virtualProductContext" list="variantProducts"/>
-                    <filter-list-by-date list="variantProducts"/>
-                    <if-not-empty field="variantProducts">
-                        <iterate list="variantProducts" entry="variantProduct">
-                            <!-- log level="info" message = "Variant product =====${variantProduct.productIdTo}"/ -->
-                            <set field="variantProductContext.productId" from-field="variantProduct.productIdTo"/>
-                            <call-service service-name="checkImageUrlForProduct" in-map-name="variantProductContext">
-                                <result-to-field result-name="filesImageMap" field="filesImageMap"/>
-                            </call-service>
-                            <if-not-empty field="filesImageMap">
-                                <if-not-empty field="filesImageMap.smallImageUrlMap.smallImageUrl">
-                                    <if-compare field="filesImageMap.smallImageUrlMap.isExists" operator="equals" value="Y">
-                                        <field-to-list list="fileExists" field="filesImageMap.smallImageUrlMap.smallImageUrl"/>
-                                    <else>
-                                            <field-to-list list="fileNotExists" field="filesImageMap.smallImageUrlMap.smallImageUrl"/>
-                                    </else>
-                                    </if-compare>
-                                </if-not-empty>
-
-                                <if-not-empty field="filesImageMap.mediumImageUrlMap.mediumImageUrl">
-                                    <if-compare field="filesImageMap.mediumImageUrlMap.isExists" operator="equals" value="Y">
-                                        <field-to-list list="fileExists" field="filesImageMap.mediumImageUrlMap.mediumImageUrl"/>
-                                    <else>
-                                        <field-to-list list="fileNotExists" field="filesImageMap.mediumImageUrlMap.mediumImageUrl"/>
-                                    </else>
-                                    </if-compare>
-                                </if-not-empty>
-
-                                <if-not-empty field="filesImageMap.largeImageUrlMap.largeImageUrl">
-                                    <if-compare field="filesImageMap.largeImageUrlMap.isExists" operator="equals" value="Y">
-                                        <field-to-list list="fileExists" field="filesImageMap.largeImageUrlMap.largeImageUrl"/>
-                                    <else>
-                                        <field-to-list list="fileNotExists" field="filesImageMap.largeImageUrlMap.largeImageUrl"/>
-                                    </else>
-                                    </if-compare>
-                                </if-not-empty>
-
-                                <if-not-empty field="filesImageMap.detailImageUrlMap.detailImageUrl">
-                                    <if-compare field="filesImageMap.detailImageUrl.isExists" operator="equals" value="Y">
-                                        <field-to-list list="fileExists" field="filesImageMap.detailImageUrl.detailImageUrl"/>
-                                    <else>
-                                        <field-to-list list="fileNotExists" field="filesImageMap.detailImageUrl.detailImageUrl"/>
-                                    </else>
-                                    </if-compare>
-                                </if-not-empty>
-
-                            </if-not-empty>
-                        </iterate>
-                    </if-not-empty>
-                </if-compare>
-            </iterate>
-            <field-to-result field="fileExists" result-name="fileExists"/>
-            <field-to-result field="fileNotExists" result-name="fileNotExists"/>
-        </if-not-empty>
-    </simple-method>
-
-
-    <!-- This service get the category id and check all the images of category exists or not -->
-    <simple-method method-name="checkImageUrlForCategory" short-description="Check for image url exists or not for product" login-required="false">
-        <if-not-empty field="parameters.categoryId">
-            <set field="productCategoryFindContext.productCategoryId" from-field="parameters.categoryId"/>
-            <find-by-primary-key entity-name="ProductCategory" value-field="category" map="productCategoryFindContext"/>
-            <!-- check for category image url -->
-            <if-not-empty field="category.categoryImageUrl">
-                <set field="checkImageUrlContext.imageUrl" from-field="category.categoryImageUrl"/>
-                <call-service service-name="checkImageUrl" in-map-name="checkImageUrlContext">
-                    <result-to-field result-name="isExists" field="isExists"/>
-                </call-service>
-                <set field="categoryImageUrlMap.categoryImageUrl" from-field="category.categoryImageUrl"/>
-                <set field="categoryImageUrlMap.isExists" from-field="isExists"/>
-                <set field="filesImageMap.categoryImageUrlMap" from-field="categoryImageUrlMap"/>
-                <if-compare field="isExists" operator="equals" value="N">
-                    <clear-field field="category.categoryImageUrl"></clear-field>
-                </if-compare>
-            </if-not-empty>
-            <!-- check for link image url -->
-            <if-not-empty field="category.linkOneImageUrl">
-                <clear-field field="checkImageUrlContext.imageUrl"/>
-                <set field="checkImageUrlContext.imageUrl" from-field="category.linkOneImageUrl"/>
-                <call-service service-name="checkImageUrl" in-map-name="checkImageUrlContext">
-                    <result-to-field result-name="isExists" field="isExists"/>
-                </call-service>
-                <set field="linkOneImageUrlMap.linkOneImageUrl" from-field="category.linkOneImageUrl"/>
-                <set field="linkOneImageUrlMap.isExists" from-field="isExists"/>
-                <set field="filesImageMap.linkOneImageUrlMap" from-field="linkOneImageUrlMap"/>
-                <if-compare field="isExists" operator="equals" value="N">
-                    <clear-field field="category.linkOneImageUrl"></clear-field>
-                </if-compare>
-            </if-not-empty>
-            <!-- check for link two image url -->
-            <if-not-empty field="category.linkTwoImageUrl">
-                <clear-field field="checkImageUrlContext.imageUrl"/>
-                <set field="checkImageUrlContext.imageUrl" from-field="category.linkTwoImageUrl"/>
-                <call-service service-name="checkImageUrl" in-map-name="checkImageUrlContext">
-                    <result-to-field result-name="isExists" field="isExists"/>
-                </call-service>
-                <set field="linkTwoImageUrlMap.largeImageUrl" from-field="category.linkTwoImageUrl"/>
-                <set field="linkTwoImageUrlMap.isExists" from-field="isExists"/>
-                <set field="filesImageMap.linkTwoImageUrlMap" from-field="linkTwoImageUrlMap"/>
-                <if-compare field="isExists" operator="equals" value="N">
-                    <clear-field field="category.linkTwoImageUrl"></clear-field>
-                </if-compare>
-            </if-not-empty>
-            <!-- set-service-fields service-name="updateProductCategory" map-name="category" to-map-name="updateProductCategoryContext"/>
-            <call-service service-name="updateProductCategory" in-map-name="updateProductCategoryContext" / -->
-            <store-value value-field="category"/>
-            <field-to-result field="filesImageMap" result-name="filesImageMap"/>
-        </if-not-empty>
-    </simple-method>
-
-    <simple-method method-name="checkImageUrlForProduct" short-description="Check for image url exists or not for product" login-required="false">
-        <if-not-empty field="parameters.productId">
-            <set field="productFindContext.productId" from-field="parameters.productId"/>
-            <find-by-primary-key entity-name="Product" value-field="product" map="productFindContext"/>
-            <!-- check for small image url -->
-            <if-not-empty field="product.smallImageUrl">
-                <set field="checkImageUrlContext.imageUrl" from-field="product.smallImageUrl"/>
-                <call-service service-name="checkImageUrl" in-map-name="checkImageUrlContext">
-                    <result-to-field result-name="isExists" field="isExists"/>
-                </call-service>
-                <set field="smallImageUrlMap.smallImageUrl" from-field="product.smallImageUrl"/>
-                <set field="smallImageUrlMap.isExists" from-field="isExists"/>
-                <set field="filesImageMap.smallImageUrlMap" from-field="smallImageUrlMap"/>
-                <if-compare field="isExists" operator="equals" value="N">
-                    <log level="info" message="Update SmallImage for product Id ${parameters.productId}"/>
-                    <clear-field field="product.smallImageUrl"></clear-field>
-                </if-compare>
-            </if-not-empty>
-            <!-- check for medium image url -->
-            <if-not-empty field="product.mediumImageUrl">
-                <clear-field field="checkImageUrlContext.imageUrl"/>
-                <set field="checkImageUrlContext.imageUrl" from-field="product.mediumImageUrl"/>
-                <call-service service-name="checkImageUrl" in-map-name="checkImageUrlContext">
-                    <result-to-field result-name="isExists" field="isExists"/>
-                </call-service>
-                <set field="mediumImageUrlMap.mediumImageUrl" from-field="product.mediumImageUrl"/>
-                <set field="mediumImageUrlMap.isExists" from-field="isExists"/>
-                <set field="filesImageMap.mediumImageUrlMap" from-field="mediumImageUrlMap"/>
-                <if-compare field="isExists" operator="equals" value="N">
-                    <clear-field field="product.mediumImageUrl"></clear-field>
-                </if-compare>
-            </if-not-empty>
-            <!-- check for large image url -->
-            <if-not-empty field="product.largeImageUrl">
-                <clear-field field="checkImageUrlContext.imageUrl"/>
-                <set field="checkImageUrlContext.imageUrl" from-field="product.largeImageUrl"/>
-                <call-service service-name="checkImageUrl" in-map-name="checkImageUrlContext">
-                    <result-to-field result-name="isExists" field="isExists"/>
-                </call-service>
-                <set field="largeImageUrlMap.largeImageUrl" from-field="product.largeImageUrl"/>
-                <set field="largeImageUrlMap.isExists" from-field="isExists"/>
-                <set field="filesImageMap.largeImageUrlMap" from-field="largeImageUrlMap"/>
-                <if-compare field="isExists" operator="equals" value="N">
-                    <clear-field field="product.largeImageUrl"></clear-field>
-                </if-compare>
-            </if-not-empty>
-            <!-- check for detail image url -->
-            <if-not-empty field="product.detailImageUrl">
-                <clear-field field="checkImageUrlContext.imageUrl"/>
-                <set field="checkImageUrlContext.imageUrl" from-field="product.detailImageUrl"/>
-                <call-service service-name="checkImageUrl" in-map-name="checkImageUrlContext">
-                    <result-to-field result-name="isExists" field="isExists"/>
-                </call-service>
-                <set field="detailImageUrlMap.detailImageUrl" from-field="product.detailImageUrl"/>
-                <set field="detailImageUrlMap.isExists" from-field="isExists"/>
-                <set field="filesImageMap.detailImageUrlMap" from-field="detailImageUrlMap"/>
-                <if-compare field="isExists" operator="equals" value="N">
-                    <clear-field field="product.detailImageUrl"></clear-field>
-                </if-compare>
-            </if-not-empty>
-            <field-to-result field="filesImageMap" result-name="filesImageMap"/>
-            <store-value value-field="product"/>
-            <!-- set-service-fields service-name="updateProduct" map-name="product" to-map-name="updateProductContext"/>
-            <call-service service-name="updateProduct" in-map-name="updateProductContext" / -->
-            </if-not-empty>
-    </simple-method>
-
-    <!-- get file image url and return Y or N -->
-    <simple-method method-name="checkImageUrl" short-description="Check for image url exists or not" login-required="false">
-        <set field="imageUrl" from-field="parameters.imageUrl"/>
-
-        <call-object-method obj-field="imageUrl" method-name="startsWith" ret-field="httpFlag" >
-            <string value="http"></string>
-        </call-object-method>
-        <call-object-method obj-field="imageUrl" method-name="startsWith" ret-field="httpsFlag" >
-            <string value="https"></string>
-        </call-object-method>
-        <call-object-method obj-field="imageUrl" method-name="startsWith" ret-field="ftpFlag" >
-            <string value="ftp"></string>
-        </call-object-method>
-        <if>
-            <condition>
-                <or>
-                    <if-compare field="httpFlag" operator="equals" value="true" type="Boolean"/>
-                    <if-compare field="httpsFlag" operator="equals" value="true" type="Boolean"/>
-                    <if-compare field="ftpFlag" operator="equals" value="true" type="Boolean"/>
-                </or>
-            </condition>
-            <then>
-                <call-class-method method-name="fromUrlString" class-name="org.apache.ofbiz.base.util.UtilURL" ret-field="url">
-                   <string value="${imageUrl}"/>
-                </call-class-method>
-            </then>
-            <else>
-                <set field="imageUrl" value="/themes/common-theme/webapp${parameters.imageUrl}"/>
-                <call-class-method method-name="fromOfbizHomePath" class-name="org.apache.ofbiz.base.util.UtilURL" ret-field="url">
-                   <string value="${imageUrl}"/>
-                </call-class-method>
-            </else>
-        </if>
-        <if-not-empty field="url">
-            <set field="isExists" value="Y"/>
-        <else>
-            <set field="isExists" value="N"/>
-        </else>
-        </if-not-empty>
-        <field-to-result field="isExists" result-name="isExists"/>
-    </simple-method>
-
-    <simple-method method-name="catalogPermissionCheck" short-description="Catalog permission logic">
-        <set field="primaryPermission" value="CATALOG"/>
-        <call-simple-method method-name="genericBasePermissionCheck" xml-resource="component://common/minilang/permission/CommonPermissionServices.xml"/>
-    </simple-method>
-
-    <simple-method method-name="prodCatalogToPartyPermissionCheck" short-description="ProdCatalogToParty permission logic">
-        <set field="altPermission" value="PARTYMGR"/>
-        <call-simple-method method-name="catalogPermissionCheck"/>
-    </simple-method>
-
-    <simple-method method-name="createMissingCategoryAndProductAltUrls" short-description="create missing category and product alternative urls.">
-        <now-timestamp field="now"/>
-        <field-to-result field="parameters.prodCatalogId" result-name="prodCatalogId"/>
-        <set field="categoriesNotUpdated" value="0" type="Integer"/>
-        <set field="categoriesUpdated" value="0" type="Integer"/>
-        <set field="productsNotUpdated" value="0" type="Integer"/>
-        <set field="productsUpdated" value="0" type="Integer"/>
-        <entity-and entity-name="ProdCatalogCategory" list="prodCatalogCategoryList" filter-by-date="false">
-            <field-map field-name="prodCatalogId" from-field="parameters.prodCatalogId"/>
-        </entity-and>
-
-        <!-- Get all categories -->
-        <set field="parameters.productCategories" value="${groovy: []}" type="List"/>
-        <iterate list="prodCatalogCategoryList" entry="prodCatalogCategory">
-            <set field="rootProductCategoryId" from-field="prodCatalogCategory.productCategoryId"/>
-            <entity-and entity-name="ProductCategoryRollup" list="productCategoryRollupList" filter-by-date="true">
-                <field-map field-name="parentProductCategoryId" from-field="rootProductCategoryId"/>
-            </entity-and>
-            <set field="parameters.parentProductCategoryId" from-field="rootProductCategoryId"/>
-            <call-simple-method method-name="createMissingCategoryAltUrlInline"/>
-        </iterate>
-
-        <iterate list="parameters.productCategories" entry="productCategoryList">
-            <!-- Create Product Category Alternative URLs -->
-            <if-empty field="category">
-                <entity-condition entity-name="ProductCategoryContentAndInfo" list="productCategoryContentAndInfoList" filter-by-date="true" use-cache="true">
-                    <condition-list combine="and">
-                        <condition-expr field-name="productCategoryId" from-field="productCategoryList.productCategoryId"/>
-                        <condition-expr field-name="prodCatContentTypeId" value="ALTERNATIVE_URL"/>
-                    </condition-list>
-                    <order-by field-name="-fromDate"/>
-                </entity-condition>
-                <if-empty field="productCategoryContentAndInfoList">
-                    <set field="createSimpleTextContentForCategoryCtx.fromDate" from-field="now"/>
-                    <set field="createSimpleTextContentForCategoryCtx.prodCatContentTypeId" value="ALTERNATIVE_URL"/>
-                    <set field="createSimpleTextContentForCategoryCtx.localeString" value="en"/>
-                    <set field="createSimpleTextContentForCategoryCtx.productCategoryId" from-field="productCategoryList.productCategoryId"/>
-                    <if-empty field="productCategoryList.categoryName">
-                        <entity-condition entity-name="ProductCategoryContentAndInfo" list="productCategoryContentList" filter-by-date="true" use-cache="true">
-                            <condition-list combine="and">
-                                <condition-expr field-name="productCategoryId" from-field="productCategoryList.productCategoryId"/>
-                                <condition-expr field-name="prodCatContentTypeId" value="CATEGORY_NAME"/>
-                            </condition-list>
-                            <order-by field-name="-fromDate"/>
-                        </entity-condition>
-                        <if-not-empty field="productCategoryContentList">
-                            <first-from-list list="productCategoryContentList" entry="productCategoryContent"/>
-                            <set field="getContentAndDataResourceCtx.contentId" from-field="productCategoryContent.contentId"/>
-                            <call-service service-name="getContentAndDataResource" in-map-name="getContentAndDataResourceCtx">
-                                <result-to-field result-name="resultData" field="resultMap"/>
-                            </call-service>
-                            
-                            <set field="electronicText" from-field="resultMap.electronicText"/>
-                            <set field="createSimpleTextContentForCategoryCtx.text" from-field="electronicText.textData"/>
-                        </if-not-empty>
-                    <else>
-                        <set field="createSimpleTextContentForCategoryCtx.text" from-field="productCategoryList.categoryName"/>
-                    </else>
-                    </if-empty>
-                    <if-not-empty field="createSimpleTextContentForCategoryCtx.text">
-                        <call-service service-name="createSimpleTextContentForCategory" in-map-name="createSimpleTextContentForCategoryCtx"/>
-                        <calculate field="categoriesUpdated" type="Integer">
-                            <calcop operator="add" field="categoriesUpdated">
-                                <number value="1"/>
-                            </calcop>
-                        </calculate>
-                    </if-not-empty>
-                    <check-errors/>
-                <else>
-                    <calculate field="categoriesNotUpdated" type="Integer">
-                        <calcop operator="add" field="categoriesNotUpdated">
-                            <number value="1"/>
-                        </calcop>
-                    </calculate>
-                </else>
-                </if-empty>
-            </if-empty>
-
-            <!-- Create Product Alternative URLs -->
-            <if-empty field="product">
-                <entity-condition entity-name="ProductCategoryMember" list="productCategoryMemberList" filter-by-date="true" use-cache="true">
-                    <condition-list combine="and">
-                        <condition-expr field-name="productCategoryId" from-field="productCategoryList.productCategoryId"/>
-                    </condition-list>
-                    <order-by field-name="-fromDate"/>
-                </entity-condition>
-                <iterate list="productCategoryMemberList" entry="productCategoryMember">
-                    <set field="product.productId" from-field="productCategoryMember.productId"/>
-                    <entity-condition entity-name="ProductContentAndInfo" list="ProductContentAndInfoList" filter-by-date="true" use-cache="true">
-                        <condition-list combine="and">
-                            <condition-expr field-name="productId" from-field="product.productId"/>
-                            <condition-expr field-name="productContentTypeId" value="ALTERNATIVE_URL"/>
-                        </condition-list>
-                        <order-by field-name="-fromDate"/>
-                    </entity-condition>
-                    <if-empty field="ProductContentAndInfoList">
-                        <entity-one entity-name="Product" value-field="productMap">
-                            <field-map field-name="productId" from-field="product.productId"/>
-                        </entity-one>
-                        <set field="createSimpleTextContentForProductCtx.fromDate" from-field="now"/>
-                        <set field="createSimpleTextContentForProductCtx.productContentTypeId" value="ALTERNATIVE_URL"/>
-                        <set field="createSimpleTextContentForProductCtx.localeString" value="en"/>
-                        <set field="createSimpleTextContentForProductCtx.productId" from-field="product.productId"/>
-                        <if-empty field="productMap.internalName">
-                           <set field="createSimpleTextContentForProductCtx.text" from-field="productMap.productName"/>
-                        <else>
-                           <set field="createSimpleTextContentForProductCtx.text" from-field="productMap.internalName"/>
-                        </else>
-                        </if-empty>
-                        <if-not-empty field="createSimpleTextContentForProductCtx.text">
-                            <call-service service-name="createSimpleTextContentForProduct" in-map-name="createSimpleTextContentForProductCtx"/>
-                            <calculate field="productsUpdated" type="Integer">
-                                <calcop operator="add" field="productsUpdated">
-                                    <number value="1"/>
-                                </calcop>
-                            </calculate>
-                        </if-not-empty>
-                        <check-errors/>
-                    <else>
-                        <calculate field="productsNotUpdated" type="Integer">
-                            <calcop operator="add" field="productsNotUpdated">
-                                <number value="1"/>
-                            </calcop>
-                        </calculate>
-                    </else>
-                    </if-empty>
-                </iterate>
-            </if-empty>
-        </iterate>
-        <set field="categoriesUpdatedMessage" value="Categories updated: ${categoriesUpdated}"/>
-        <field-to-list list="successMessageList" field="categoriesUpdatedMessage"/>
-        <set field="productsUpdatedMessage" value="Products updated: ${productsUpdated}"/>
-        <field-to-list list="successMessageList" field="productsUpdatedMessage"/>
-        <field-to-result field="categoriesNotUpdated" result-name="categoriesNotUpdated"/>
-        <field-to-result field="productsNotUpdated" result-name="productsNotUpdated"/>
-        <field-to-result field="categoriesUpdated" result-name="categoriesUpdated"/>
-        <field-to-result field="productsUpdated" result-name="productsUpdated"/>
-    </simple-method>
-
-    <simple-method method-name="createMissingCategoryAltUrlInline" short-description="create missing category alternative inline">
-        <entity-and entity-name="ProductCategoryRollup" list="productCategoryRollups" filter-by-date="true">
-            <field-map field-name="parentProductCategoryId" from-field="parameters.parentProductCategoryId"/>
-        </entity-and>
-        <iterate list="productCategoryRollups" entry="productCategoryRollup">
-            <!-- append product category to list -->
-            <entity-one entity-name="ProductCategory" value-field="productCategory">
-                <field-map field-name="productCategoryId" from-field="productCategoryRollup.productCategoryId"/>
-            </entity-one>
-            <field-to-list list="parameters.productCategories" field="productCategory"/>
-            <!-- find rollup product categories -->
-            <set field="parameters.parentProductCategoryId" from-field="productCategoryRollup.productCategoryId"/>
-            <call-simple-method method-name="createMissingCategoryAltUrlInline"/>
-            <check-errors/>
-        </iterate>
-    </simple-method>
-</simple-methods>
diff --git a/applications/product/servicedef/services.xml b/applications/product/servicedef/services.xml
index 3458698725f..4e821b4814a 100644
--- a/applications/product/servicedef/services.xml
+++ b/applications/product/servicedef/services.xml
@@ -182,7 +182,7 @@ under the License.
         <attribute name="productId" type="String" mode="IN" optional="false"/>
         <attribute name="weight" type="Long" mode="IN" optional="true"/>
     </service>
-    
+
     <service name="createProductReview" engine="simple"
             location="component://product/minilang/product/product/ProductServices.xml" invoke="createProductReview" auth="true">
         <description>Create a product review entity</description>
@@ -245,14 +245,14 @@ under the License.
     <service name="createProductPrice" default-entity-name="ProductPrice" engine="simple"
                 location="component://product/minilang/product/price/PriceServices.xml" invoke="createProductPrice" auth="true">
         <description>
-            Create a Product Price. 
-            
-            If taxAuthGeoId and taxAuthPartyId are passed in then the price will be considered a price 
+            Create a Product Price.
+
+            If taxAuthGeoId and taxAuthPartyId are passed in then the price will be considered a price
             with tax included (the priceWithoutTax, priceWithTax, taxAmount, and taxPercentage fields will also be populated).
-            
+
             If the taxInPrice field is 'Y' then the price field will be left with the tax included (price will be equal to priceWithTax),
             otherwise tax will be removed from the passed in price and the price field will be equal to the priceWithoutTax field.
-            
+
             If taxAuthGeoId or taxAuthPartyId empty then the taxInPrice field will be ignored.
         </description>
         <auto-attributes include="pk" mode="IN" optional="false"/>
@@ -1303,14 +1303,14 @@ under the License.
         <auto-attributes include="pk" mode="IN" optional="false"/>
     </service>
 
-    <service name="catalogPermissionCheck" engine="simple"
-        location="component://product/minilang/product/catalog/CatalogServices.xml" invoke="catalogPermissionCheck" auth="true">
+    <service name="catalogPermissionCheck" engine="groovy"
+        location="component://product/groovyScripts/product/catalog/CatalogServices.groovy" invoke="catalogPermissionCheck" auth="true">
         <description>Catalog Permission Checking Logic</description>
         <implements service="permissionInterface"/>
     </service>
 
-    <service name="prodCatalogToPartyPermissionCheck" engine="simple"
-            location="component://product/minilang/product/catalog/CatalogServices.xml" invoke="prodCatalogToPartyPermissionCheck">
+    <service name="prodCatalogToPartyPermissionCheck" engine="groovy"
+            location="component://product/groovyScripts/product/catalog/CatalogServices.groovy" invoke="prodCatalogToPartyPermissionCheck">
         <description>ProdCatalogToParty Permission Checking Logic</description>
         <implements service="permissionInterface"/>
     </service>
@@ -1320,7 +1320,7 @@ under the License.
         <description>Create product and inventory item</description>
         <attribute name="dirName" type="java.lang.String" mode="IN" optional="true"/>
     </service>
-    
+
     <!-- Start Web Analytics configuration services -->
     <service name="createWebAnalyticsConfig" default-entity-name="WebAnalyticsConfig" engine="entity-auto" invoke="create" auth="true">
         <description>Create a WebAnalyticsConfig</description>
@@ -1336,7 +1336,7 @@ under the License.
         <description>Delete a WebAnalyticsConfig</description>
         <auto-attributes include="pk" mode="IN" optional="false"/>
     </service>
-    
+
     <service name="createWebAnalyticsType" default-entity-name="WebAnalyticsType" engine="entity-auto" invoke="create" auth="true">
         <description>Create a WebAnalyticsType</description>
         <auto-attributes include="pk" mode="IN" optional="false"/>
@@ -1351,7 +1351,7 @@ under the License.
         <description>Delete a WebAnalyticsType</description>
         <auto-attributes include="pk" mode="IN" optional="false"/>
     </service>
-    
+
     <!-- Product Promo Content services -->
     <service name="createProductPromoContent" default-entity-name="ProductPromoContent" engine="entity-auto" invoke="create" auth="true">
         <description>Create Product Promo Content</description>
@@ -1517,12 +1517,12 @@ under the License.
         location="component://product/minilang/product/imagemanagement/ImageManagementServices.xml" invoke="createImageContentApproval" auth="true">
         <attribute name="contentId" mode="IN" type="String" optional="false"/>
     </service>
-    
+
     <service name="removeImageContentApproval" engine="simple"
         location="component://product/minilang/product/imagemanagement/ImageManagementServices.xml" invoke="removeImageContentApproval" auth="true">
         <attribute name="partyId" mode="IN" type="String" optional="false"/>
     </service>
-    
+
     <service name="resizeImages" engine="simple"
         location="component://product/minilang/product/imagemanagement/ImageManagementServices.xml" invoke="resizeImages" auth="true">
         <description>Resize Images.</description>
@@ -1530,7 +1530,7 @@ under the License.
         <attribute name="productId" mode="IN" type="String" optional="false"/>
         <attribute name="size" mode="IN" type="String" optional="false"/>
     </service>
-    
+
     <service name="resizeImageOfProduct" engine="java"
         location="org.apache.ofbiz.product.imagemanagement.ImageManagementServices" invoke="resizeImageOfProduct" auth="true">
         <description>Resize Image Of Product.</description>
@@ -1538,7 +1538,7 @@ under the License.
         <attribute name="dataResourceName" mode="IN" type="String" optional="false"/>
         <attribute name="resizeWidth" mode="IN" type="String" optional="false"/>
     </service>
-    
+
     <service name="createNewImageThumbnail" engine="java"
         location="org.apache.ofbiz.product.imagemanagement.ImageManagementServices" invoke="createNewImageThumbnail" auth="true">
         <description>Create New Image Thumbnail.</description>
@@ -1548,14 +1548,14 @@ under the License.
         <attribute name="drObjectInfo" mode="IN" type="String" optional="false"/>
         <attribute name="sizeWidth" mode="IN" type="String" optional="false"/>
     </service>
-    
+
     <service name="removeImageBySize" engine="simple"
         location="component://product/minilang/product/imagemanagement/ImageManagementServices.xml" invoke="removeImageBySize" auth="true">
         <description>Remove Image By Size.</description>
         <attribute name="productId" mode="IN" type="String" optional="false"/>
         <attribute name="mapKey" mode="IN" type="String" optional="false"/>
     </service>
-    
+
     <service name="replaceImageToExistImage" engine="java"
         location="org.apache.ofbiz.product.imagemanagement.ReplaceImage" invoke="replaceImageToExistImage" auth="true">
         <description>Resize Image Of Product.</description>
@@ -1565,7 +1565,7 @@ under the License.
         <attribute name="dataResourceNameExist" mode="IN" type="String" optional="false"/>
         <attribute name="dataResourceNameReplace" mode="IN" type="String" optional="false"/>
     </service>
-    
+
     <service name="renameImage" engine="java"
         location="org.apache.ofbiz.product.imagemanagement.ImageManagementServices" invoke="renameImage" auth="true">
         <description>Rename Image.</description>
@@ -1573,10 +1573,10 @@ under the License.
         <attribute name="contentId" mode="IN" type="String" optional="false"/>
         <attribute name="drDataResourceName" mode="IN" type="String" optional="false"/>
     </service>
-    
+
     <!-- Alternative URLs -->
-    <service name="createMissingCategoryAndProductAltUrls" engine="simple"
-                location="component://product/minilang/product/catalog/CatalogServices.xml" invoke="createMissingCategoryAndProductAltUrls" auth="true" use-transaction="false">
+    <service name="createMissingCategoryAndProductAltUrls" engine="groovy"
+                location="component://product/groovyScripts/product/catalog/CatalogServices.groovy" invoke="createMissingCategoryAndProductAltUrls" auth="true" use-transaction="false">
         <description>Create missing Category and Product Alternative URLs</description>
         <attribute name="prodCatalogId" mode="INOUT" type="String" optional="false"/>
         <attribute name="category" mode="IN" type="String" optional="true"/>
@@ -1593,7 +1593,7 @@ under the License.
         <auto-attributes include="pk" mode="IN" optional="false"/>
         <auto-attributes include="nonpk" mode="IN" optional="true"/>
     </service>
-    
+
     <service name="updateMarketInterest" default-entity-name="MarketInterest" engine="entity-auto" invoke="update" auth="true">
         <description>Update a Market Interest</description>
         <permission-service service-name="productGenericPermission" main-action="UPDATE"/>
diff --git a/applications/product/servicedef/services_maint.xml b/applications/product/servicedef/services_maint.xml
index ef40320d5cd..72198a6ede3 100644
--- a/applications/product/servicedef/services_maint.xml
+++ b/applications/product/servicedef/services_maint.xml
@@ -93,64 +93,64 @@ under the License.
     </service>
 
     <!-- Check Urls exists or not related services -->
-    <service name="checkImageUrlForAllCategories" engine="simple"
-      location="component://product/minilang/product/catalog/CatalogServices.xml" invoke="checkImageUrlForAllCategories" transaction-timeout="36000">
+    <service name="checkImageUrlForAllCategories" engine="groovy"
+      location="component://product/groovyScripts/product/catalog/CatalogServices.groovy" invoke="checkImageUrlForAllCategories" transaction-timeout="36000">
         <description>check For Image Urls exists or not for all categories</description>
         <attribute name="topCategory" type="String" mode="IN" optional="true"/>
         <attribute name="excludeEmpty" type="Boolean" mode="IN" optional="true"/>
         <attribute name="categoriesMap" type="java.util.Map" mode="OUT" optional="true"/>
     </service>
 
-    <service name="getAllCategories" engine="simple"
-      location="component://product/minilang/product/catalog/CatalogServices.xml" invoke="getAllCategories">
+    <service name="getAllCategories" engine="groovy"
+      location="component://product/groovyScripts/product/catalog/CatalogServices.groovy" invoke="getAllCategories">
         <description>Get all categories of a category </description>
         <attribute name="topCategory" type="String" mode="IN" optional="true"/>
         <attribute name="categories" type="java.util.List" mode="OUT" optional="true"/>
     </service>
 
-    <service name="getRelatedCategories" engine="simple"
-      location="component://product/minilang/product/catalog/CatalogServices.xml" invoke="getRelatedCategories">
+    <service name="getRelatedCategories" engine="groovy"
+      location="component://product/groovyScripts/product/catalog/CatalogServices.groovy" invoke="getRelatedCategories">
         <description>Get all related categories of a category </description>
         <attribute name="parentProductCategoryId" type="String" mode="IN" optional="false"/>
         <attribute name="categories" type="java.util.List" mode="INOUT" optional="true"/>
     </service>
-    
+
     <service name="getCategoryTrail" engine="java"
       location="org.apache.ofbiz.product.category.CategoryWorker" invoke="getCategoryTrail">
-        <description> Returns a complete category trail - can be used for exporting proper category trees. 
-        This is mostly useful when used in combination with breadcrumbs,  for building a facetted index tree, 
+        <description> Returns a complete category trail - can be used for exporting proper category trees.
+        This is mostly useful when used in combination with breadcrumbs,  for building a facetted index tree,
         or to export a category tree for migration to another system.
-        Will create the tree from root point to categoryId. 
-        
+        Will create the tree from root point to categoryId.
+
         This service is not meant to be run on every request.
-        Its best use is to generate the trail every so often and store somewhere (a lucene/solr tree, entities, cache or so). 
+        Its best use is to generate the trail every so often and store somewhere (a lucene/solr tree, entities, cache or so).
         </description>
         <attribute name="productCategoryId" type="String" mode="IN" optional="false"/>
         <attribute name="trail" type="java.util.List" mode="OUT" optional="true"/>
     </service>
 
-    <service name="checkImageUrlForCategoryAndProduct" engine="simple"
-      location="component://product/minilang/product/catalog/CatalogServices.xml" invoke="checkImageUrlForCategoryAndProduct">
+    <service name="checkImageUrlForCategoryAndProduct" engine="groovy"
+      location="component://product/groovyScripts/product/catalog/CatalogServices.groovy" invoke="checkImageUrlForCategoryAndProduct">
         <description>check For Image Urls exists or not for category</description>
         <attribute name="categoryId" type="String" mode="IN" optional="false"/>
         <attribute name="fileNotExists" type="java.util.List" mode="OUT" optional="true"/>
         <attribute name="fileExists" type="java.util.List" mode="OUT" optional="true"/>
     </service>
-    <service name="checkImageUrlForCategory" engine="simple"
-      location="component://product/minilang/product/catalog/CatalogServices.xml" invoke="checkImageUrlForCategory">
+    <service name="checkImageUrlForCategory" engine="groovy"
+      location="component://product/groovyScripts/product/catalog/CatalogServices.groovy" invoke="checkImageUrlForCategory">
         <description>check For Image Urls exists or not For Product</description>
         <attribute name="categoryId" type="String" mode="IN" optional="false"/>
         <attribute name="filesImageMap" type="java.util.Map" mode="OUT" optional="true"/>
     </service>
-    <service name="checkImageUrlForProduct" engine="simple"
-      location="component://product/minilang/product/catalog/CatalogServices.xml" invoke="checkImageUrlForProduct">
+    <service name="checkImageUrlForProduct" engine="groovy"
+      location="component://product/groovyScripts/product/catalog/CatalogServices.groovy" invoke="checkImageUrlForProduct">
         <description>check For Image Urls exists or not For Product</description>
         <attribute name="productId" type="String" mode="IN" optional="false"/>
         <attribute name="filesImageMap" type="java.util.Map" mode="OUT" optional="true"/>
     </service>
 
-    <service name="checkImageUrl" engine="simple"
-      location="component://product/minilang/product/catalog/CatalogServices.xml" invoke="checkImageUrl">
+    <service name="checkImageUrl" engine="groovy"
+      location="component://product/groovyScripts/product/catalog/CatalogServices.groovy" invoke="checkImageUrl">
         <description>check For Image Urls exists or not</description>
         <attribute name="imageUrl" type="String" mode="IN" optional="false"/>
         <attribute name="isExists" type="String" mode="OUT" optional="true"/>