Examples with EntityListIterator org.apache.ofbiz.entity.util.EntityListIterator used on opensource projects

Example 11 with EntityListIterator

use of org.apache.ofbiz.entity.util.EntityListIterator in project ofbiz-framework by apache.

the class EntitySyncContext method assembleKeysToRemove.

public LinkedList<GenericEntity> assembleKeysToRemove() throws SyncDataErrorException {
    // get all removed items from the given time range, add to list for those
    LinkedList<GenericEntity> keysToRemove = new LinkedList<GenericEntity>();
    if (this.nextRemoveTxTime != null && (this.nextRemoveTxTime.equals(currentRunEndTime) || this.nextRemoveTxTime.after(currentRunEndTime))) {
        // this means that for all entities in this pack we found on the last pass that there would be nothing for this one, so just return nothing...
        return keysToRemove;
    }
    // Debug.logInfo("Getting keys to remove; currentRunStartTime=" + currentRunStartTime + ", currentRunEndTime=" + currentRunEndTime, module);
    boolean beganTransaction = false;
    try {
        beganTransaction = TransactionUtil.begin(7200);
    } catch (GenericTransactionException e) {
        throw new SyncDataErrorException("Unable to begin JTA transaction", e);
    }
    try {
        // find all instances of this entity with the STAMP_TX_FIELD != null, sort ascending to get lowest/oldest value first, then grab first and consider as candidate currentRunStartTime
        EntityCondition findValCondition = EntityCondition.makeCondition(EntityCondition.makeCondition(ModelEntity.STAMP_TX_FIELD, EntityOperator.GREATER_THAN_EQUAL_TO, currentRunStartTime), EntityCondition.makeCondition(ModelEntity.STAMP_TX_FIELD, EntityOperator.LESS_THAN, currentRunEndTime));
        EntityListIterator removeEli = EntityQuery.use(delegator).from("EntitySyncRemove").where(findValCondition).orderBy(ModelEntity.STAMP_TX_FIELD, ModelEntity.STAMP_FIELD).queryIterator();
        GenericValue entitySyncRemove = null;
        while ((entitySyncRemove = removeEli.next()) != null) {
            // pull the PK from the EntitySyncRemove in the primaryKeyRemoved field, de-XML-serialize it
            String primaryKeyRemoved = entitySyncRemove.getString("primaryKeyRemoved");
            GenericEntity pkToRemove = null;
            try {
                pkToRemove = (GenericEntity) XmlSerializer.deserialize(primaryKeyRemoved, delegator);
            } catch (IOException e) {
                String errorMsg = "Error deserializing GenericPK to remove in Entity Sync Data for entitySyncId [" + entitySyncId + "] and entitySyncRemoveId [" + entitySyncRemove.getString("entitySyncRemoveId") + "]: " + e.toString();
                Debug.logError(e, errorMsg, module);
                throw new SyncDataErrorException(errorMsg, e);
            } catch (SAXException e) {
                String errorMsg = "Error deserializing GenericPK to remove in Entity Sync Data for entitySyncId [" + entitySyncId + "] and entitySyncRemoveId [" + entitySyncRemove.getString("entitySyncRemoveId") + "]: " + e.toString();
                Debug.logError(e, errorMsg, module);
                throw new SyncDataErrorException(errorMsg, e);
            } catch (ParserConfigurationException e) {
                String errorMsg = "Error deserializing GenericPK to remove in Entity Sync Data for entitySyncId [" + entitySyncId + "] and entitySyncRemoveId [" + entitySyncRemove.getString("entitySyncRemoveId") + "]: " + e.toString();
                Debug.logError(e, errorMsg, module);
                throw new SyncDataErrorException(errorMsg, e);
            } catch (SerializeException e) {
                String errorMsg = "Error deserializing GenericPK to remove in Entity Sync Data for entitySyncId [" + entitySyncId + "] and entitySyncRemoveId [" + entitySyncRemove.getString("entitySyncRemoveId") + "]: " + e.toString();
                Debug.logError(e, errorMsg, module);
                throw new SyncDataErrorException(errorMsg, e);
            }
            // set the stamp fields for future reference
            pkToRemove.set(ModelEntity.STAMP_TX_FIELD, entitySyncRemove.get(ModelEntity.STAMP_TX_FIELD));
            pkToRemove.set(ModelEntity.STAMP_FIELD, entitySyncRemove.get(ModelEntity.STAMP_FIELD));
            pkToRemove.set(ModelEntity.CREATE_STAMP_TX_FIELD, entitySyncRemove.get(ModelEntity.CREATE_STAMP_TX_FIELD));
            pkToRemove.set(ModelEntity.CREATE_STAMP_FIELD, entitySyncRemove.get(ModelEntity.CREATE_STAMP_FIELD));
            if (this.entityNameToUseSet.contains(pkToRemove.getEntityName())) {
                keysToRemove.add(pkToRemove);
            }
        }
        removeEli.close();
        // if we didn't find anything for this entity, find the next value's Timestamp and keep track of it
        if (keysToRemove.size() == 0) {
            EntityCondition findNextCondition = EntityCondition.makeCondition(ModelEntity.STAMP_TX_FIELD, EntityOperator.GREATER_THAN_EQUAL_TO, currentRunEndTime);
            EntityListIterator eliNext = EntityQuery.use(delegator).from("EntitySyncRemove").where(findNextCondition).orderBy(ModelEntity.STAMP_TX_FIELD).queryIterator();
            // get the first element and it's tx time value...
            GenericValue firstVal = eliNext.next();
            eliNext.close();
            if (firstVal != null) {
                Timestamp nextTxTime = firstVal.getTimestamp(ModelEntity.STAMP_TX_FIELD);
                if (this.nextRemoveTxTime == null || nextTxTime.before(this.nextRemoveTxTime)) {
                    this.nextRemoveTxTime = nextTxTime;
                }
            }
        }
    } catch (GenericEntityException e) {
        try {
            TransactionUtil.rollback(beganTransaction, "Entity Engine error in assembleKeysToRemove", e);
        } catch (GenericTransactionException e2) {
            Debug.logWarning(e2, "Unable to call rollback()", module);
        }
        throw new SyncDataErrorException("Error getting keys to remove from the datasource", e);
    } catch (Throwable t) {
        try {
            TransactionUtil.rollback(beganTransaction, "General error in assembleKeysToRemove", t);
        } catch (GenericTransactionException e2) {
            Debug.logWarning(e2, "Unable to call rollback()", module);
        }
        throw new SyncDataErrorException("Caught runtime error while getting keys to remove", t);
    }
    try {
        TransactionUtil.commit(beganTransaction);
    } catch (GenericTransactionException e) {
        throw new SyncDataErrorException("Commit transaction failed", e);
    }
    // TEST SECTION: leave false for normal use
    boolean logValues = false;
    if (logValues && keysToRemove.size() > 0) {
        StringBuilder toRemoveInfo = new StringBuilder();
        for (GenericEntity keyToRemove : keysToRemove) {
            toRemoveInfo.append("\n-->[");
            toRemoveInfo.append(keyToRemove.get(ModelEntity.STAMP_TX_FIELD));
            toRemoveInfo.append(":");
            toRemoveInfo.append(keyToRemove.get(ModelEntity.STAMP_FIELD));
            toRemoveInfo.append("] ");
            toRemoveInfo.append(keyToRemove);
        }
        Debug.logInfo(toRemoveInfo.toString(), module);
    }
    // this calculation is false, so it needs to be nullified
    if (keysToRemove.size() > 0) {
        this.nextRemoveTxTime = null;
    }
    return keysToRemove;
}

