1220 lines
40 KiB
OpenEdge ABL
1220 lines
40 KiB
OpenEdge ABL
/**
|
|
* File Name: fflib_SObjects2
|
|
* @description Primitive domain for the object type SObject
|
|
*
|
|
* @author architect ir. Wilhelmus G.J. Velzeboer
|
|
*
|
|
* Copyright (c), W.G.J. Velzeboer,
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
*
|
|
* - Redistributions of source code must retain the above author notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* - Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* - Neither the name of the author nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software without
|
|
* specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
|
* THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
|
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
public virtual class fflib_SObjects2 extends fflib_SObjects implements fflib_ISObjects2 {
|
|
protected Schema.DescribeSObjectResult SObjectDescribe { get; private set; }
|
|
|
|
/**
|
|
* Class constructors
|
|
*
|
|
* @param objects The Objects of type SObjectType, to contain inside the domain
|
|
*/
|
|
public fflib_SObjects2(List<Object> objects) {
|
|
// todo - assert of objects of type SObject
|
|
this((List<SObject>) objects);
|
|
}
|
|
|
|
/**
|
|
* Class constructor
|
|
*
|
|
* @param records The records to contain inside the domain
|
|
*/
|
|
public fflib_SObjects2(List<SObject> records) {
|
|
this(records, records.getSObjectType());
|
|
}
|
|
|
|
/**
|
|
* Class constructor
|
|
*
|
|
* @param records The records to contain inside the domain
|
|
* @param sObjectType The SObjectType of the records
|
|
*/
|
|
public fflib_SObjects2(
|
|
List<SObject> records,
|
|
Schema.SObjectType sObjectType
|
|
) {
|
|
super(records, sObjectType);
|
|
SObjectDescribe = sObjectType.getDescribe();
|
|
}
|
|
|
|
/**
|
|
* @param id Domain containing primary key (Id field) values
|
|
*
|
|
* @return Returns only the SObjects from the domain matching the given Ids.
|
|
*/
|
|
public virtual SObject getRecord(Id id) {
|
|
List<SObject> result = getRecords(new Set<Id>{ id });
|
|
|
|
return (result.size() == 0) ? null : result.get(0);
|
|
}
|
|
|
|
/**
|
|
* Creates a map between the record Ids of this domain to the last given grandparent domain.
|
|
*
|
|
* @param domainsByRelationshipField A Map of domains and the in hierarchical order from first parent to grandparent
|
|
*
|
|
* @return Returns a map with KEY: The Ids of the records in this domain,
|
|
* to the VALUE: The Id of the last grandparent record listed in the relatedDomains,
|
|
* null if no grandparent exists.
|
|
*
|
|
* @example
|
|
* ICases casesDomain = Cases.newInstance(caseRecords);
|
|
* IContacts contactsDomain = Contacts.newInstance(contactRecords);
|
|
* IAccount accountDomain = Accounts.newInstance(accountRecords);
|
|
*
|
|
* // A map with key - Case.Id to value - Account.Id
|
|
* Map<Id, Id> accountIdByCaseId =
|
|
* casesDomain.getParentIdById(
|
|
* new Map<Schema.SObjectField, fflib_SObjects2>
|
|
* {
|
|
* Schema.Case.ContactId => contactDomain,
|
|
* Schema.Contact.AccountId => accountDomain
|
|
* });
|
|
*/
|
|
public virtual Map<Id, Id> getParentIdById(
|
|
Map<Schema.SObjectField, fflib_SObjects2> domainsByRelationshipField
|
|
) {
|
|
// Takes the highest related domain from the domainsByRelationshipField
|
|
Schema.SObjectField relationshipField = new List<Schema.SObjectField>(
|
|
domainsByRelationshipField.keySet()
|
|
)
|
|
.get(0);
|
|
fflib_SObjects2 relatedDomain = domainsByRelationshipField.remove(
|
|
relationshipField
|
|
);
|
|
|
|
// Extract the Id values of the related SObjectType
|
|
Map<Id, Id> result = getIdFieldByIdField(
|
|
relationshipField,
|
|
getSObjectType().getDescribe().fields.getMap().get('Id')
|
|
);
|
|
|
|
// Check if we need to resolve another parent relation, if not return the results
|
|
if (domainsByRelationshipField.isEmpty())
|
|
return result;
|
|
|
|
// Fetch the Ids of the related SObjectType
|
|
Map<Id, Id> parentIdByChildId = relatedDomain.getParentIdById(
|
|
domainsByRelationshipField
|
|
);
|
|
|
|
// Replace the maps value (ParentId) with the grand parent Id
|
|
return fflib_ArrayUtils.replaceValue(result, parentIdByChildId);
|
|
}
|
|
|
|
/** DEPRECATED **/
|
|
public virtual Map<Id, Id> getGrandParentIdById(
|
|
List<fflib_ISObjects2> relatedDomains
|
|
) {
|
|
System.debug(
|
|
LoggingLevel.WARN,
|
|
'The \'getGrandParentIdById(List<fflib_ISObjects2> relatedDomains)\' method is deprecated,' +
|
|
'please refactor to \'getParentIdById(Map<Schema.SObjectField, fflib_ISObjects2> relatedDomains)\''
|
|
);
|
|
|
|
fflib_ISObjects2 relatedDomain = relatedDomains.remove(0);
|
|
SObjectType relatedDomainType = relatedDomain.getSObjectType();
|
|
Map<SObjectType, SObjectField> relatedFieldByDomainType = getRelatedFieldByDomainType();
|
|
|
|
if (relatedFieldByDomainType.containsKey(relatedDomainType) == false)
|
|
throw new DeveloperException(
|
|
String.format(
|
|
'RelatedDomain type {0} not present in method getRelatedFieldByDomainType',
|
|
new List<String>{ String.valueOf(relatedDomainType) }
|
|
)
|
|
);
|
|
|
|
Map<Id, Id> result = getIdFieldByIdField(
|
|
relatedFieldByDomainType.get(relatedDomainType),
|
|
getSObjectType().getDescribe().fields.getMap().get('Id')
|
|
);
|
|
|
|
// Check if we need to resolve another parent relation, if not return the results
|
|
if (relatedDomains.isEmpty())
|
|
return result;
|
|
|
|
Map<Id, Id> grandChildIdByChildId = relatedDomain.getGrandParentIdById(
|
|
relatedDomains
|
|
);
|
|
|
|
// Replace the maps value (childId) with the grand child Id
|
|
return fflib_ArrayUtils.replaceValue(result, grandChildIdByChildId);
|
|
}
|
|
|
|
/**
|
|
* Creates a map between the record Ids of this domain to the last given child domain.
|
|
* This method is using getRelatedFieldByDomainType to determine which SObjectField
|
|
* is related to the given parent domain
|
|
*
|
|
* @param domainsByRelationshipField A Map of domains in hierarchical order from first child to grandchild
|
|
*
|
|
* @return Returns a map with KEY: The Ids of the records in this domain,
|
|
* to the VALUE: The record Ids of the lowest child related record listed in the relatedDomains,
|
|
* null if no grandchild exists.
|
|
*
|
|
* @example
|
|
* ICases casesDomain = Cases.newInstance(caseRecords);
|
|
* IContacts contactsDomain = Contacts.newInstance(contactRecords);
|
|
* IAccount accountDomain = Accounts.newInstance(accountRecords);
|
|
*
|
|
* // A map with key - Case.Id to value - Account.Id
|
|
* Map<Id, Set<Id>> caseIdsByAccountId =
|
|
* accountsDomain.getChildIdsById(
|
|
* new Map<Schema.SObjectField, fflib_SObjects2>
|
|
* {
|
|
* Schema.Contact.AccountId => contactsDomain
|
|
* Schema.Case.ContactId => casesDomain,
|
|
* });
|
|
*/
|
|
public virtual Map<Id, Set<Id>> getChildIdsById(
|
|
Map<Schema.SObjectField, fflib_SObjects2> domainsByRelationshipField
|
|
) {
|
|
// Takes the highest related domain from the domainsByRelationshipField
|
|
Schema.SObjectField relationshipField = new List<Schema.SObjectField>(
|
|
domainsByRelationshipField.keySet()
|
|
)
|
|
.get(0);
|
|
fflib_SObjects2 relatedDomain = domainsByRelationshipField.remove(
|
|
relationshipField
|
|
);
|
|
|
|
Map<Id, Set<Id>> result = relatedDomain.getIdFieldsByIdField(
|
|
relatedDomain.getSObjectType().getDescribe().fields.getMap().get('Id'),
|
|
relationshipField
|
|
);
|
|
|
|
// Check if we need to resolve another child relation, if not return the results
|
|
if (domainsByRelationshipField.isEmpty())
|
|
return result;
|
|
|
|
Map<Id, Set<Id>> childIdsById = relatedDomain.getChildIdsById(
|
|
domainsByRelationshipField
|
|
);
|
|
|
|
// Replace the maps value (childIds) with the grand child Id
|
|
return fflib_ArrayUtils.replaceValues(result, childIdsById);
|
|
}
|
|
|
|
/** DEPRECATED **/
|
|
public virtual Map<Id, Set<Id>> getChildIdsById(
|
|
List<fflib_SObjects2> relatedDomains
|
|
) {
|
|
System.debug(
|
|
LoggingLevel.WARN,
|
|
'The \'getChildIdsById(List<fflib_ISObjects2> relatedDomains)\' method is deprecated,' +
|
|
'please refactor to \'getChildIdsById(Map<Schema.SObjectField, fflib_ISObjects2> relatedDomains)\''
|
|
);
|
|
|
|
SObjectType thisDomainType = getSObjectType();
|
|
fflib_SObjects2 relatedDomain = relatedDomains.remove(0);
|
|
Map<SObjectType, SObjectField> relatedFieldByDomainType = relatedDomain.getRelatedFieldByDomainType();
|
|
|
|
if (relatedFieldByDomainType.containsKey(thisDomainType) == false)
|
|
throw new DeveloperException(
|
|
String.format(
|
|
'RelatedDomain type {0} not present in method getRelatedFieldByDomainType',
|
|
new List<String>{ String.valueOf(thisDomainType) }
|
|
)
|
|
);
|
|
|
|
SObjectField relatedLookupFieldOnChild = relatedFieldByDomainType.get(
|
|
thisDomainType
|
|
);
|
|
Map<Id, Set<Id>> result = relatedDomain.getIdFieldsByIdField(
|
|
relatedDomain.getSObjectType().getDescribe().fields.getMap().get('Id'),
|
|
relatedLookupFieldOnChild
|
|
);
|
|
|
|
// Check if we need to resolve another child relation, if not return the results
|
|
if (relatedDomains.isEmpty())
|
|
return result;
|
|
|
|
Map<Id, Set<Id>> childIdsById = relatedDomain.getChildIdsById(
|
|
relatedDomains
|
|
);
|
|
|
|
// Replace the maps value (childIds) with the grand child Id
|
|
return fflib_ArrayUtils.replaceValues(result, childIdsById);
|
|
}
|
|
|
|
/**
|
|
* @return Returns the contents of the Domain by their primary Key ('Id' field)
|
|
*/
|
|
public virtual Map<Id, SObject> getSObjectById() {
|
|
return new Map<Id, SObject>(getRecords());
|
|
}
|
|
|
|
/**
|
|
* @param ids Domain containing primary key (Id field) values
|
|
*
|
|
* @return Returns only the SObjects from the domain matching the given Ids.
|
|
*/
|
|
public virtual List<SObject> getRecords(fflib_Ids ids) {
|
|
return getRecords(ids.getIds());
|
|
}
|
|
|
|
/**
|
|
* @param ids A Set containing primary key (Id field) values
|
|
*
|
|
* @return Returns only the SObjects from the domain matching the given Ids.
|
|
*/
|
|
public virtual List<SObject> getRecords(Set<Id> ids) {
|
|
Map<Id, SObject> sObjectsByIds = getSObjectById();
|
|
List<SObject> result = new List<SObject>();
|
|
for (Id id : ids) {
|
|
if (sObjectsByIds.containsKey(id) == false)
|
|
continue;
|
|
|
|
result.add(sObjectsByIds.get(id));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @param criteria The condition the returned record must meet
|
|
*
|
|
* @return Return the SObject records contained in the domain matching the criteria
|
|
*/
|
|
public virtual List<SObject> getRecords(fflib_Criteria criteria) {
|
|
List<SObject> result = new List<SObject>();
|
|
for (SObject record : getRecords()) {
|
|
if (!criteria.evaluate(record))
|
|
continue;
|
|
|
|
result.add(record);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @return Trip the records from fields that the user doesn't have access to
|
|
*/
|
|
public virtual List<SObject> stripInaccessibleFields() {
|
|
return stripInaccessibleFields(AccessType.READABLE);
|
|
}
|
|
|
|
/**
|
|
* @param accessType
|
|
*
|
|
* @return Trip the records from fields that the user doesn't have access to
|
|
*/
|
|
public virtual List<SObject> stripInaccessibleFields(
|
|
System.AccessType accessType
|
|
) {
|
|
return Security.stripInaccessible(accessType, getRecords()).getRecords();
|
|
}
|
|
|
|
/**
|
|
* @param sObjectField The Schema.SObjectField to get their Id values
|
|
*
|
|
* @return The Date values of the given sObjectField, null values are omitted
|
|
*/
|
|
@TestVisible
|
|
protected virtual fflib_Dates getDateFieldValues(
|
|
Schema.SObjectField sObjectField
|
|
) {
|
|
Set<Date> result = new Set<Date>();
|
|
for (SObject record : getRecords()) {
|
|
Object fieldValue = record.get(sObjectField);
|
|
if (fieldValue == null)
|
|
continue;
|
|
result.add((Date) fieldValue);
|
|
}
|
|
return new fflib_Dates(result);
|
|
}
|
|
|
|
/**
|
|
* @param sObjectField The Schema.SObjectField to get their Id values
|
|
* @param criteria The criteria condition that must be met to include the value in the return
|
|
*
|
|
* @return The Date values of the given sObjectField, null values are omitted
|
|
*/
|
|
@TestVisible
|
|
protected virtual fflib_Dates getDateFieldValues(
|
|
Schema.SObjectField sObjectField,
|
|
fflib_Criteria criteria
|
|
) {
|
|
return new fflib_SObjects2(getRecords(criteria), getSObjectType())
|
|
.getDateFieldValues(sObjectField);
|
|
}
|
|
|
|
/**
|
|
* @param sObjectField The Schema.SObjectField to get their Id values
|
|
*
|
|
* @return The DateTime values of the given sObjectField, null values are omitted
|
|
*/
|
|
@TestVisible
|
|
protected virtual fflib_DateTimes getDateTimeFieldValues(
|
|
Schema.SObjectField sObjectField
|
|
) {
|
|
Set<Datetime> result = new Set<Datetime>();
|
|
for (SObject record : getRecords()) {
|
|
Object fieldValue = record.get(sObjectField);
|
|
if (fieldValue == null)
|
|
continue;
|
|
result.add((Datetime) fieldValue);
|
|
}
|
|
return new fflib_DateTimes(result);
|
|
}
|
|
|
|
/**
|
|
* @param sObjectField The Schema.SObjectField to get their Id values
|
|
* @param criteria The criteria condition that must be met to include the value in the return
|
|
*
|
|
* @return The DateTime values of the given sObjectField, null values are omitted
|
|
*/
|
|
@TestVisible
|
|
protected virtual fflib_DateTimes getDateTimeFieldValues(
|
|
Schema.SObjectField sObjectField,
|
|
fflib_Criteria criteria
|
|
) {
|
|
return new fflib_SObjects2(getRecords(criteria), getSObjectType())
|
|
.getDateTimeFieldValues(sObjectField);
|
|
}
|
|
|
|
/**
|
|
* @param decimalField The field to use as the Value of the returned Map
|
|
* @param idField The field to use as the Key of the returned map
|
|
*
|
|
* @return Returns a map with the values of two fields
|
|
*/
|
|
@TestVisible
|
|
protected virtual Map<Id, Decimal> getDecimalById(
|
|
Schema.SObjectField decimalField,
|
|
Schema.SObjectField idField
|
|
) {
|
|
Map<Id, Decimal> result = new Map<Id, Decimal>();
|
|
for (SObject record : getRecords()) {
|
|
if (record.get(idField) == null)
|
|
continue;
|
|
|
|
result.put((Id) record.get(idField), (Decimal) record.get(decimalField));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @param sObjectField The Schema.SObjectField to get the SUM of
|
|
*
|
|
* @return The total SUM of the given field
|
|
*/
|
|
@TestVisible
|
|
protected virtual Decimal getDecimalFieldSum(
|
|
Schema.SObjectField sObjectField
|
|
) {
|
|
Decimal result = 0;
|
|
for (SObject record : getRecords()) {
|
|
result += record.get(sObjectField) == null
|
|
? 0
|
|
: (Decimal) record.get(sObjectField);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @param sObjectField The Schema.SObjectField to get their Id values
|
|
*
|
|
* @return The Decimal values of the given sObjectField, null values are omitted
|
|
*/
|
|
@TestVisible
|
|
protected virtual fflib_Decimals getDecimalFieldValues(
|
|
Schema.SObjectField sObjectField
|
|
) {
|
|
Set<Decimal> result = new Set<Decimal>();
|
|
for (SObject record : getRecords()) {
|
|
Object fieldValue = record.get(sObjectField);
|
|
if (fieldValue == null)
|
|
continue;
|
|
result.add((Decimal) fieldValue);
|
|
}
|
|
return new fflib_Decimals(result);
|
|
}
|
|
|
|
/**
|
|
* @param sObjectField The Schema.SObjectField to get their Id values
|
|
* @param criteria The criteria condition that must be met to include the value in the return
|
|
*
|
|
* @return The Decimal values of the given sObjectField, null values are omitted
|
|
*/
|
|
@TestVisible
|
|
protected virtual fflib_Decimals getDecimalFieldValues(
|
|
Schema.SObjectField sObjectField,
|
|
fflib_Criteria criteria
|
|
) {
|
|
return new fflib_SObjects2(getRecords(criteria), getSObjectType())
|
|
.getDecimalFieldValues(sObjectField);
|
|
}
|
|
|
|
/**
|
|
* @param sObjectField The Schema.SObjectField to get their Id values
|
|
*
|
|
* @return The Double values of the given sObjectField, null values are omitted
|
|
*/
|
|
@TestVisible
|
|
protected virtual fflib_Doubles getDoubleFieldValues(
|
|
Schema.SObjectField sObjectField
|
|
) {
|
|
Set<Double> result = new Set<Double>();
|
|
for (SObject record : getRecords()) {
|
|
Object fieldValue = record.get(sObjectField);
|
|
if (fieldValue == null)
|
|
continue;
|
|
result.add((Double) fieldValue);
|
|
}
|
|
return new fflib_Doubles(result);
|
|
}
|
|
|
|
/**
|
|
* @param sObjectField The Schema.SObjectField to get their Id values
|
|
* @param criteria The criteria condition that must be met to include the value in the return
|
|
*
|
|
* @return The Double values of the given sObjectField, null values are omitted
|
|
*/
|
|
@TestVisible
|
|
protected virtual fflib_Doubles getDoubleFieldValues(
|
|
Schema.SObjectField sObjectField,
|
|
fflib_Criteria criteria
|
|
) {
|
|
return new fflib_SObjects2(getRecords(criteria), getSObjectType())
|
|
.getDoubleFieldValues(sObjectField);
|
|
}
|
|
|
|
/**
|
|
* Get a map with the values of two fields.
|
|
* Key fields containing null values are omitted
|
|
*
|
|
* @param valueField The field to use as the Value of the Map
|
|
* @param keyField The field to use as the Key of the map
|
|
*
|
|
* @return Returns a map with the values of two fields
|
|
*
|
|
* @example
|
|
* Accounts accounts = Accounts.newInstance(records);
|
|
* Map<Object, Object> accountNameById = accounts.getFieldByField(Account.Name, Account.Id);
|
|
*/
|
|
@TestVisible
|
|
protected virtual Map<Object, Object> getFieldByField(
|
|
Schema.SObjectField valueField,
|
|
Schema.SObjectField keyField
|
|
) {
|
|
Map<Object, Object> result = new Map<Object, Object>();
|
|
for (SObject record : getRecords()) {
|
|
if (record.get(keyField) == null)
|
|
continue;
|
|
|
|
result.put(record.get(keyField), record.get(valueField));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Get a map with the values of two fields
|
|
* Key fields containing null values are omitted
|
|
*
|
|
* @param valueField The field to use as the Value of the Map
|
|
* @param keyField The field to use as the Key of the map
|
|
*
|
|
* @return Returns a map with the values of two fields
|
|
*
|
|
* @example
|
|
* Contacts contacts = Contacts.newInstance(records);
|
|
* Map<Object, Set<Object>> contactIdByAccountId = contacts.getFieldsByField(Contact.Id, Contact.AccountId);
|
|
*/
|
|
@TestVisible
|
|
protected virtual Map<Object, Set<Object>> getFieldsByField(
|
|
Schema.SObjectField valueField,
|
|
Schema.SObjectField keyField
|
|
) {
|
|
Map<Object, Set<Object>> result = new Map<Object, Set<Object>>();
|
|
for (SObject record : getRecords()) {
|
|
Object keyFieldValue = record.get(keyField);
|
|
if (keyFieldValue == null)
|
|
continue;
|
|
|
|
if (!result.containsKey(keyFieldValue)) {
|
|
result.put(keyFieldValue, new Set<Object>());
|
|
}
|
|
result.get(keyFieldValue).add(record.get(valueField));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @return Returns only the first SObject contained in the domain.
|
|
*/
|
|
public SObject getFirstSObject() {
|
|
if (isEmpty())
|
|
return null;
|
|
|
|
return getRecords().get(0);
|
|
}
|
|
|
|
/**
|
|
* Get a map with the values of a String field as key and Id field
|
|
* Key fields containing null values are omitted
|
|
*
|
|
* @param valueField The Id field to use as the Value of the Map
|
|
* @param keyField The String field to use as the Key of the map
|
|
*
|
|
* @return Returns a map with the values of two fields
|
|
*
|
|
* @example
|
|
* Contacts contacts = Contacts.newInstance(records);
|
|
* Map<String, Id> accountIdByContactId = contacts.getIdFieldByStringField(Contact.Id, Contact.Name);
|
|
*/
|
|
@TestVisible
|
|
protected virtual Map<String, Id> getIdFieldByStringField(
|
|
Schema.SObjectField valueField,
|
|
Schema.SObjectField keyField
|
|
) {
|
|
Map<String, Id> result = new Map<String, Id>();
|
|
for (SObject record : getRecords()) {
|
|
if (record.get(keyField) == null)
|
|
continue;
|
|
|
|
result.put((String) record.get(keyField), (Id) record.get(valueField));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Get a map with the values of two Id fields
|
|
* Key fields containing null values are omitted
|
|
*
|
|
* @param valueField The Id field to use as the Value of the Map
|
|
* @param keyField The Id field to use as the Key of the map
|
|
*
|
|
* @return Returns a map with the values of two fields
|
|
*
|
|
* @example
|
|
* Contacts contacts = Contacts.newInstance(records);
|
|
* Map<Id, Id> accountIdByContactId = contacts.getIdFieldByIdField(Contact.AccountId, Contact.Id);
|
|
*/
|
|
@TestVisible
|
|
protected virtual Map<Id, Id> getIdFieldByIdField(
|
|
Schema.SObjectField valueField,
|
|
Schema.SObjectField keyField
|
|
) {
|
|
Map<Id, Id> result = new Map<Id, Id>();
|
|
for (SObject record : getRecords()) {
|
|
if (record.get(keyField) == null)
|
|
continue;
|
|
|
|
result.put((Id) record.get(keyField), (Id) record.get(valueField));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Get a map with the values of two Id fields with a one to many relation
|
|
* Key fields containing null values are omitted
|
|
*
|
|
* @param valueField The Id field to use as the Value of the Map
|
|
* @param keyField The Id field to use as the Key of the map
|
|
*
|
|
* @return Returns a map with the values of two fields
|
|
*
|
|
* @example
|
|
* Contacts contacts = Contacts.newInstance(records);
|
|
* Map<Id, Set<Id>> contactIdByAccountId = contacts.getIdFieldsByIdField(Contact.Id, Contact.AccountId);
|
|
*/
|
|
@TestVisible
|
|
protected virtual Map<Id, Set<Id>> getIdFieldsByIdField(
|
|
Schema.SObjectField valueField,
|
|
Schema.SObjectField keyField
|
|
) {
|
|
Map<Id, Set<Id>> result = new Map<Id, Set<Id>>();
|
|
for (SObject record : getRecords()) {
|
|
Id keyFieldId = (Id) record.get(keyField);
|
|
if (keyFieldId == null)
|
|
continue;
|
|
|
|
if (!result.containsKey(keyFieldId)) {
|
|
result.put(keyFieldId, new Set<Id>());
|
|
}
|
|
result.get(keyFieldId).add((Id) record.get(valueField));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Get a map with the values of an Id field by a String field with a one to many relation
|
|
* Key fields containing null values are omitted
|
|
*
|
|
* @param valueField The Id field to use as the Value of the Map
|
|
* @param keyField The String field to use as the Key of the map
|
|
*
|
|
* @return Returns a map with the values of two fields
|
|
*
|
|
* @example
|
|
* Accounts accounts = Accounts.newInstance(records);
|
|
* Map<String, Set<Id>> accountIdsByCountry = accounts.getIdFieldsByStringField(Account.BillingCountry, Account.Id);
|
|
*/
|
|
@TestVisible
|
|
protected virtual Map<String, Set<Id>> getIdFieldsByStringField(
|
|
Schema.SObjectField valueField,
|
|
Schema.SObjectField keyField
|
|
) {
|
|
Map<String, Set<Id>> result = new Map<String, Set<Id>>();
|
|
for (SObject record : getRecords()) {
|
|
String keyFieldString = String.valueOf(record.get(keyField));
|
|
if (keyFieldString == null)
|
|
continue;
|
|
|
|
if (!result.containsKey(keyFieldString)) {
|
|
result.put(keyFieldString, new Set<Id>());
|
|
}
|
|
result.get(keyFieldString).add((Id) record.get(valueField));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Gets the Id values, but with the option to omit null values
|
|
*
|
|
* @param field The Schema.SObjectField to get their Id values
|
|
* @param omitNulls If set to TRUE, null values will be removed from the result
|
|
*
|
|
* @return The Id values of the given sObjectField, null values are omitted
|
|
*/
|
|
@TestVisible
|
|
protected Set<Id> getIdFieldValues(
|
|
Schema.SObjectField field,
|
|
Boolean omitNulls
|
|
) {
|
|
Set<Id> result = getIdFieldValues(field);
|
|
|
|
if (omitNulls) {
|
|
result.remove(null);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @param sObjectField The Schema.SObjectField to get their Id values
|
|
* @param criteria The criteria condition that must be met to include the value in the return
|
|
*
|
|
* @return The Id values of the given sObjectField, null values are omitted
|
|
*/
|
|
@TestVisible
|
|
protected virtual fflib_Ids getIdFieldValues(
|
|
Schema.SObjectField sObjectField,
|
|
fflib_Criteria criteria
|
|
) {
|
|
return new fflib_Ids(
|
|
new fflib_SObjects2(getRecords(criteria), getSObjectType())
|
|
.getIdFieldValues(sObjectField)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @param sObjectField The Schema.SObjectField to get their values
|
|
*
|
|
* @return The Integer values of the given sObjectField, null values are omitted
|
|
*/
|
|
@TestVisible
|
|
protected virtual fflib_Integers getIntegerFieldValues(
|
|
Schema.SObjectField sObjectField
|
|
) {
|
|
Set<Integer> result = new Set<Integer>();
|
|
for (SObject record : getRecords()) {
|
|
Object fieldValue = record.get(sObjectField);
|
|
if (fieldValue == null)
|
|
continue;
|
|
|
|
result.add(Integer.valueOf(fieldValue));
|
|
}
|
|
return new fflib_Integers(result);
|
|
}
|
|
|
|
/**
|
|
* @param sObjectField The Schema.SObjectField to get their values
|
|
* @param criteria The criteria condition that must be met to include the value in the return
|
|
*
|
|
* @return The Integer values of the given sObjectField, null values are omitted
|
|
*/
|
|
@TestVisible
|
|
protected virtual fflib_Integers getIntegerFieldValues(
|
|
Schema.SObjectField sObjectField,
|
|
fflib_Criteria criteria
|
|
) {
|
|
return new fflib_SObjects2(getRecords(criteria), getSObjectType())
|
|
.getIntegerFieldValues(sObjectField);
|
|
}
|
|
|
|
/**
|
|
* @param sObjectField The Schema.SObjectField to get their values
|
|
*
|
|
* @return The Long values of the given sObjectField, null values are omitted
|
|
*/
|
|
@TestVisible
|
|
protected virtual fflib_Longs getLongFieldValues(
|
|
Schema.SObjectField sObjectField
|
|
) {
|
|
Set<Long> result = new Set<Long>();
|
|
for (SObject record : getRecords()) {
|
|
Object fieldValue = record.get(sObjectField);
|
|
if (fieldValue == null)
|
|
continue;
|
|
result.add((Long) fieldValue);
|
|
}
|
|
return new fflib_Longs(result);
|
|
}
|
|
|
|
/**
|
|
* @param sObjectField The Schema.SObjectField to get their values
|
|
* @param criteria The criteria condition that must be met to include the value in the return
|
|
*
|
|
* @return The Long values of the given sObjectField, null values are omitted
|
|
*/
|
|
@TestVisible
|
|
protected virtual fflib_Longs getLongFieldValues(
|
|
Schema.SObjectField sObjectField,
|
|
fflib_Criteria criteria
|
|
) {
|
|
return new fflib_SObjects2(getRecords(criteria), getSObjectType())
|
|
.getLongFieldValues(sObjectField);
|
|
}
|
|
|
|
@TestVisible
|
|
protected virtual List<SObject> getRecords(
|
|
Schema.SObjectField sObjectField,
|
|
Id idValue
|
|
) {
|
|
return getRecords(sObjectField, new Set<Id>{ idValue });
|
|
}
|
|
|
|
@TestVisible
|
|
protected virtual List<SObject> getRecords(
|
|
Schema.SObjectField sObjectField,
|
|
Set<Id> values
|
|
) {
|
|
List<SObject> result = new List<SObject>();
|
|
for (SObject record : getRecords()) {
|
|
if (values?.contains((Id) record.get(sObjectField))) {
|
|
result.add(record);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@TestVisible
|
|
protected virtual List<SObject> getRecords(
|
|
Schema.SObjectField sObjectField,
|
|
String value
|
|
) {
|
|
return getRecords(sObjectField, new Set<String>{ value });
|
|
}
|
|
|
|
@TestVisible
|
|
protected virtual List<SObject> getRecords(
|
|
Schema.SObjectField sObjectField,
|
|
Set<String> values
|
|
) {
|
|
List<SObject> result = new List<SObject>();
|
|
for (SObject record : getRecords()) {
|
|
if (values?.contains((String) record.get(sObjectField))) {
|
|
result.add(record);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@TestVisible
|
|
protected virtual List<SObject> getRecordsIsNot(
|
|
Schema.SObjectField sObjectField,
|
|
String value
|
|
) {
|
|
return getRecordsNotIn(sObjectField, new Set<String>{ value });
|
|
}
|
|
|
|
@TestVisible
|
|
protected virtual List<SObject> getRecordsNotIn(
|
|
Schema.SObjectField sObjectField,
|
|
Set<String> values
|
|
) {
|
|
List<SObject> result = new List<SObject>();
|
|
for (SObject record : getRecords()) {
|
|
if (values?.contains((String) record.get(sObjectField)))
|
|
continue;
|
|
result.add(record);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@TestVisible
|
|
protected virtual List<SObject> getRecordsIsNot(
|
|
Schema.SObjectField sObjectField,
|
|
Id idValue
|
|
) {
|
|
return getRecordsNotIn(sObjectField, new Set<Id>{ idValue });
|
|
}
|
|
|
|
@TestVisible
|
|
protected virtual List<SObject> getRecordsNotIn(
|
|
Schema.SObjectField sObjectField,
|
|
Set<Id> idValues
|
|
) {
|
|
List<SObject> result = new List<SObject>();
|
|
for (SObject record : getRecords()) {
|
|
if (idValues?.contains((Id) record.get(sObjectField)) == false) {
|
|
result.add(record);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@TestVisible
|
|
protected virtual List<SObject> getRecords(
|
|
Schema.SObjectField sObjectField,
|
|
Boolean value
|
|
) {
|
|
List<SObject> result = new List<SObject>();
|
|
for (SObject record : getRecords()) {
|
|
if ((Boolean) record.get(sObjectField) == value) {
|
|
result.add(record);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Get Parent Domain SObjectType to SObjectField.relationship field on this domain SObjectType
|
|
*
|
|
* @return Returns a map of the Parent Domain SObjectType to SObjectField.relationship field on the SObjectType
|
|
*/
|
|
protected virtual Map<SObjectType, Schema.SObjectField> getRelatedFieldByDomainType() {
|
|
return new Map<SObjectType, Schema.SObjectField>();
|
|
}
|
|
|
|
/**
|
|
* Get a map with the record mapped to the given Id field value
|
|
* Key fields containing null values are omitted
|
|
*
|
|
* @param sObjectField The field to use as key for the map
|
|
*
|
|
* @return Returns a map with the record mapped to the given Id field value
|
|
*
|
|
* @example
|
|
* Account account = Account.newInstance(records);
|
|
* Map<Id, SObject> accountById = account.getSObjectByIdField(Account.Id);
|
|
*/
|
|
@TestVisible
|
|
protected virtual Map<Id, SObject> getSObjectByIdField(
|
|
Schema.SObjectField sObjectField
|
|
) {
|
|
Map<Id, SObject> result = new Map<Id, SObject>();
|
|
for (SObject record : getRecords()) {
|
|
if (record.get(sObjectField) == null)
|
|
continue;
|
|
|
|
result.put((Id) record.get(sObjectField), record);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Get a map with the records mapped to the given Id field value
|
|
* Key fields containing null values are omitted
|
|
*
|
|
* @param sObjectField The field to use as key for the map
|
|
*
|
|
* @return Returns a map with the records mapped to the given Id field value
|
|
*
|
|
* @example
|
|
* Contacts contacts = Contacts.newInstance(records);
|
|
* Map<Id, List<SObject>> contactsByAccountId = contacts.getSObjectsByIdField(Contact.AccountId);
|
|
*/
|
|
@TestVisible
|
|
protected virtual Map<Id, List<SObject>> getSObjectsByIdField(
|
|
Schema.SObjectField sObjectField
|
|
) {
|
|
Map<Id, List<SObject>> result = new Map<Id, List<SObject>>();
|
|
for (SObject record : getRecords()) {
|
|
Id fieldId = (Id) record.get(sObjectField);
|
|
if (fieldId == null)
|
|
continue;
|
|
|
|
if (!result.containsKey(fieldId)) {
|
|
result.put(fieldId, new List<SObject>());
|
|
}
|
|
result.get(fieldId).add(record);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Get a map with the record mapped to the given String field value
|
|
* Key fields containing null values are omitted
|
|
*
|
|
* @param sObjectField The field to use as key for the map
|
|
*
|
|
* @return Returns a map with the record mapped to the given String field value
|
|
*
|
|
* @example
|
|
* Account account = Account.newInstance(records);
|
|
* Map<String, SObject> accountByNumber = account.getSObjectByStringField(Account.AccountNumber);
|
|
*/
|
|
@TestVisible
|
|
protected virtual Map<String, SObject> getSObjectByStringField(
|
|
Schema.SObjectField sObjectField
|
|
) {
|
|
Map<String, SObject> result = new Map<String, SObject>();
|
|
for (SObject record : getRecords()) {
|
|
if (record.get(sObjectField) == null)
|
|
continue;
|
|
|
|
String fieldValue = (String) record.get(sObjectField);
|
|
result.put(fieldValue, record);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Get a map with the records mapped to the given String field value
|
|
* Key fields containing null values are omitted
|
|
*
|
|
* @param sObjectField The field to use as key for the map
|
|
*
|
|
* @return Returns a map with the records mapped to the given String field value
|
|
*
|
|
* @example
|
|
* Accounts accounts = Account.newInstance(records);
|
|
* Map<String, List<SObject>> accountByName = accounts.getSObjectsByStringField(Account.AccountName);
|
|
*/
|
|
@TestVisible
|
|
protected virtual Map<String, List<SObject>> getSObjectsByStringField(
|
|
Schema.SObjectField sObjectField
|
|
) {
|
|
Map<String, List<SObject>> result = new Map<String, List<SObject>>();
|
|
for (SObject record : getRecords()) {
|
|
String fieldValue = (String) record.get(sObjectField);
|
|
if (fieldValue == null)
|
|
continue;
|
|
|
|
if (!result.containsKey(fieldValue)) {
|
|
result.put(fieldValue, new List<SObject>());
|
|
}
|
|
result.get(fieldValue).add(record);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Get a map with the given String field value mapped to the given Id field
|
|
* Key fields containing null values are omitted
|
|
*
|
|
* @param valueField The String field to use as value for the map
|
|
* @param keyField The Id field to use as key for the map
|
|
*
|
|
* @return a map with the given String field value mapped to the given Id field
|
|
*
|
|
* @example
|
|
* Account account = Account.newInstance(records);
|
|
* Map<Id, String> accountNameById = account.getStringFieldByIdField(Account.AccountName, Account.Id);
|
|
*/
|
|
@TestVisible
|
|
protected virtual Map<Id, String> getStringFieldByIdField(
|
|
Schema.SObjectField valueField,
|
|
Schema.SObjectField keyField
|
|
) {
|
|
Map<Id, String> result = new Map<Id, String>();
|
|
Map<Object, Object> fieldByField = getFieldByField(valueField, keyField);
|
|
for (Object obj : fieldByField.keySet()) {
|
|
result.put((Id) obj, (String) fieldByField.get(obj));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Get a map with the given Date field value mapped to the given Id field
|
|
* Key fields containing null values are omitted
|
|
*
|
|
* @param valueField The Date field to use as value for the map
|
|
* @param keyField The Id field to use as key for the map
|
|
*
|
|
* @return a map with the given Date field value mapped to the given Id field
|
|
*
|
|
* @example
|
|
* Account account = Account.newInstance(records);
|
|
* Map<Id, Date> createdDateById = account.getDateFieldByIdField(Account.CreatedDate, Account.Id);
|
|
*/
|
|
@TestVisible
|
|
protected virtual Map<Id, Date> getDateFieldByIdField(
|
|
Schema.SObjectField valueField,
|
|
Schema.SObjectField keyField
|
|
) {
|
|
Map<Id, Date> result = new Map<Id, Date>();
|
|
Map<Object, Object> fieldByField = getFieldByField(valueField, keyField);
|
|
for (Object obj : fieldByField.keySet()) {
|
|
Object value = fieldByField.get(obj);
|
|
Date dateValue;
|
|
if (value instanceof Date) {
|
|
dateValue = (Date) value;
|
|
} else if (value != null) {
|
|
dateValue = ((Datetime) value).date();
|
|
}
|
|
result.put((Id) obj, dateValue);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Get a map with the given Date field value mapped to the given Id field
|
|
* Key fields containing null values are omitted
|
|
*
|
|
* @param valueField The DateTime field to use as value for the map
|
|
* @param keyField The Id field to use as key for the map
|
|
*
|
|
* @return a map with the given Date field value mapped to the given Id field
|
|
*
|
|
* @example
|
|
* Account account = Account.newInstance(records);
|
|
* Map<Id, Datetime> createdDateById = account.getDateFieldByIdField(Account.CreatedDate, Account.Id);
|
|
*/
|
|
@TestVisible
|
|
protected virtual Map<Id, Datetime> getDateTimeFieldByIdField(
|
|
Schema.SObjectField valueField,
|
|
Schema.SObjectField keyField
|
|
) {
|
|
Map<Id, Datetime> result = new Map<Id, Datetime>();
|
|
Map<Object, Object> fieldByField = getFieldByField(valueField, keyField);
|
|
for (Object obj : fieldByField.keySet()) {
|
|
result.put((Id) obj, (Datetime) fieldByField.get(obj));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Get a map with the records mapped to the given String field value
|
|
* Key fields containing null values are omitted
|
|
*
|
|
* @param valueField The field to use as value for the map
|
|
* @param keyField The field to use as key for the map
|
|
*
|
|
* @return Returns a map with the record mapped to the given Id field value
|
|
*
|
|
* @example
|
|
* Account account = Account.newInstance(records);
|
|
* Map<Id, String> accountNameById = account.getStringFieldByStringField(Account.AccountName, Account.Id);
|
|
*/
|
|
@TestVisible
|
|
protected virtual Map<String, String> getStringFieldByStringField(
|
|
Schema.SObjectField valueField,
|
|
Schema.SObjectField keyField
|
|
) {
|
|
Map<String, String> result = new Map<String, String>();
|
|
Map<Object, Object> fieldByField = getFieldByField(keyField, valueField);
|
|
for (Object obj : fieldByField.keySet()) {
|
|
result.put((String) obj, (String) fieldByField.get(obj));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @param sObjectField The Schema.SObjectField to get their values
|
|
* @param criteria The criteria condition that must be met to include the value in the return
|
|
*
|
|
* @return The String values of the given sObjectField
|
|
*/
|
|
@TestVisible
|
|
protected virtual fflib_Strings getStringFieldValues(
|
|
Schema.SObjectField sObjectField,
|
|
fflib_Criteria criteria
|
|
) {
|
|
return new fflib_Strings(
|
|
new fflib_SObjects2(getRecords(criteria), getSObjectType())
|
|
.getStringFieldValues(sObjectField)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Sets the given value to the given field only when the criteria is met for the record
|
|
*
|
|
* @param sObjectField The Schema.SObjectField to change its value
|
|
* @param value The new value for the given sObjectField
|
|
* @param criteria The criteria condition that must be met to include the value in the return
|
|
*/
|
|
@TestVisible
|
|
protected virtual void setFieldValue(
|
|
Schema.SObjectField sObjectField,
|
|
Object value,
|
|
fflib_Criteria criteria
|
|
) {
|
|
new fflib_SObjects2(getRecords(criteria), getSObjectType())
|
|
.setFieldValue(sObjectField, value);
|
|
}
|
|
|
|
/**
|
|
* Sets a value to the given field only when key field Id value is provided in the given map
|
|
*
|
|
* @param sObjectIdFieldToCheck The SObject Id Field to match the key against in the provided map
|
|
* @param sObjectFieldToUpdate The SObjectField to store the mapped value when the key matches the value in the sObjectFieldToUpdate field
|
|
* @param values Map of values to store by the sObjectIdFieldToCheck fields value
|
|
*/
|
|
@TestVisible
|
|
protected virtual void setFieldValue(
|
|
Schema.SObjectField sObjectIdFieldToCheck,
|
|
Schema.SObjectField sObjectFieldToUpdate,
|
|
Map<Id, Object> values
|
|
) {
|
|
for (SObject record : getRecords()) {
|
|
Id keyValue = (Id) record.get(sObjectIdFieldToCheck);
|
|
if (values?.containsKey(keyValue)) {
|
|
record.put(sObjectFieldToUpdate, values.get(keyValue));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets a value to the given field only when key field String value is provided in the given map
|
|
*
|
|
* @param sObjectStringFieldToCheck The SObject String Field to match the key against in the provided map
|
|
* @param sObjectFieldToUpdate The SObjectField to store the mapped value when the key matches the value in the sObjectFieldToUpdate field
|
|
* @param values Map of values to store by the sObjectIdFieldToCheck fields value
|
|
*/
|
|
@TestVisible
|
|
protected virtual void setFieldValue(
|
|
Schema.SObjectField sObjectStringFieldToCheck,
|
|
Schema.SObjectField sObjectFieldToUpdate,
|
|
Map<String, Object> values
|
|
) {
|
|
for (SObject record : getRecords()) {
|
|
String keyValue = (String) record.get(sObjectStringFieldToCheck);
|
|
if (values?.containsKey(keyValue)) {
|
|
record.put(sObjectFieldToUpdate, values.get(keyValue));
|
|
}
|
|
}
|
|
}
|
|
|
|
public class DeveloperException extends Exception {
|
|
}
|
|
}
|