private static void Remove(PersistableBusinessObject value, object key)
{
if (cache != null)
{
//remove the fully populated
cache.Remove(string.Concat(key.ToString(), "|", value.GetType().ToString(), "|", true.ToString()));
//remove the partially populated
cache.Remove(string.Concat(key.ToString(), "|", value.GetType().ToString(), "|", false.ToString()));
}
}
public static void Add(PersistableBusinessObject value, object key, bool fullyPopulated)
{
if (cache != null)
{
cache.Add(string.Concat(key.ToString(), "|", value.GetType().ToString(), "|", fullyPopulated.ToString()), value);
}
}
public static void Add(PersistableBusinessObject objectToAdd, bool fullyPopulated)
{
//add the object to the cache using the Id as part of the key
Add(objectToAdd, (object)objectToAdd.Id, true);
//add the object to the cache using the Code as part of the key if there is one
PropertyInfo propertyInfo = objectToAdd.GetType().GetProperty("Code");
if (propertyInfo != null)
{
Add(objectToAdd, (object)propertyInfo.GetValue(objectToAdd, null), true);
}
}
public static void Remove(PersistableBusinessObject objectToRemove)
{
//remove using the id as the key
Remove(objectToRemove, (object)objectToRemove.Id);
//remove using the code as the key
PropertyInfo propertyInfo = objectToRemove.GetType().GetProperty("Code");
if (propertyInfo != null)
{
Remove(objectToRemove, (object)propertyInfo.GetValue(objectToRemove, null));
}
}
public static bool Contains(PersistableBusinessObject value, bool fullyPopulated)
{
bool contains = false;
if (cache != null)
{
contains = cache.Contains(string.Concat(value.Id.ToString(), "|", value.GetType().ToString(), "|", fullyPopulated.ToString()));
}
if (!contains && !fullyPopulated)
{
//we were after a non fully populated object, and there wasn't one lets see if there is a fully populated object
if (cache != null)
{
contains = cache.Contains(string.Concat(value.Id.ToString(), "|", value.GetType().ToString(), "|", true.ToString()));
}
}
return(contains);
}
/// <summary>
/// Gets the checksum.
/// </summary>
/// <param name="entity">The entity.</param>
public static void GetChecksum(PersistableBusinessObject entity)
{
GetChecksum(entity, entity.GetType().Name.Replace(entity.GetType().Namespace, ""));
}
/// <summary>
/// A method 'Map' defined in 'Mapper' class with 6 arguments passing in
/// </summary>
/// <param name="sourceObject">The source object.</param>
/// <param name="destinationObject">The destination object.</param>
/// <param name="sourceSystem">The source system.</param>
/// <param name="destinationSystem">The destination system.</param>
/// <param name="advancedMappingMethod">The advanced mapping method.</param>
/// <param name="propertiesToIgnore">The properties to ignore.</param>
public static void Map(
PersistableBusinessObject sourceObject,
PersistableBusinessObject destinationObject,
string sourceSystem,
string destinationSystem,
AdvancedMapping advancedMappingMethod,
string[] propertiesToIgnore)
{
if (destinationObject != null)
{
Type sourceObjectType = sourceObject.GetType();
Type destinationObjectType = destinationObject.GetType();
// Source property value
object sourcePropertyValue = null;
// Source property info
PropertyInfo sourcePropertyInfo = null;
// Get a mapping class association if we have one
MappingClassAssociation mappingClassAssociation = MappingController.GetMappingClassAssociationByTypes(
sourceObjectType,
destinationObjectType);
// Get the properties for the above class association
List <MappingPropertyAssociation> mappingPropertyAssociations = null;
// If we have a mapping association see if there are any properties
if (null != mappingClassAssociation)
{
mappingPropertyAssociations = MappingController.GetMappingPropertyAssociationsByClassAssociationId(
mappingClassAssociation.Id);
}
// Loop through the properties of the destination object
foreach (PropertyInfo destinationPropertyInfo in destinationObjectType.GetProperties())
{
// Only continue if we can write the destination property
if (destinationPropertyInfo.CanWrite)
{
// See if we have properties to ignore
if (null != propertiesToIgnore)
{
// See if we can find the property
if (null != Array.Find <string>(propertiesToIgnore,
delegate(string propertyToIgnore)
{
// Do we ignore this property
return(destinationPropertyInfo.Name == propertyToIgnore);
}))
{
// Ignore this property
continue;
}
}
// The mapping if one exists
BusinessObjects.Mapping valueMapping = null;
// The property association we've found, if any
MappingPropertyAssociation mappingPropertyAssociation = null;
// Is it a mappable property?
bool mappable = (mappingPropertyAssociations != null &&
null != (mappingPropertyAssociation = mappingPropertyAssociations.Find(
delegate(MappingPropertyAssociation propertyAssociation)
{
return(propertyAssociation.DestinationProperty == destinationPropertyInfo.Name);
})));
// If we're mappable, we need to see if the source object has a value that we can use for the lookup
if (mappable)
{
// Get the source property with the same name as the mapping source property
sourcePropertyInfo = sourceObjectType.GetProperty(mappingPropertyAssociation.SourceProperty);
//if the destination object has a writeable property with the same name, and their types are the same then set to cloned value
if (sourcePropertyInfo != null &&
sourcePropertyInfo.PropertyType.Equals(destinationPropertyInfo.PropertyType) &&
sourcePropertyInfo.CanRead)
{
// Get the source value
sourcePropertyValue = sourcePropertyInfo.GetValue(sourceObject, null);
}
else
{
mappable = false;
}
}
// See if this property is mappable and mapped
if (mappable && null != (valueMapping = MappingController.GetMapping(
sourceObjectType,
destinationObjectType,
sourceSystem,
destinationSystem,
mappingPropertyAssociation.SourceProperty,
mappingPropertyAssociation.DestinationProperty,
sourcePropertyValue.ToString())))
{
// Set the destination properties value to the mapped value
destinationPropertyInfo.SetValue(destinationObject, valueMapping.DestinationValue, null);
}
else
{
// Get the source property with the same name as the current destination property
sourcePropertyInfo = sourceObjectType.GetProperty(destinationPropertyInfo.Name);
//if the destination object has a writeable property with the same name, and their types are the same then set to cloned value
if (sourcePropertyInfo != null &&
sourcePropertyInfo.PropertyType.Equals(destinationPropertyInfo.PropertyType) &&
sourcePropertyInfo.CanRead)
{
// Get the value of the source property
sourcePropertyValue = sourcePropertyInfo.GetValue(sourceObject, null);
// Set the destination properties value to a clone of the source value
destinationPropertyInfo.SetValue(destinationObject, DeepClone(sourcePropertyValue), null);
}
else
{
// Set the destination properties value to null
//destinationPropertyInfo.SetValue(destinationObject, Discovery.Utility.Null.SetNull(destinationPropertyInfo), null);
}
}
}
}
//call a delegate to perform futher specific mapping
if (advancedMappingMethod != null)
{
advancedMappingMethod(sourceObject, destinationObject, sourceSystem, destinationSystem);
}
}
else
{
throw new MappingException("The Destination object is null.");
}
}