Example 12 with EntityListIterator

use of org.apache.ofbiz.entity.util.EntityListIterator in project ofbiz-framework by apache.

the class EntitySyncContext method assembleValuesToCreate.

public ArrayList<GenericValue> assembleValuesToCreate() throws SyncDataErrorException {
    // first grab all values inserted in the date range, then get the updates (leaving out all values inserted in the data range)
    // make it an ArrayList to easily merge in sorted lists
    ArrayList<GenericValue> valuesToCreate = new ArrayList<GenericValue>();
    if (this.nextCreateTxTime != null && (this.nextCreateTxTime.equals(currentRunEndTime) || this.nextCreateTxTime.after(currentRunEndTime))) {
        // this means that for all entities in this pack we found on the last pass that there would be nothing for this one, so just return nothing...
        return valuesToCreate;
    }
    // Debug.logInfo("Getting values to create; currentRunStartTime=" + currentRunStartTime + ", currentRunEndTime=" + currentRunEndTime, module);
    int entitiesSkippedForKnownNext = 0;
    // iterate through entities, get all records with tx stamp in the current time range, put all in a single list
    for (ModelEntity modelEntity : entityModelToUseList) {
        int insertBefore = 0;
        // first test to see if we know that there are no records for this entity in this time period...
        Timestamp knownNextCreateTime = this.nextEntityCreateTxTime.get(modelEntity.getEntityName());
        if (knownNextCreateTime != null && (knownNextCreateTime.equals(currentRunEndTime) || knownNextCreateTime.after(currentRunEndTime))) {
            // Debug.logInfo("In assembleValuesToCreate found knownNextCreateTime [" + knownNextCreateTime + "] after currentRunEndTime [" + currentRunEndTime + "], so skipping time per period for entity [" + modelEntity.getEntityName() + "]", module);
            entitiesSkippedForKnownNext++;
            continue;
        }
        boolean beganTransaction = false;
        try {
            beganTransaction = TransactionUtil.begin(7200);
        } catch (GenericTransactionException e) {
            throw new SyncDataErrorException("Unable to begin JTA transaction", e);
        }
        try {
            EntityCondition findValCondition = EntityCondition.makeCondition(EntityCondition.makeCondition(ModelEntity.CREATE_STAMP_TX_FIELD, EntityOperator.GREATER_THAN_EQUAL_TO, currentRunStartTime), EntityCondition.makeCondition(ModelEntity.CREATE_STAMP_TX_FIELD, EntityOperator.LESS_THAN, currentRunEndTime));
            EntityQuery eq = EntityQuery.use(delegator).from(modelEntity.getEntityName()).where(findValCondition).orderBy(ModelEntity.CREATE_STAMP_TX_FIELD, ModelEntity.CREATE_STAMP_FIELD);
            long valuesPerEntity = 0;
            try (EntityListIterator eli = eq.queryIterator()) {
                // get the values created within the current time range
                GenericValue nextValue = null;
                while ((nextValue = eli.next()) != null) {
                    // find first value in valuesToCreate list, starting with the current insertBefore value, that has a CREATE_STAMP_TX_FIELD after the nextValue.CREATE_STAMP_TX_FIELD, then do the same with CREATE_STAMP_FIELD
                    while (insertBefore < valuesToCreate.size() && valuesToCreate.get(insertBefore).getTimestamp(ModelEntity.CREATE_STAMP_TX_FIELD).before(nextValue.getTimestamp(ModelEntity.CREATE_STAMP_TX_FIELD))) {
                        insertBefore++;
                    }
                    while (insertBefore < valuesToCreate.size() && valuesToCreate.get(insertBefore).getTimestamp(ModelEntity.CREATE_STAMP_FIELD).before(nextValue.getTimestamp(ModelEntity.CREATE_STAMP_FIELD))) {
                        insertBefore++;
                    }
                    valuesToCreate.add(insertBefore, nextValue);
                    valuesPerEntity++;
                }
            } catch (GenericEntityException e) {
                try {
                    TransactionUtil.rollback(beganTransaction, "Entity Engine error in assembleValuesToCreate", e);
                } catch (GenericTransactionException e2) {
                    Debug.logWarning(e2, "Unable to call rollback()", module);
                }
                throw new SyncDataErrorException("Error getting values to create from the datasource", e);
            }
            // if we didn't find anything for this entity, find the next value's Timestamp and keep track of it
            if (valuesPerEntity == 0) {
                Timestamp startCheckStamp = new Timestamp(System.currentTimeMillis() - syncEndBufferMillis);
                EntityCondition findNextCondition = EntityCondition.makeCondition(EntityCondition.makeCondition(ModelEntity.CREATE_STAMP_TX_FIELD, EntityOperator.NOT_EQUAL, null), EntityCondition.makeCondition(ModelEntity.CREATE_STAMP_TX_FIELD, EntityOperator.GREATER_THAN_EQUAL_TO, currentRunEndTime));
                eq = EntityQuery.use(delegator).from(modelEntity.getEntityName()).where(findNextCondition).orderBy(ModelEntity.CREATE_STAMP_TX_FIELD);
                GenericValue firstVal = null;
                try (EntityListIterator eliNext = eq.queryIterator()) {
                    // get the first element and it's tx time value...
                    firstVal = eliNext.next();
                } catch (GenericEntityException e) {
                    try {
                        TransactionUtil.rollback(beganTransaction, "Entity Engine error in assembleValuesToCreate", e);
                    } catch (GenericTransactionException e2) {
                        Debug.logWarning(e2, "Unable to call rollback()", module);
                    }
                    throw new SyncDataErrorException("Error getting values to create from the datasource", e);
                }
                Timestamp nextTxTime;
                if (firstVal != null) {
                    nextTxTime = firstVal.getTimestamp(ModelEntity.CREATE_STAMP_TX_FIELD);
                } else {
                    // no results? well, then it's safe to say that up to the pre-querytime (minus the buffer, as usual) we are okay
                    nextTxTime = startCheckStamp;
                }
                if (this.nextCreateTxTime == null || nextTxTime.before(this.nextCreateTxTime)) {
                    this.nextCreateTxTime = nextTxTime;
                    Debug.logInfo("EntitySync: Set nextCreateTxTime to [" + nextTxTime + "]", module);
                }
                Timestamp curEntityNextTxTime = this.nextEntityCreateTxTime.get(modelEntity.getEntityName());
                if (curEntityNextTxTime == null || nextTxTime.before(curEntityNextTxTime)) {
                    this.nextEntityCreateTxTime.put(modelEntity.getEntityName(), nextTxTime);
                    Debug.logInfo("EntitySync: Set nextEntityCreateTxTime to [" + nextTxTime + "] for the entity [" + modelEntity.getEntityName() + "]", module);
                }
            }
        } catch (Throwable t) {
            try {
                TransactionUtil.rollback(beganTransaction, "Throwable error in assembleValuesToCreate", t);
            } catch (GenericTransactionException e2) {
                Debug.logWarning(e2, "Unable to call rollback()", module);
            }
            throw new SyncDataErrorException("Caught runtime error while getting values to create", t);
        }
        try {
            TransactionUtil.commit(beganTransaction);
        } catch (GenericTransactionException e) {
            throw new SyncDataErrorException("Commit transaction failed", e);
        }
    }
    if (entitiesSkippedForKnownNext > 0) {
        if (Debug.infoOn())
            Debug.logInfo("In assembleValuesToCreate skipped [" + entitiesSkippedForKnownNext + "/" + entityModelToUseList + "] entities for the time period ending at [" + currentRunEndTime + "] because of next known create times", module);
    }
    // TEST SECTION: leave false for normal use
    boolean logValues = false;
    if (logValues && valuesToCreate.size() > 0) {
        StringBuilder toCreateInfo = new StringBuilder();
        for (GenericValue valueToCreate : valuesToCreate) {
            toCreateInfo.append("\n-->[");
            toCreateInfo.append(valueToCreate.get(ModelEntity.CREATE_STAMP_TX_FIELD));
            toCreateInfo.append(":");
            toCreateInfo.append(valueToCreate.get(ModelEntity.CREATE_STAMP_FIELD));
            toCreateInfo.append("] ");
            toCreateInfo.append(valueToCreate.getPrimaryKey());
        }
        Debug.logInfo(toCreateInfo.toString(), module);
    }
    // this calculation is false, so it needs to be nullified
    if (valuesToCreate.size() > 0) {
        this.nextCreateTxTime = null;
    }
    return valuesToCreate;
}

