/**
* convert AccountHqContractObjectKeyFilter to a Map.
*
* @param in the filter object to convert to the Map
* @param record use this Map instead of creating a new one (Optional)
* @param rootName use this name as the root name for the object (defaults to
* "AccountHqContractObject")
* @return Map the output Map
*/
public static Map toMap(AccountHqContractObjectKeyFilter in, Map record, String rootName) {
Integer iVal = null;
if (record == null) record = new HashMap();
if (rootName == null) rootName = "AccountHqContractObject";
Map keyMap = (Map) record.get(rootName);
if (keyMap != null) keyMap = (Map) record.get("Key");
keyMap.put("Key", getMap(in, keyMap));
record.put(rootName, keyMap);
if ((iVal = in.getIndex()) != null) record.put("Index", iVal);
return record;
}
/**
* convert Map to AccountHqContractObjectKeyFilter.
*
* @param record the Map containing the data to convert to the object, not including the root
* @return AccountHqContractObjectKeyFilter the converted object
*/
public static AccountHqContractObjectKeyFilter getFilter(Map record) {
Object[] list = null;
Object obj = null;
if (record == null) return null;
AccountHqContractObjectKeyFilter out = new AccountHqContractObjectKeyFilter();
Map AccountInternalIdMap = (Map) record.get("AccountInternalId");
Boolean AccountInternalIdFetch = DataHelper.getFetch(AccountInternalIdMap);
Boolean AccountInternalIdSortDir = DataHelper.getSortDirection(AccountInternalIdMap);
Integer AccountInternalIdSortOrder = DataHelper.getSortOrder(AccountInternalIdMap);
if (AccountInternalIdFetch != null) out.setAccountInternalIdFetch(AccountInternalIdFetch);
if (AccountInternalIdSortDir != null)
out.setAccountInternalIdSortDirection(AccountInternalIdSortDir);
if (AccountInternalIdSortOrder != null)
out.setAccountInternalIdSortOrder(AccountInternalIdSortOrder);
Filter[] AccountInternalIdFilter =
DataHelper.mapToFilterArray(AccountInternalIdMap, Integer.class);
if (AccountInternalIdFilter != null) {
IntegerFilter[] AccountInternalIdFilters = new IntegerFilter[AccountInternalIdFilter.length];
for (int i = 0; i < AccountInternalIdFilters.length; i++) {
AccountInternalIdFilters[i] = (IntegerFilter) AccountInternalIdFilter[i];
}
try {
out.setAccountInternalIdFilter(AccountInternalIdFilters);
} catch (Exception x) {
x.printStackTrace();
}
}
Map TrackingIdMap = (Map) record.get("TrackingId");
Boolean TrackingIdFetch = DataHelper.getFetch(TrackingIdMap);
Boolean TrackingIdSortDir = DataHelper.getSortDirection(TrackingIdMap);
Integer TrackingIdSortOrder = DataHelper.getSortOrder(TrackingIdMap);
if (TrackingIdFetch != null) out.setTrackingIdFetch(TrackingIdFetch);
if (TrackingIdSortDir != null) out.setTrackingIdSortDirection(TrackingIdSortDir);
if (TrackingIdSortOrder != null) out.setTrackingIdSortOrder(TrackingIdSortOrder);
Filter[] TrackingIdFilter = DataHelper.mapToFilterArray(TrackingIdMap, Integer.class);
if (TrackingIdFilter != null) {
IntegerFilter[] TrackingIdFilters = new IntegerFilter[TrackingIdFilter.length];
for (int i = 0; i < TrackingIdFilters.length; i++) {
TrackingIdFilters[i] = (IntegerFilter) TrackingIdFilter[i];
}
try {
out.setTrackingIdFilter(TrackingIdFilters);
} catch (Exception x) {
x.printStackTrace();
}
}
Map TrackingIdServMap = (Map) record.get("TrackingIdServ");
Boolean TrackingIdServFetch = DataHelper.getFetch(TrackingIdServMap);
Boolean TrackingIdServSortDir = DataHelper.getSortDirection(TrackingIdServMap);
Integer TrackingIdServSortOrder = DataHelper.getSortOrder(TrackingIdServMap);
if (TrackingIdServFetch != null) out.setTrackingIdServFetch(TrackingIdServFetch);
if (TrackingIdServSortDir != null) out.setTrackingIdServSortDirection(TrackingIdServSortDir);
if (TrackingIdServSortOrder != null) out.setTrackingIdServSortOrder(TrackingIdServSortOrder);
Filter[] TrackingIdServFilter = DataHelper.mapToFilterArray(TrackingIdServMap, Integer.class);
if (TrackingIdServFilter != null) {
IntegerFilter[] TrackingIdServFilters = new IntegerFilter[TrackingIdServFilter.length];
for (int i = 0; i < TrackingIdServFilters.length; i++) {
TrackingIdServFilters[i] = (IntegerFilter) TrackingIdServFilter[i];
}
try {
out.setTrackingIdServFilter(TrackingIdServFilters);
} catch (Exception x) {
x.printStackTrace();
}
}
Map StartDtMap = (Map) record.get("StartDt");
Boolean StartDtFetch = DataHelper.getFetch(StartDtMap);
Boolean StartDtSortDir = DataHelper.getSortDirection(StartDtMap);
Integer StartDtSortOrder = DataHelper.getSortOrder(StartDtMap);
if (StartDtFetch != null) out.setStartDtFetch(StartDtFetch);
if (StartDtSortDir != null) out.setStartDtSortDirection(StartDtSortDir);
if (StartDtSortOrder != null) out.setStartDtSortOrder(StartDtSortOrder);
Filter[] StartDtFilter = DataHelper.mapToFilterArray(StartDtMap, Date.class);
if (StartDtFilter != null) {
DateFilter[] StartDtFilters = new DateFilter[StartDtFilter.length];
for (int i = 0; i < StartDtFilters.length; i++) {
StartDtFilters[i] = (DateFilter) StartDtFilter[i];
}
try {
out.setStartDtFilter(StartDtFilters);
} catch (Exception x) {
x.printStackTrace();
}
}
Boolean Fetch = DataHelper.getFetch(record);
if (Fetch != null) out.setFetch(Fetch);
Integer Index = DataHelper.getIndex(record);
if (Index != null) out.setIndex(Index);
return out;
}