/// <summary>
/// Gets the mapping class associations by class association name
/// </summary>
/// <returns></returns>
public static MappingClassAssociation GetMappingClassAssociationByTypes(
Type sourceMappingType,
Type destinationMappingType)
{
MappingClassAssociation mappingClassAssociation = null;
try
{
// Get the mapping class associations
mappingClassAssociation =
CBO <MappingClassAssociation> .FillObject(
DataAccessProvider.Instance().GetMappingClassAssociationByTypes(
sourceMappingType.FullName,
destinationMappingType.FullName));
}
catch (Exception ex)
{
if (
Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.ExceptionPolicy.HandleException(ex,
"Business Logic"))
{
throw;
}
}
// Done
return(mappingClassAssociation);
}
/// <summary>
/// Saves the mapping class association.
/// </summary>
/// <param name="association">The association.</param>
/// <returns></returns>
public static int SaveMappingClassAssociation(MappingClassAssociation association)
{
try
{
if (association.IsValid)
{
association.Id = DataAccessProvider.Instance().SaveMappingClassAssociation(association);
}
else
{
// Entity is not valid
throw new InValidBusinessObjectException(association);
}
}
catch (Exception ex)
{
if (
Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.ExceptionPolicy.HandleException(ex,
"Business Logic"))
{
throw;
}
}
// Done
return(association.Id);
}
private MappingClassAssociation PopulateNewMappingClassAssocation()
{
MappingClassAssociation mappingClassAssociation = new MappingClassAssociation();
mappingClassAssociation.SourceType = "OpCoShipment";
mappingClassAssociation.DestinationType = "TDCShipment";
mappingClassAssociation.SourceTypeFullName = "Discovery.BusinessObjects.OpCoShipment";
mappingClassAssociation.DestinationTypeFullName = "Discovery.BusinessObjects.TDCShipment";
return(mappingClassAssociation);
}
public void SaveDestinationMappingClassAssociationConstraint()
{
using (TransactionScope scope = new TransactionScope())
{
MappingController.DeleteAllMappings();
MappingController.DeleteAllMappingSystems();
MappingController.DeleteAllMappingPropertyAssociations();
MappingController.DeleteAllMappingClassAssociations();
MappingClassAssociation classAssociation = PopulateNewMappingClassAssocation();
MappingController.SaveMappingClassAssociation(classAssociation);
MappingController.SaveMappingClassAssociation(classAssociation);
}
}
/// <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.");
}
}