Example 13 with EntityListIterator

use of org.apache.ofbiz.entity.util.EntityListIterator in project ofbiz-framework by apache.

the class EntitySyncContext method getCurrentRunStartTime.

protected static Timestamp getCurrentRunStartTime(Timestamp lastSuccessfulSynchTime, List<ModelEntity> entityModelToUseList, Delegator delegator) throws GenericEntityException {
    // if currentRunStartTime is null, what to do? I guess iterate through all entities and find earliest tx stamp
    if (lastSuccessfulSynchTime == null) {
        Timestamp currentRunStartTime = null;
        for (ModelEntity modelEntity : entityModelToUseList) {
            // fields to select will be PK and the STAMP_TX_FIELD, slimmed down so we don't get a ton of data back
            Set<String> fieldsToSelect = UtilMisc.toSet(modelEntity.getPkFieldNames());
            // find all instances of this entity with the STAMP_TX_FIELD != null, sort ascending to get lowest/oldest value first, then grab first and consider as candidate currentRunStartTime
            fieldsToSelect.add(ModelEntity.STAMP_TX_FIELD);
            EntityListIterator eli = EntityQuery.use(delegator).select(fieldsToSelect).from(modelEntity.getEntityName()).where(EntityCondition.makeCondition(ModelEntity.STAMP_TX_FIELD, EntityOperator.NOT_EQUAL, null)).orderBy(ModelEntity.STAMP_TX_FIELD).queryIterator();
            GenericValue nextValue = eli.next();
            eli.close();
            if (nextValue != null) {
                Timestamp candidateTime = nextValue.getTimestamp(ModelEntity.STAMP_TX_FIELD);
                if (currentRunStartTime == null || candidateTime.before(currentRunStartTime)) {
                    currentRunStartTime = candidateTime;
                }
            }
        }
        if (Debug.infoOn())
            Debug.logInfo("No currentRunStartTime was stored on the EntitySync record, so searched for the earliest value and got: " + currentRunStartTime, module);
        return currentRunStartTime;
    } else {
        return lastSuccessfulSynchTime;
    }
}

