private static AuditOperation BuildOperation(AuditOperationEntry operationEntry)
{
AuditOperation operation = operationEntry.MapTo <AuditOperation>();
if (operationEntry.UserAgent != null)
{
UserAgent userAgent = new UserAgent(operationEntry.UserAgent);
operation.OperationSystem = userAgent.GetSystem();
operation.Browser = userAgent.GetBrowser();
}
operation.Elapsed = (int)operationEntry.EndedTime.Subtract(operationEntry.CreatedTime).TotalMilliseconds;
if (operation.ResultType == AjaxResultType.Success)
{
foreach (AuditEntityEntry entityEntry in operationEntry.EntityEntries)
{
AuditEntity entity = entityEntry.MapTo <AuditEntity>();
operation.AuditEntities.Add(entity);
foreach (AuditPropertyEntry propertyEntry in entityEntry.PropertyEntries)
{
AuditProperty property = propertyEntry.MapTo <AuditProperty>();
entity.Properties.Add(property);
}
}
}
return(operation);
}
/// <summary>
/// Gets the audit property.
/// </summary>
/// <param name="relation">The relation.</param>
/// <returns></returns>
private AuditProperty GetAuditProperty(System.Data.Entity.Core.Objects.DataClasses.IRelatedEnd relation)
{
Contract.Requires <ArgumentNullException>(relation != null, "relation");
Contract.Ensures(Contract.Result <AuditProperty>() != null);
string relationName = relation.RelationshipSet.Name;
string propertyName = string.Empty;
// check our list
AuditProperty auditProperty = this.currentAuditProperties.FirstOrDefault(ap => ap.EntityName == relationName && ap.PropertyName == propertyName && ap.IsRelation == true);
if (auditProperty == null)
{
// check the database
auditProperty = this.AuditProperties.FirstOrDefault(ap => ap.EntityName == relationName && ap.PropertyName == propertyName && ap.IsRelation == true);
if (auditProperty == null)
{
// create it
auditProperty = new AuditProperty()
{
EntityName = relationName, PropertyName = propertyName, PropertyType = string.Empty, IsRelation = true
};
}
this.currentAuditProperties.Add(auditProperty);
}
return(auditProperty);
}
/// <summary>
/// Gets the audit property.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="propertyName">Name of the property.</param>
/// <returns></returns>
private AuditProperty GetAuditProperty(IAuditable <TKey> entity, string propertyName)
{
Contract.Requires <ArgumentNullException>(entity != null, "entity");
Contract.Requires <ArgumentNullException>(!propertyName.IsNullOrWhiteSpace(), "propertyName");
//x Contract.Ensures(Contract.Result<AuditProperty>() != null);
string entityName = GetEntityTypeName(entity); // ObjectContext.GetObjectType(entity.GetType()).Name;
// check our list
AuditProperty auditProperty = this.currentAuditProperties.FirstOrDefault(ap => ap.EntityName == entityName && ap.PropertyName == propertyName);
if (auditProperty == null)
{
// check the database
auditProperty = this.AuditProperties.FirstOrDefault(ap => ap.EntityName == entityName && ap.PropertyName == propertyName);
if (auditProperty != null)
{
this.currentAuditProperties.Add(auditProperty);
}
}
// might return null
return(auditProperty);
}
///--------------------------------------------------------------------------------
/// <summary>This method is used to copy/paste a new item.</summary>
///
/// <param name="copyItem">The item to copy/paste.</param>
/// <param name="savePaste">Flag to determine whether to save the results of the paste.</param>
///--------------------------------------------------------------------------------
public AuditPropertyViewModel PasteAuditProperty(AuditPropertyViewModel copyItem, bool savePaste = true)
{
AuditProperty newItem = new AuditProperty();
newItem.ReverseInstance = new AuditProperty();
newItem.TransformDataFromObject(copyItem.AuditProperty, null, false);
newItem.PropertyID = Guid.NewGuid();
newItem.IsAutoUpdated = false;
newItem.Solution = Solution;
newItem.Solution = Solution;
AuditPropertyViewModel newView = new AuditPropertyViewModel(newItem, Solution);
newView.ResetModified(true);
AddAuditProperty(newView);
// paste children
if (savePaste == true)
{
Solution.AuditPropertyList.Add(newItem);
newView.OnUpdated(this, null);
Solution.ResetModified(true);
}
return(newView);
}
/// <summary>
/// Creates the audit delete records.
/// </summary>
private void CreateAuditDeleteRecords()
{
// audit deleted items
var entities = ((IObjectContextAdapter)this).ObjectContext.ObjectStateManager.GetObjectStateEntries(System.Data.Entity.EntityState.Deleted).Where(ose => !ose.IsRelationship);
//var entities = ChangeTracker.Entries().Where(e => e.State == EntityState.Added);
foreach (var item in entities)
{
IAuditable <TKey> entity = item.Entity as IAuditable <TKey>;
if (entity != null)
{
try
{
string oldValue;
string newValue;
var props = GetEntityType(entity).GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (var prop in props)
{
AuditProperty auditProperty = GetAuditProperty(entity, prop);
if (auditProperty != null)
{
var oldObj = ((IObjectContextAdapter)this).ObjectContext.ObjectStateManager.GetObjectStateEntry(entity).OriginalValues[prop.Name];
var newObj = prop.GetValue(entity);
oldValue = oldObj == null || oldObj == DBNull.Value ? null : oldObj.ToString();
newValue = newObj == null || newObj == DBNull.Value ? null : newObj.ToString();
if (newValue != oldValue)
{
TAuditItem auditItem = new TAuditItem()
{
Audit = this.currentAudit, AuditProperty = auditProperty, Entity1 = entity, Entity2 = null, OperationType = "D", OldValue = oldValue, NewValue = newValue
};
this.currentAuditItems.Add(auditItem);
}
}
}
}
catch (Exception ex)
{
// TODO: log the error?
System.Diagnostics.Debug.WriteLine("Error auditing a delete: " + ex.Message);
}
}
}
}
///--------------------------------------------------------------------------------
/// <summary>This property returns a copy of the forward engineering data for the solution.</summary>
///--------------------------------------------------------------------------------
public DataType GetForwardInstance(Solution forwardSolution)
{
bool isCustomized = false;
DataType forwardItem = new DataType();
if (ForwardInstance != null)
{
forwardItem.TransformDataFromObject(ForwardInstance, null, false);
isCustomized = true;
}
else
{
}
foreach (Property item in PropertyList)
{
item.DataType = this;
Property forwardChildItem = item.GetForwardInstance(forwardSolution);
if (forwardChildItem != null)
{
forwardItem.PropertyList.Add(forwardChildItem);
isCustomized = true;
}
}
foreach (AuditProperty item in AuditPropertyList)
{
item.DataType = this;
AuditProperty forwardChildItem = item.GetForwardInstance(forwardSolution);
if (forwardChildItem != null)
{
forwardItem.AuditPropertyList.Add(forwardChildItem);
isCustomized = true;
}
}
if (isCustomized == false)
{
return(null);
}
forwardItem.SpecSourceName = DefaultSourceName;
if (forwardSolution.ReferencedModelIDs.Find("ItemName", forwardItem.SpecSourceName) == null)
{
forwardSolution.ReferencedModelIDs.Add(CreateIDReference());
}
#region protected
#endregion protected
return(forwardItem);
}
/// <summary>
/// Creates the audit delete relation records.
/// </summary>
private void CreateAuditDeleteRelationRecords()
{
// audit deleted relationships
var deletedRelations = ((IObjectContextAdapter)this).ObjectContext.ObjectStateManager.GetObjectStateEntries(System.Data.Entity.EntityState.Deleted).Where(ose => ose.IsRelationship);
foreach (var item in deletedRelations)
{
try
{
ObjectStateEntry parentEntry = GetEntityEntryFromRelation(item, 0);
ObjectStateEntry childEntry;
IAuditable <TKey> parent = parentEntry.Entity as IAuditable <TKey>;
if (parent != null)
{
IAuditable <TKey> child;
// Find representation of the relation
System.Data.Entity.Core.Objects.DataClasses.IRelatedEnd relatedEnd = parentEntry.RelationshipManager.GetAllRelatedEnds().First(r => r.RelationshipSet == item.EntitySet);
childEntry = GetEntityEntryFromRelation(item, 1);
child = childEntry.Entity as IAuditable <TKey>;
if (child != null)
{
try
{
AuditProperty auditProperty = GetAuditProperty(relatedEnd);
TAuditItem auditItem = new TAuditItem()
{
Audit = this.currentAudit, AuditProperty = auditProperty, Entity1 = parent, Entity2 = child, OperationType = "-", OldValue = string.Empty, NewValue = string.Empty
};
this.currentAuditItems.Add(auditItem);
}
catch (Exception ex)
{
// TODO: log the error?
System.Diagnostics.Debug.WriteLine("Error auditing a delete relation: " + ex.Message);
}
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Error auditing remove relation: " + ex.Message);
}
}
}
private void PopulateProperties(Audit audit, EntityEntry entityEntry)
{
foreach (var property in entityEntry.CurrentValues.Properties)
{
if (property.IsConcurrencyToken)
{
continue;
}
(var newValue, var oldValue) = GetValues(property, entityEntry);
// 当前属性的新值与旧值均为空时，则不被审计
if (string.IsNullOrEmpty(newValue) && string.IsNullOrEmpty(oldValue))
{
continue;
}
var auditProperty = new AuditProperty();
auditProperty.Id = _idGeneratorFactory.GetSnowflakeIdGenerator().GenerateId();
auditProperty.PropertyName = property.Name;
auditProperty.PropertyTypeName = GetTypeName(property.ClrType);
auditProperty.NewValue = newValue;
auditProperty.OldValue = oldValue;
if (!Options.Store.MapRelationship)
{
auditProperty.AuditId = audit.Id;
}
else
{
auditProperty.Audit = audit;
}
audit.Properties.Add(auditProperty);
}
}
///--------------------------------------------------------------------------------
/// <summary>Interpret this node to produce code, output, or model data..</summary>
///
/// <param name="interpreterType">The type of interpretation to perform.</param>
/// <param name="solutionContext">The associated solution.</param>
/// <param name="templateContext">The associated template.</param>
/// <param name="modelContext">The associated model context.</param>
///--------------------------------------------------------------------------------
public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext)
{
try
{
if (CurrentItem != null)
{
if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentAuditProperty))
{
if (solutionContext.CurrentAuditProperty != null)
{
AuditProperty.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- AuditProperty: ").Append(solutionContext.CurrentAuditProperty.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentCollection))
{
if (solutionContext.CurrentCollection != null)
{
Collection.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Collection: ").Append(solutionContext.CurrentCollection.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentEntity))
{
if (solutionContext.CurrentEntity != null)
{
Entity.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Entity: ").Append(solutionContext.CurrentEntity.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentEntityReference))
{
if (solutionContext.CurrentEntityReference != null)
{
EntityReference.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- EntityReference: ").Append(solutionContext.CurrentEntityReference.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentEnumeration))
{
if (solutionContext.CurrentEnumeration != null)
{
Enumeration.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Enumeration: ").Append(solutionContext.CurrentEnumeration.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentFeature))
{
if (solutionContext.CurrentFeature != null)
{
Feature.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Feature: ").Append(solutionContext.CurrentFeature.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentIndex))
{
if (solutionContext.CurrentIndex != null)
{
Index.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Index: ").Append(solutionContext.CurrentIndex.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentIndexProperty))
{
if (solutionContext.CurrentIndexProperty != null)
{
IndexProperty.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- IndexProperty: ").Append(solutionContext.CurrentIndexProperty.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentMethod))
{
if (solutionContext.CurrentMethod != null)
{
Method.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Method: ").Append(solutionContext.CurrentMethod.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentMethodRelationship))
{
if (solutionContext.CurrentMethodRelationship != null)
{
MethodRelationship.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- MethodRelationship: ").Append(solutionContext.CurrentMethodRelationship.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentModel))
{
if (solutionContext.CurrentModel != null)
{
Model.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Model: ").Append(solutionContext.CurrentModel.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentModelObject))
{
if (solutionContext.CurrentModelObject != null)
{
ModelObject.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- ModelObject: ").Append(solutionContext.CurrentModelObject.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentModelProperty))
{
if (solutionContext.CurrentModelProperty != null)
{
ModelProperty.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- ModelProperty: ").Append(solutionContext.CurrentModelProperty.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentObjectInstance))
{
if (solutionContext.CurrentObjectInstance != null)
{
ObjectInstance.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- ObjectInstance: ").Append(solutionContext.CurrentObjectInstance.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentParameter))
{
if (solutionContext.CurrentParameter != null)
{
Parameter.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Parameter: ").Append(solutionContext.CurrentParameter.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentProject))
{
if (solutionContext.CurrentProject != null)
{
Project.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Project: ").Append(solutionContext.CurrentProject.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentProperty))
{
if (solutionContext.CurrentProperty != null)
{
Property.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Property: ").Append(solutionContext.CurrentProperty.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentPropertyInstance))
{
if (solutionContext.CurrentPropertyInstance != null)
{
PropertyInstance.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- PropertyInstance: ").Append(solutionContext.CurrentPropertyInstance.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentPropertyReference))
{
if (solutionContext.CurrentPropertyReference != null)
{
PropertyReference.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- PropertyReference: ").Append(solutionContext.CurrentPropertyReference.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentPropertyRelationship))
{
if (solutionContext.CurrentPropertyRelationship != null)
{
PropertyRelationship.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- PropertyRelationship: ").Append(solutionContext.CurrentPropertyRelationship.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentRelationship))
{
if (solutionContext.CurrentRelationship != null)
{
Relationship.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Relationship: ").Append(solutionContext.CurrentRelationship.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentRelationshipProperty))
{
if (solutionContext.CurrentRelationshipProperty != null)
{
RelationshipProperty.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- RelationshipProperty: ").Append(solutionContext.CurrentRelationshipProperty.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStage))
{
if (solutionContext.CurrentStage != null)
{
Stage.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Stage: ").Append(solutionContext.CurrentStage.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStageTransition))
{
if (solutionContext.CurrentStageTransition != null)
{
StageTransition.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- StageTransition: ").Append(solutionContext.CurrentStageTransition.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentState))
{
if (solutionContext.CurrentState != null)
{
State.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- State: ").Append(solutionContext.CurrentState.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStateModel))
{
if (solutionContext.CurrentStateModel != null)
{
StateModel.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- StateModel: ").Append(solutionContext.CurrentStateModel.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStateTransition))
{
if (solutionContext.CurrentStateTransition != null)
{
StateTransition.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- StateTransition: ").Append(solutionContext.CurrentStateTransition.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStep))
{
if (solutionContext.CurrentStep != null)
{
Step.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Step: ").Append(solutionContext.CurrentStep.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStepTransition))
{
if (solutionContext.CurrentStepTransition != null)
{
StepTransition.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- StepTransition: ").Append(solutionContext.CurrentStepTransition.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentValue))
{
if (solutionContext.CurrentValue != null)
{
Value.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Value: ").Append(solutionContext.CurrentValue.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentView))
{
if (solutionContext.CurrentView != null)
{
View.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- View: ").Append(solutionContext.CurrentView.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentViewProperty))
{
if (solutionContext.CurrentViewProperty != null)
{
ViewProperty.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- ViewProperty: ").Append(solutionContext.CurrentViewProperty.InnerXmlData);
}
}
}
else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentWorkflow))
{
if (solutionContext.CurrentWorkflow != null)
{
Workflow.DeleteCurrentItemFromSolution(solutionContext);
if (solutionContext.IsSampleMode == true)
{
templateContext.MessageBuilder.Append("\r\n- Workflow: ").Append(solutionContext.CurrentWorkflow.InnerXmlData);
}
}
}
#region protected
#endregion protected
else
{
LogException(solutionContext, templateContext, modelContext, String.Format(DisplayValues.Exception_CouldNotDeleteItem, CurrentItem.CurrentItemName), interpreterType);
}
}
}
catch (ApplicationAbortException)
{
throw;
}
catch (System.Exception ex)
{
LogException(solutionContext, templateContext, modelContext, ex, interpreterType);
}
}
///--------------------------------------------------------------------------------
/// <summary>This method gets the collection context associated with this node.</summary>
///
/// <param name="solutionContext">The associated solution.</param>
/// <param name="templateContext">The associated template.</param>
/// <param name="modelContext">The associated model context.</param>
///--------------------------------------------------------------------------------
public IEnterpriseEnumerable GetCollection(Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext)
{
IDomainEnterpriseObject nodeContext = modelContext;
if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentAuditProperty))
{
return(AuditProperty.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentCollection))
{
return(Collection.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentEntity))
{
return(Entity.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentEntityReference))
{
return(EntityReference.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentEnumeration))
{
return(Enumeration.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentFeature))
{
return(Feature.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentIndex))
{
return(Index.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentIndexProperty))
{
return(IndexProperty.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentMethod))
{
return(Method.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentMethodRelationship))
{
return(MethodRelationship.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentModel))
{
return(Model.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentModelObject))
{
return(ModelObject.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentModelProperty))
{
return(ModelProperty.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentObjectInstance))
{
return(ObjectInstance.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentParameter))
{
return(Parameter.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentProject))
{
return(Project.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentProperty))
{
return(Property.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentPropertyInstance))
{
return(PropertyInstance.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentPropertyReference))
{
return(PropertyReference.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentPropertyRelationship))
{
return(PropertyRelationship.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentRelationship))
{
return(Relationship.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentRelationshipProperty))
{
return(RelationshipProperty.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStage))
{
return(Stage.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStageTransition))
{
return(StageTransition.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentState))
{
return(State.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStateModel))
{
return(StateModel.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStateTransition))
{
return(StateTransition.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStep))
{
return(Step.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStepTransition))
{
return(StepTransition.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentValue))
{
return(Value.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentView))
{
return(View.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentViewProperty))
{
return(ViewProperty.GetCollectionContext(solutionContext, nodeContext));
}
else if (CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentWorkflow))
{
return(Workflow.GetCollectionContext(solutionContext, nodeContext));
}
#region protected
#endregion protected
else if (solutionContext.ModelObjectNames.AllKeys.Contains(CurrentItemName.Substring(7)) == true)
{
return(ObjectInstance.GetCollectionContext(solutionContext, CurrentItemName.Substring(7), nodeContext));
}
return(null);
}
///--------------------------------------------------------------------------------
/// <summary>This method gets the model context associated with this node.</summary>
///
/// <param name="solutionContext">The associated solution.</param>
/// <param name="templateContext">The associated template.</param>
/// <param name="modelContext">The associated model context.</param>
/// <param name="isValidContext">Output flag, signifying whether context returned is a valid one.</param>
///--------------------------------------------------------------------------------
public IDomainEnterpriseObject GetModelContext(Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext, out bool isValidContext)
{
IDomainEnterpriseObject nodeContext = modelContext;
IDomainEnterpriseObject currentContext = modelContext;
ModelContextNode leafModelContext = ModelContext;
isValidContext = false;
if (ThisContext != null)
{
templateContext.PopCount = templateContext.ModelContextStack.Count - 1;
}
else if (PopContext != null)
{
// go through pop context nodes directly here
ModelContextNode contextNode = this;
while (contextNode != null)
{
if (contextNode.PopContext != null)
{
leafModelContext = contextNode.ModelContext;
templateContext.PopCount++;
}
contextNode = contextNode.ModelContext;
}
}
if (templateContext.PopCount > 0)
{
// pop context executes first
nodeContext = templateContext.GetModelContext(templateContext.PopCount);
templateContext.PopCount = 0;
}
if (leafModelContext != null)
{
// model context nodes execute next (then, nodes are evaluated)
nodeContext = leafModelContext.GetModelContext(solutionContext, templateContext, nodeContext, out isValidContext);
}
if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.AuditProperty))
{
nodeContext = AuditProperty.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Collection))
{
nodeContext = Collection.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Entity))
{
nodeContext = Entity.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.EntityReference))
{
nodeContext = EntityReference.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Enumeration))
{
nodeContext = Enumeration.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Feature))
{
nodeContext = Feature.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Index))
{
nodeContext = Index.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.IndexProperty))
{
nodeContext = IndexProperty.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Method))
{
nodeContext = Method.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.MethodRelationship))
{
nodeContext = MethodRelationship.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Model))
{
nodeContext = Model.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.ModelObject))
{
nodeContext = ModelObject.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.ModelProperty))
{
nodeContext = ModelProperty.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.ObjectInstance))
{
nodeContext = ObjectInstance.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Parameter))
{
nodeContext = Parameter.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Project))
{
nodeContext = Project.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Property))
{
nodeContext = Property.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.PropertyInstance))
{
nodeContext = PropertyInstance.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.PropertyReference))
{
nodeContext = PropertyReference.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.PropertyRelationship))
{
nodeContext = PropertyRelationship.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Relationship))
{
nodeContext = Relationship.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.RelationshipProperty))
{
nodeContext = RelationshipProperty.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Solution))
{
nodeContext = Solution.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Stage))
{
nodeContext = Stage.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.StageTransition))
{
nodeContext = StageTransition.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.State))
{
nodeContext = State.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.StateModel))
{
nodeContext = StateModel.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.StateTransition))
{
nodeContext = StateTransition.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Step))
{
nodeContext = Step.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.StepTransition))
{
nodeContext = StepTransition.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Value))
{
nodeContext = Value.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.View))
{
nodeContext = View.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.ViewProperty))
{
nodeContext = ViewProperty.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Workflow))
{
nodeContext = Workflow.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlColumn))
{
nodeContext = SqlColumn.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlDatabase))
{
nodeContext = SqlDatabase.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlExtendedProperty))
{
nodeContext = SqlExtendedProperty.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlForeignKey))
{
nodeContext = SqlForeignKey.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlForeignKeyColumn))
{
nodeContext = SqlForeignKeyColumn.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlIndex))
{
nodeContext = SqlIndex.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlIndexedColumn))
{
nodeContext = SqlIndexedColumn.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlProperty))
{
nodeContext = SqlProperty.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlTable))
{
nodeContext = SqlTable.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlView))
{
nodeContext = SqlView.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlViewProperty))
{
nodeContext = SqlViewProperty.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.XmlAttribute))
{
nodeContext = XmlAttribute.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.XmlDocument))
{
nodeContext = XmlDocument.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.XmlNode))
{
nodeContext = XmlNode.GetModelContext(solutionContext, nodeContext, out isValidContext);
}
#region protected
else if (ModelContextName == "ReferencedEntity")
{
currentContext = nodeContext;
nodeContext = Collection.GetModelContext(solutionContext, currentContext, out isValidContext);
if (nodeContext is Collection)
{
nodeContext = (nodeContext as Collection).ReferencedEntity;
}
else
{
nodeContext = EntityReference.GetModelContext(solutionContext, currentContext, out isValidContext);
if (nodeContext is EntityReference)
{
nodeContext = (nodeContext as EntityReference).ReferencedEntity;
}
else
{
nodeContext = Relationship.GetModelContext(solutionContext, currentContext, out isValidContext);
if (nodeContext is Relationship)
{
nodeContext = (nodeContext as Relationship).ReferencedEntity;
}
else
{
nodeContext = Parameter.GetModelContext(solutionContext, currentContext, out isValidContext);
if (nodeContext is Parameter)
{
nodeContext = (nodeContext as Parameter).ReferencedEntity;
}
}
}
}
}
else if (ModelContextName == "ReferencedProperty")
{
currentContext = nodeContext;
nodeContext = RelationshipProperty.GetModelContext(solutionContext, currentContext, out isValidContext);
if (nodeContext is RelationshipProperty)
{
nodeContext = (nodeContext as RelationshipProperty).ReferencedProperty;
}
else
{
nodeContext = PropertyReference.GetModelContext(solutionContext, currentContext, out isValidContext);
if (nodeContext is PropertyReference)
{
nodeContext = (nodeContext as PropertyReference).ReferencedProperty;
}
else
{
nodeContext = Parameter.GetModelContext(solutionContext, currentContext, out isValidContext);
if (nodeContext is Parameter)
{
nodeContext = (nodeContext as Parameter).ReferencedPropertyBase as Property;
}
}
}
}
else if (ModelContextName == "BaseEntity")
{
nodeContext = Entity.GetModelContext(solutionContext, nodeContext, out isValidContext);
if (nodeContext is Entity)
{
nodeContext = (nodeContext as Entity).BaseEntity;
}
}
else if (solutionContext.ModelObjectPropertyNames[ModelContextName] != null)
{
nodeContext = ObjectInstance.GetModelContextViaProperty(solutionContext, ModelContextName, nodeContext, out isValidContext);
}
#endregion protected
else if (solutionContext.ModelObjectNames.AllKeys.Contains(ModelContextName) == true)
{
return(ObjectInstance.GetModelContext(solutionContext, ModelContextName, nodeContext, out isValidContext));
}
if (nodeContext == null && isValidContext == false)
{
LogException(solutionContext, templateContext, modelContext, String.Format(DisplayValues.Exception_InvalidModelContext, ModelContextName, modelContext.Name, modelContext.GetType().Name), InterpreterTypeCode.None);
}
return(nodeContext);
}
///--------------------------------------------------------------------------------
/// <summary>This method gets the collection context associated with this node.</summary>
///
/// <param name="solutionContext">The associated solution.</param>
/// <param name="templateContext">The associated template.</param>
/// <param name="modelContext">The associated model context.</param>
///--------------------------------------------------------------------------------
public IEnterpriseEnumerable GetCollection(Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext)
{
IDomainEnterpriseObject nodeContext = modelContext;
bool isValidContext;
if (ModelContext != null)
{
nodeContext = ModelContext.GetModelContext(solutionContext, templateContext, modelContext, out isValidContext);
}
if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.AuditProperty))
{
return(AuditProperty.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Collection))
{
return(Collection.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Entity))
{
return(Entity.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.EntityReference))
{
return(EntityReference.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Enumeration))
{
return(Enumeration.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Feature))
{
return(Feature.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Index))
{
return(Index.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.IndexProperty))
{
return(IndexProperty.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Method))
{
return(Method.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.MethodRelationship))
{
return(MethodRelationship.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Model))
{
return(Model.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.ModelObject))
{
return(ModelObject.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.ModelProperty))
{
return(ModelProperty.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.ObjectInstance))
{
return(ObjectInstance.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Parameter))
{
return(Parameter.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Project))
{
return(Project.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Property))
{
return(Property.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.PropertyInstance))
{
return(PropertyInstance.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.PropertyReference))
{
return(PropertyReference.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.PropertyRelationship))
{
return(PropertyRelationship.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Relationship))
{
return(Relationship.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.RelationshipProperty))
{
return(RelationshipProperty.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Solution))
{
return(Solution.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Stage))
{
return(Stage.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.StageTransition))
{
return(StageTransition.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.State))
{
return(State.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.StateModel))
{
return(StateModel.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.StateTransition))
{
return(StateTransition.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Step))
{
return(Step.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.StepTransition))
{
return(StepTransition.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Value))
{
return(Value.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.View))
{
return(View.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.ViewProperty))
{
return(ViewProperty.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Workflow))
{
return(Workflow.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlColumn))
{
return(SqlColumn.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlDatabase))
{
return(SqlDatabase.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlExtendedProperty))
{
return(SqlExtendedProperty.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlForeignKey))
{
return(SqlForeignKey.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlForeignKeyColumn))
{
return(SqlForeignKeyColumn.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlIndex))
{
return(SqlIndex.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlIndexedColumn))
{
return(SqlIndexedColumn.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlProperty))
{
return(SqlProperty.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlTable))
{
return(SqlTable.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlView))
{
return(SqlView.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.SqlViewProperty))
{
return(SqlViewProperty.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.XmlAttribute))
{
return(XmlAttribute.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.XmlDocument))
{
return(XmlDocument.GetCollectionContext(solutionContext, nodeContext));
}
else if (ModelContextName == Enum.GetName(typeof(SpecModelContextTypeCode), SpecModelContextTypeCode.XmlNode))
{
return(XmlNode.GetCollectionContext(solutionContext, nodeContext));
}
#region protected
else if (ModelContextName == Enum.GetName(typeof(ModelContextTypeCode), ModelContextTypeCode.Tag))
{
return(Tag.GetCollectionContext(solutionContext, modelContext));
}
#endregion protected
else if (solutionContext.ModelObjectNames.AllKeys.Contains(ModelContextName) == true)
{
return(ObjectInstance.GetCollectionContext(solutionContext, ModelContextName, nodeContext));
}
LogException(solutionContext, templateContext, modelContext, String.Format(DisplayValues.Exception_InvalidModelContext, ModelContextName, modelContext.GetType().Name), InterpreterTypeCode.None);
return(null);
}
/// <summary>
/// Gets the audit property.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="prop">The property.</param>
/// <returns></returns>
private AuditProperty GetAuditProperty(IAuditable <TKey> entity, PropertyInfo prop)
{
Contract.Requires <ArgumentNullException>(entity != null, "entity");
Contract.Requires <ArgumentNullException>(prop != null, "prop");
//x Contract.Ensures(Contract.Result<AuditProperty>() != null);
string entityName = GetEntityTypeName(entity); // ObjectContext.GetObjectType(entity.GetType()).Name;
string propertyName = prop.Name;
// only value types are audited (include strings in this...)
if (!prop.PropertyType.IsValueType && prop.PropertyType != typeof(string))
{
return(null);
}
// do not log collections
if (prop.PropertyType is IEnumerable)
{
return(null);
}
// ignore properties with the ignore attribute
if (prop.GetCustomAttributes(typeof(AuditIgnoreAttribute), true).FirstOrDefault() != null)
{
return(null);
}
// ignore properties with the not tracked attribute
if (prop.GetCustomAttributes(typeof(NotMappedAttribute), true).FirstOrDefault() != null)
{
return(null);
}
// fix up the property type (not sure everyone will like this...
string propertyType = prop.PropertyType.ToString();
bool nullable = false;
if (propertyType.StartsWith("System.Nullable"))
{
nullable = true;
propertyType = propertyType.Substring(propertyType.IndexOf("[") + 1).TrimEnd(']');
}
if (propertyType.StartsWith("System."))
{
propertyType = propertyType.Substring(7);
}
if (propertyType == "String")
{
propertyType = "string";
}
if (propertyType == "Int32")
{
propertyType = "int";
}
if (propertyType == "Int64")
{
propertyType = "long";
}
if (propertyType == "Int16")
{
propertyType = "short";
}
if (propertyType == "Boolean")
{
propertyType = "bool";
}
if (propertyType == "Byte")
{
propertyType = "byte";
}
if (propertyType == "Single")
{
propertyType = "float";
}
if (propertyType == "Double")
{
propertyType = "double";
}
if (propertyType == "Decimal")
{
propertyType = "decimal";
}
if (propertyType == "Char")
{
propertyType = "char";
}
if (propertyType == "Sbyte")
{
propertyType = "sbyte";
}
if (nullable)
{
propertyType += "?";
}
// check our list
AuditProperty auditProperty = this.currentAuditProperties.FirstOrDefault(ap => ap.EntityName == entityName && ap.PropertyName == propertyName && ap.IsRelation == false);
if (auditProperty == null)
{
// check the database
auditProperty = this.AuditProperties.FirstOrDefault(ap => ap.EntityName == entityName && ap.PropertyName == propertyName && ap.IsRelation == false);
if (auditProperty == null)
{
// create it
auditProperty = new AuditProperty()
{
EntityName = entityName, PropertyName = propertyName, PropertyType = propertyType.ToString(), IsRelation = false
};
}
this.currentAuditProperties.Add(auditProperty);
}
return(auditProperty);
}