Example 14 with EntityListIterator

use of org.apache.ofbiz.entity.util.EntityListIterator in project ofbiz-framework by apache.

the class ServiceUtil method purgeOldJobs.

public static Map<String, Object> purgeOldJobs(DispatchContext dctx, Map<String, ? extends Object> context) {
    Locale locale = (Locale) context.get("locale");
    Debug.logWarning("purgeOldJobs service invoked. This service is obsolete - the Job Scheduler will purge old jobs automatically.", module);
    String sendPool = null;
    Calendar cal = Calendar.getInstance();
    try {
        sendPool = ServiceConfigUtil.getServiceEngine().getThreadPool().getSendToPool();
        int daysToKeep = ServiceConfigUtil.getServiceEngine().getThreadPool().getPurgeJobDays();
        cal.add(Calendar.DAY_OF_YEAR, -daysToKeep);
    } catch (GenericConfigException e) {
        Debug.logWarning(e, "Exception thrown while getting service configuration: ", module);
        return returnError(UtilProperties.getMessage(ServiceUtil.resource, "ServiceExceptionThrownWhileGettingServiceConfiguration", UtilMisc.toMap("errorString", e), locale));
    }
    Delegator delegator = dctx.getDelegator();
    Timestamp purgeTime = new Timestamp(cal.getTimeInMillis());
    // create the conditions to query
    EntityCondition pool = EntityCondition.makeCondition("poolId", sendPool);
    List<EntityExpr> finExp = UtilMisc.toList(EntityCondition.makeCondition("finishDateTime", EntityOperator.NOT_EQUAL, null));
    finExp.add(EntityCondition.makeCondition("finishDateTime", EntityOperator.LESS_THAN, purgeTime));
    List<EntityExpr> canExp = UtilMisc.toList(EntityCondition.makeCondition("cancelDateTime", EntityOperator.NOT_EQUAL, null));
    canExp.add(EntityCondition.makeCondition("cancelDateTime", EntityOperator.LESS_THAN, purgeTime));
    EntityCondition cancelled = EntityCondition.makeCondition(canExp);
    EntityCondition finished = EntityCondition.makeCondition(finExp);
    EntityCondition doneCond = EntityCondition.makeCondition(UtilMisc.toList(cancelled, finished), EntityOperator.OR);
    // always suspend the current transaction; use the one internally
    Transaction parent = null;
    try {
        if (TransactionUtil.getStatus() != TransactionUtil.STATUS_NO_TRANSACTION) {
            parent = TransactionUtil.suspend();
        }
        // lookup the jobs - looping 1000 at a time to avoid problems with cursors
        // also, using unique transaction to delete as many as possible even with errors
        boolean noMoreResults = false;
        boolean beganTx1 = false;
        while (!noMoreResults) {
            // current list of records
            List<GenericValue> curList = null;
            try {
                // begin this transaction
                beganTx1 = TransactionUtil.begin();
                EntityQuery eq = EntityQuery.use(delegator).select("jobId").from("JobSandbox").where(EntityCondition.makeCondition(UtilMisc.toList(doneCond, pool))).cursorScrollInsensitive().maxRows(1000);
                try (EntityListIterator foundJobs = eq.queryIterator()) {
                    curList = foundJobs.getPartialList(1, 1000);
                }
            } catch (GenericEntityException e) {
                Debug.logError(e, "Cannot obtain job data from datasource", module);
                try {
                    TransactionUtil.rollback(beganTx1, e.getMessage(), e);
                } catch (GenericTransactionException e1) {
                    Debug.logWarning(e1, module);
                }
                return ServiceUtil.returnError(e.getMessage());
            } finally {
                try {
                    TransactionUtil.commit(beganTx1);
                } catch (GenericTransactionException e) {
                    Debug.logWarning(e, module);
                }
            }
            // remove each from the list in its own transaction
            if (UtilValidate.isNotEmpty(curList)) {
                for (GenericValue job : curList) {
                    String jobId = job.getString("jobId");
                    boolean beganTx2 = false;
                    try {
                        beganTx2 = TransactionUtil.begin();
                        job.remove();
                    } catch (GenericEntityException e) {
                        Debug.logInfo("Cannot remove job data for ID: " + jobId, module);
                        try {
                            TransactionUtil.rollback(beganTx2, e.getMessage(), e);
                        } catch (GenericTransactionException e1) {
                            Debug.logWarning(e1, module);
                        }
                    } finally {
                        try {
                            TransactionUtil.commit(beganTx2);
                        } catch (GenericTransactionException e) {
                            Debug.logWarning(e, module);
                        }
                    }
                }
            } else {
                noMoreResults = true;
            }
        }
        // Now JobSandbox data is cleaned up. Now process Runtime data and remove the whole data in single shot that is of no need.
        boolean beganTx3 = false;
        GenericValue runtimeData = null;
        List<GenericValue> runtimeDataToDelete = new LinkedList<>();
        long jobsandBoxCount = 0;
        try {
            // begin this transaction
            beganTx3 = TransactionUtil.begin();
            EntityQuery eq = EntityQuery.use(delegator).select("runtimeDataId").from("RuntimeData");
            try (EntityListIterator runTimeDataIt = eq.queryIterator()) {
                while ((runtimeData = runTimeDataIt.next()) != null) {
                    EntityCondition whereCondition = EntityCondition.makeCondition(UtilMisc.toList(EntityCondition.makeCondition("runtimeDataId", EntityOperator.NOT_EQUAL, null), EntityCondition.makeCondition("runtimeDataId", EntityOperator.EQUALS, runtimeData.getString("runtimeDataId"))), EntityOperator.AND);
                    jobsandBoxCount = EntityQuery.use(delegator).from("JobSandbox").where(whereCondition).queryCount();
                    if (BigDecimal.ZERO.compareTo(BigDecimal.valueOf(jobsandBoxCount)) == 0) {
                        runtimeDataToDelete.add(runtimeData);
                    }
                }
            }
            // Now we are ready to delete runtimeData, we can safely delete complete list that we have recently fetched i.e runtimeDataToDelete.
            delegator.removeAll(runtimeDataToDelete);
        } catch (GenericEntityException e) {
            Debug.logError(e, "Cannot obtain runtime data from datasource", module);
            try {
                TransactionUtil.rollback(beganTx3, e.getMessage(), e);
            } catch (GenericTransactionException e1) {
                Debug.logWarning(e1, module);
            }
            return ServiceUtil.returnError(e.getMessage());
        } finally {
            try {
                TransactionUtil.commit(beganTx3);
            } catch (GenericTransactionException e) {
                Debug.logWarning(e, module);
            }
        }
    } catch (GenericTransactionException e) {
        Debug.logError(e, "Unable to suspend transaction; cannot purge jobs!", module);
        return ServiceUtil.returnError(e.getMessage());
    } finally {
        if (parent != null) {
            try {
                TransactionUtil.resume(parent);
            } catch (GenericTransactionException e) {
                Debug.logWarning(e, module);
            }
        }
    }
    return ServiceUtil.returnSuccess();
}

Example 15 with EntityListIterator

use of org.apache.ofbiz.entity.util.EntityListIterator in project ofbiz-framework by apache.

the class WebToolsServices method entityExportAll.

public static Map<String, Object> entityExportAll(DispatchContext dctx, Map<String, ? extends Object> context) {
    Delegator delegator = dctx.getDelegator();
    Locale locale = (Locale) context.get("locale");
    // mandatory
    String outpath = (String) context.get("outpath");
    Timestamp fromDate = (Timestamp) context.get("fromDate");
    Integer txTimeout = (Integer) context.get("txTimeout");
    if (txTimeout == null) {
        txTimeout = Integer.valueOf(7200);
    }
    List<String> results = new LinkedList<String>();
    if (UtilValidate.isNotEmpty(outpath)) {
        File outdir = new File(outpath);
        if (!outdir.exists()) {
            outdir.mkdir();
        }
        if (outdir.isDirectory() && outdir.canWrite()) {
            Set<String> passedEntityNames;
            try {
                ModelReader reader = delegator.getModelReader();
                Collection<String> ec = reader.getEntityNames();
                passedEntityNames = new TreeSet<String>(ec);
            } catch (Exception exc) {
                return ServiceUtil.returnError(UtilProperties.getMessage(resource, "EntityImportErrorRetrievingEntityNames", locale));
            }
            int fileNumber = 1;
            for (String curEntityName : passedEntityNames) {
                long numberWritten = 0;
                ModelEntity me = delegator.getModelEntity(curEntityName);
                if (me instanceof ModelViewEntity) {
                    results.add("[" + fileNumber + "] [vvv] " + curEntityName + " skipping view entity");
                    continue;
                }
                List<EntityCondition> conds = new LinkedList<EntityCondition>();
                if (UtilValidate.isNotEmpty(fromDate)) {
                    conds.add(EntityCondition.makeCondition("createdStamp", EntityOperator.GREATER_THAN_EQUAL_TO, fromDate));
                }
                EntityQuery eq = EntityQuery.use(delegator).from(curEntityName).where(conds).orderBy(me.getPkFieldNames());
                try {
                    boolean beganTx = TransactionUtil.begin();
                    // Don't bother writing the file if there's nothing to put into it
                    try (EntityListIterator values = eq.queryIterator()) {
                        GenericValue value = values.next();
                        if (value != null) {
                            try (PrintWriter writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(outdir, curEntityName + ".xml")), "UTF-8")))) {
                                writer.println("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
                                writer.println("<entity-engine-xml>");
                                do {
                                    value.writeXmlText(writer, "");
                                    numberWritten++;
                                    if (numberWritten % 500 == 0) {
                                        TransactionUtil.commit(beganTx);
                                        beganTx = TransactionUtil.begin();
                                    }
                                } while ((value = values.next()) != null);
                                writer.println("</entity-engine-xml>");
                            } catch (UnsupportedEncodingException | FileNotFoundException e) {
                                results.add("[" + fileNumber + "] [xxx] Error when writing " + curEntityName + ": " + e);
                            }
                            results.add("[" + fileNumber + "] [" + numberWritten + "] " + curEntityName + " wrote " + numberWritten + " records");
                        } else {
                            results.add("[" + fileNumber + "] [---] " + curEntityName + " has no records, not writing file");
                        }
                        TransactionUtil.commit(beganTx);
                    } catch (GenericEntityException entityEx) {
                        results.add("[" + fileNumber + "] [xxx] Error when writing " + curEntityName + ": " + entityEx);
                        continue;
                    }
                    fileNumber++;
                } catch (GenericTransactionException e) {
                    Debug.logError(e, module);
                    results.add(e.getLocalizedMessage());
                }
            }
        } else {
            results.add("Path not found or no write access.");
        }
    } else {
        results.add("No path specified, doing nothing.");
    }
    // send the notification
    Map<String, Object> resp = UtilMisc.<String, Object>toMap("results", results);
    return resp;
}