//Generate the Terms collection (of Term) based on an xml document
public static bool Save(XmlDocument xmlTemplateDoc, Template template, bool bValidate)
{
//Convert the xml into an xmldocument
//XmlDocument xmlTemplateDoc = new XmlDocument();
//xmlTemplateDoc.PreserveWhitespace = false;
//xmlTemplateDoc.LoadXml(template.TemplateDef);
//Convert the objects stored in memory to an xmldocument
XmlDocument xmlDoc = new XmlDocument();
XmlElement nodeDetailedDescriptions = xmlDoc.CreateElement(XMLNames._E_DetailedDescriptions);
if (template.DetailedDescriptions != null)
foreach (DetailedDescription detailedDescription in template.DetailedDescriptions)
{
XmlElement nodeDetailedDescription = xmlDoc.CreateElement(XMLNames._E_DetailedDescription);
detailedDescription.Build(xmlDoc, nodeDetailedDescription, bValidate);
nodeDetailedDescriptions.AppendChild(nodeDetailedDescription);
}
//Replace the impacted portion of the complete xml with this version from memory
XmlNode importedNodeDetailedDescriptions = xmlTemplateDoc.ImportNode(nodeDetailedDescriptions, true);
//Find the "DetailedDescriptions" child node
XmlNode detailedDescriptionChildNode = xmlTemplateDoc.SelectSingleNode(Utility.XMLHelper.GetXPath(true, XMLNames._E_TemplateDef, XMLNames._E_DetailedDescriptions));
if (detailedDescriptionChildNode != null)
xmlTemplateDoc.DocumentElement.ReplaceChild(importedNodeDetailedDescriptions, detailedDescriptionChildNode);
else
xmlTemplateDoc.DocumentElement.AppendChild(importedNodeDetailedDescriptions);
return true;
}
public static List<ITATDocument> Create(XmlDocument xmlTemplateDoc, Template template)
{
XmlNodeList nodeDocuments = null;
bool isNewDocStructure = isNewStructure(xmlTemplateDoc);
if (isNewDocStructure)
{
nodeDocuments = xmlTemplateDoc.SelectNodes(Utility.XMLHelper.GetXPath(true, XMLNames._E_TemplateDef, XMLNames._E_Documents, XMLNames._E_Document));
}
else
{
nodeDocuments = xmlTemplateDoc.SelectNodes(Utility.XMLHelper.GetXPath(true, XMLNames._E_TemplateDef, XMLNames._E_Document));
}
if (nodeDocuments == null)
{
return new List<ITATDocument>();
}
List<ITATDocument> rtn = new List<ITATDocument>(nodeDocuments.Count);
foreach (XmlNode nodeDocument in nodeDocuments)
{
ITATDocument document = new ITATDocument(xmlTemplateDoc, nodeDocument, template, isNewDocStructure);
rtn.Add(document);
}
return rtn;
}
public static bool Save(Template template, ref string sXml, bool bValidate)
{
//Convert the xml into an xmldocument
XmlDocument xmlTemplateDoc = new XmlDocument();
xmlTemplateDoc.PreserveWhitespace = false;
xmlTemplateDoc.LoadXml(sXml);
//Convert the objects stored in memory to an xmldocument
XmlDocument xmlDoc = new XmlDocument();
XmlElement rootComplexList = xmlDoc.CreateElement(XMLNames._E_ComplexLists);
if (template.ComplexLists != null)
foreach (ComplexList complexList in template.ComplexLists)
{
XmlElement elementComplexList = xmlDoc.CreateElement(XMLNames._E_ComplexList);
complexList.Build(xmlDoc, elementComplexList, bValidate);
rootComplexList.AppendChild(elementComplexList);
}
//Replace the impacted portion of the complete xml with this version from memory
XmlNode importedRootComplexList = xmlTemplateDoc.ImportNode(rootComplexList, true);
//Find the "Terms" child node
XmlNode complexListsChildNode = xmlTemplateDoc.SelectSingleNode(Utility.XMLHelper.GetXPath(true, XMLNames._E_TemplateDef,XMLNames._E_ComplexLists));
if (complexListsChildNode != null)
xmlTemplateDoc.DocumentElement.ReplaceChild(importedRootComplexList, complexListsChildNode);
else
xmlTemplateDoc.DocumentElement.AppendChild(importedRootComplexList);
//Store the entire xml back to the database
sXml = xmlTemplateDoc.OuterXml;
return true;
}
public static Term CreateTerm(TermType termType, bool systemTerm, bool IsManagedItem, Template template, bool isFilter)
{
switch (termType)
{
case TermType.Text:
return new TextTerm(systemTerm, template, isFilter);
case TermType.Date:
return new DateTerm(systemTerm, template, isFilter);
case TermType.Link:
return new LinkTerm(systemTerm, template, isFilter);
case TermType.MSO:
return new MSOTerm(systemTerm, template, isFilter);
case TermType.Renewal:
return new RenewalTerm(systemTerm, IsManagedItem, template, isFilter);
case TermType.Facility:
return new FacilityTerm(systemTerm, template, isFilter);
case TermType.PickList:
return new PickListTerm(systemTerm, template, isFilter);
case TermType.ComplexList:
return new ComplexList(systemTerm, template, false, isFilter);
case TermType.External:
throw new Exception("The CreateTerm method is not to be used when creating an external term.");
case TermType.PlaceHolderAttachments:
throw new Exception("The CreateTerm method is not to be used when creating a PlaceHolderAttachments term.");
case TermType.PlaceHolderComments:
throw new Exception("The CreateTerm method is not to be used when creating a PlaceHolderComments term.");
default:
throw new Exception(string.Format("Edit screen not implemented for TermType = {0}", termType));
}
}
public static bool Save(Template template, ref string sXml, bool bValidate)
{
//Convert the xml into an xmldocument
XmlDocument xmlTemplateDoc = new XmlDocument();
xmlTemplateDoc.PreserveWhitespace = false;
xmlTemplateDoc.LoadXml(sXml);
//Convert the objects stored in memory to an xmldocument
XmlDocument xmlDoc = new XmlDocument();
XmlElement nodeUserDocumentPrinters = xmlDoc.CreateElement(XMLNames._E_UserDocumentPrinters);
if (template.UserDocumentPrinters != null)
foreach (Role userDocumentPrinter in template.UserDocumentPrinters)
{
XmlElement nodeUserDocumentPrinter = xmlDoc.CreateElement(XMLNames._E_Role);
userDocumentPrinter.Build(xmlDoc, nodeUserDocumentPrinter, bValidate);
nodeUserDocumentPrinters.AppendChild(nodeUserDocumentPrinter);
}
//Replace the impacted portion of the complete xml with this version from memory
XmlNode importedNodeUserDocumentPrinters = xmlTemplateDoc.ImportNode(nodeUserDocumentPrinters, true);
//Find the "Comments" child node
XmlNode userDocumentPrinterChildNode = xmlTemplateDoc.SelectSingleNode(Utility.XMLHelper.GetXPath(true, XMLNames._E_TemplateDef, XMLNames._E_UserDocumentPrinters));
if (userDocumentPrinterChildNode != null)
xmlTemplateDoc.DocumentElement.ReplaceChild(importedNodeUserDocumentPrinters, userDocumentPrinterChildNode);
else
xmlTemplateDoc.DocumentElement.AppendChild(importedNodeUserDocumentPrinters);
//Store the entire xml back to the database
sXml = xmlTemplateDoc.OuterXml;
return true;
}
public TermDependencyCondition(Template template, string sourceTerm, string oper, string value1, string value2)
{
_template = template;
_sourceTermID = _template.FindTerm(sourceTerm).ID;
_oper = oper;
_value1 = value1;
_value2 = value2;
}
public DateTerm(XmlNode termNode, Template template, bool isFilter)
: base(termNode, template, isFilter)
{
TermType = TermType.Date;
NameRequired = true;
_value = Utility.XMLHelper.GetValueDate(termNode);
_format = Utility.XMLHelper.GetAttributeString(termNode, XMLNames._A_Format);
}
//Generate the Comments collection (of N) based on an existing Template
public static List<Role> Create(string templateDef, Template template)
{
if (templateDef == null)
return null;
XmlDocument xmlTemplateDoc = new XmlDocument();
xmlTemplateDoc.PreserveWhitespace = false;
xmlTemplateDoc.LoadXml(templateDef);
return Create(xmlTemplateDoc, template);
}
//Generate the Terms collection (of Term) based on an existing Template
//2090429 - This will be called with a param for the XPath, depending...
//This is called from ManagedItem.Create and from BasicTerms prop-get
public static List<Term> Create(string templateDef, ManagedItem managedItem, Template template)
{
if (templateDef == null)
return null;
//Convert the xml into an xmldocument
XmlDocument xmlTemplateDoc = new XmlDocument();
xmlTemplateDoc.PreserveWhitespace = false;
xmlTemplateDoc.LoadXml(templateDef);
return Create(xmlTemplateDoc.SelectSingleNode(Utility.XMLHelper.GetXPath(true, XMLNames._E_TemplateDef, XMLNames._E_Terms)), managedItem, template);
}
public static Guid Copy(Template template, Guid copyFromID, string newName)
{
Workflow workflowFrom = template.FindWorkflow(copyFromID);
if (workflowFrom == null)
return Guid.Empty;
Workflow workflowCopy = workflowFrom.Copy(newName, template is ManagedItem, template);
workflowCopy.Name = newName;
template.Workflows.Add(workflowCopy);
return workflowCopy.ID;
}
public LinkTerm(XmlNode termNode, Template template, bool isFilter)
: base(termNode, template, isFilter)
{
TermType = TermType.Link;
NameRequired = true;
_url = Utility.XMLHelper.GetAttributeString(termNode, XMLNames._A_URL);
_caption = Utility.XMLHelper.GetAttributeString(termNode, XMLNames._A_Caption);
_isManagedItemReference = Utility.XMLHelper.GetAttributeBool(termNode, XMLNames._A_IsManagedItemReference);
_complexListID = Term.CreateID(termNode, XMLNames._A_ComplexListID);
_linkSource = Utility.XMLHelper.GetAttributeString(termNode, XMLNames._A_LinkSource);
}
//Generate the Terms collection (of Term) based on an existing Template
public static List<Workflow> Create(XmlDocument xmlTemplateDoc, Template template)
{
XmlNodeList nodeWorkflows = null;
XmlNode nodeWorkflow = null;
List<Workflow> rtn = new List<Workflow>();
nodeWorkflows = xmlTemplateDoc.SelectNodes(Utility.XMLHelper.GetXPath(true, XMLNames._E_TemplateDef, XMLNames._E_Workflows, XMLNames._E_Workflow));
if (nodeWorkflows.Count == 0)
{
nodeWorkflow = xmlTemplateDoc.SelectSingleNode(Utility.XMLHelper.GetXPath(true, XMLNames._E_TemplateDef, XMLNames._E_Workflow));
if (nodeWorkflow == null)
{
//No Workflow defined
throw new Exception(string.Format("No workflow defined for older structure template '{0}', ID = '{1}'", template.Name, template.ID.ToString()));
}
else
{
//This is the 'old' structure
Workflow workflow = new Workflow(nodeWorkflow, template is ManagedItem, template);
template.ActiveWorkflowID = workflow.ID;
Event revertToDraft = template.OldWorkflowRevertEvent;
if (revertToDraft != null)
{
workflow.Events.Add(revertToDraft);
template.OldWorkflowRevertEvent = null;
}
rtn.Add(workflow);
}
}
else
{
//This is the 'new' structure - assume that RevertToDraft already set up properly.
XmlNode singleNodeWorkflows = xmlTemplateDoc.SelectSingleNode(Utility.XMLHelper.GetXPath(true, XMLNames._E_TemplateDef, XMLNames._E_Workflows));
foreach (XmlNode nodeEachWorkflow in nodeWorkflows)
{
rtn.Add(new Workflow(nodeEachWorkflow, template is ManagedItem, template));
}
string sActiveWorkflowID = string.Empty;
//if (sActiveWorkflowID == null)
// throw new Exception("The Active Workflow ID is not defined");
sActiveWorkflowID = Utility.XMLHelper.GetAttributeString(singleNodeWorkflows, XMLNames._A_ActiveWorkflowID);
if (Utility.TextHelper.IsGuid(sActiveWorkflowID))
template.ActiveWorkflowID = new Guid(sActiveWorkflowID);
else
if (rtn.Count > 0)
template.ActiveWorkflowID = rtn[0].ID;
else
throw new Exception("Unable to set the Active Workflow because no workflows are defined for this template.");
}
return rtn;
}
public static bool Save(XmlDocument xmlTemplateDoc, Template template, bool bValidate)
{
//Convert the xml into an xmldocument
bool bWriteToDatabase = false;
if (xmlTemplateDoc == null)
{
xmlTemplateDoc = new XmlDocument();
xmlTemplateDoc.PreserveWhitespace = false;
xmlTemplateDoc.LoadXml(template.TemplateDef);
bWriteToDatabase = true;
}
//Convert the objects stored in memory to an xmldocument
XmlDocument xmlDoc = new XmlDocument();
XmlElement rootITATDocuments = xmlDoc.CreateElement(XMLNames._E_Documents);
if (template.Documents != null)
foreach (ITATDocument document in template.Documents)
{
XmlElement elementDocument = xmlDoc.CreateElement(XMLNames._E_Document);
document.Build(xmlTemplateDoc, xmlDoc, elementDocument, bValidate);
rootITATDocuments.AppendChild(elementDocument);
}
//Replace the impacted portion of the complete xml with this version from memory
XmlNode importedRootITATDocument = xmlTemplateDoc.ImportNode(rootITATDocuments, true);
//Find the "Terms" child node
XmlNode documentsChildNode = xmlTemplateDoc.SelectSingleNode(Utility.XMLHelper.GetXPath(true, XMLNames._E_TemplateDef, XMLNames._E_Documents));
XmlNode documentChildNode = xmlTemplateDoc.SelectSingleNode(Utility.XMLHelper.GetXPath(true, XMLNames._E_TemplateDef, XMLNames._E_Document));
if (documentChildNode!=null)
{
xmlTemplateDoc.DocumentElement.RemoveChild(documentChildNode);
xmlTemplateDoc.DocumentElement.AppendChild(importedRootITATDocument);
}
else if (documentsChildNode != null)
xmlTemplateDoc.DocumentElement.ReplaceChild(importedRootITATDocument, documentsChildNode);
else
xmlTemplateDoc.DocumentElement.AppendChild(importedRootITATDocument);
//Store the entire xml back to the database
if (bWriteToDatabase)
Template.UpdateTemplateDef(template, xmlTemplateDoc.OuterXml);
return true;
}
public TermDependencyCondition(Template template, XmlNode conditionNode)
{
_template = template;
string sourceTerm = Utility.XMLHelper.GetAttributeString(conditionNode, XMLNames._A_SourceTerm);
if (!string.IsNullOrEmpty(sourceTerm))
{
_sourceTermID = _template.FindTerm(sourceTerm).ID;
}
else
{
_sourceTermID = Term.CreateID(conditionNode, XMLNames._A_SourceTermID);
}
_oper = Utility.XMLHelper.GetAttributeString(conditionNode, XMLNames._A_Oper);
_value1 = Utility.XMLHelper.GetAttributeString(conditionNode, XMLNames._A_Value1);
_value2 = Utility.XMLHelper.GetAttributeString(conditionNode, XMLNames._A_Value2);
}
public ExternalTerm(bool systemTerm, Business.ExternalInterfaceConfig eic, ManagedItem managedItem, Template template, bool isFilter)
: base(systemTerm, template, isFilter)
{
TermType = TermType.External;
NameRequired = true;
Name = eic.Name;
_interfaceConfig = eic;
//NOTE - This operation is valid only the FIRST time this is set...
if (TermTransforms == null && _interfaceConfig.TransformTermType.HasValue)
{
TransformTermType = _interfaceConfig.TransformTermType;
TermTransforms = _interfaceConfig.TermTransforms;
}
_managedItem = managedItem;
_valuesLoaded = false;
_value = null;
}
//Generate the Terms collection (of Term) based on an existing Template
public static List<Term> Create(XmlDocument xmlTemplateDoc, Template template)
{
XmlNodeList nodeComplexLists = xmlTemplateDoc.SelectNodes(Utility.XMLHelper.GetXPath(true, XMLNames._E_TemplateDef, XMLNames._E_ComplexLists, XMLNames._E_ComplexList));
if (nodeComplexLists == null)
{
return new List<Term>();
}
List<Term> rtn = new List<Term>(nodeComplexLists.Count);
foreach (XmlNode nodeComplexList in nodeComplexLists)
{
ComplexList complexList = new ComplexList(nodeComplexList, template, false);
rtn.Add(complexList);
}
return rtn;
}
//Generate the Comments collection (of N) based on an existing Template
public static List<Role> Create(XmlDocument xmlTemplateDoc, Template template)
{
List<Role> userDocumentPrinters = new List<Role>();
XmlNode nodeUserDocumentPrinters = xmlTemplateDoc.SelectSingleNode(Utility.XMLHelper.GetXPath(true, XMLNames._E_TemplateDef, XMLNames._E_UserDocumentPrinters));
if (nodeUserDocumentPrinters == null)
{
ITATSystem system = ITATSystem.Get(template.SystemID);
userDocumentPrinters = new List<Role>(system.Roles);
}
else
{
XmlNodeList nodeUserDocumentPrintersList = xmlTemplateDoc.SelectNodes(Utility.XMLHelper.GetXPath(true, XMLNames._E_TemplateDef, XMLNames._E_UserDocumentPrinters, XMLNames._E_Role));
foreach (XmlNode nodeUserDocumentPrinter in nodeUserDocumentPrintersList)
{
Role userDocumentPrinter = new Role(nodeUserDocumentPrinter);
userDocumentPrinters.Add(userDocumentPrinter);
}
}
return userDocumentPrinters;
}
private List<Business.Template> GetSystemTemplates(Guid gSystemID)
{
Dictionary<string, Business.Template> dictTemplates = new Dictionary<string, Business.Template>();
using (DataSet dsTemplates = Data.Template.GetRetroTemplateList(gSystemID))
{
foreach (DataRow drTemplate in dsTemplates.Tables[0].Rows)
{
Guid templateID = (Guid)drTemplate[Data.DataNames._C_TemplateID];
Business.Template template = new Business.Template(templateID, Business.DefType.Final);
if (template.RetroModel != Business.Retro.RetroModel.Off)
{
//Determine how many ManagedItems would require retro applied
int managedItemCount = GetManagedItems(templateID, template.RetroDate).Count;
if (managedItemCount > 0)
{
string templateKey = string.Format("{0:D10}|{1}", managedItemCount, templateID.ToString());
dictTemplates.Add(templateKey, template);
}
}
}
}
//Sort the templates according to number of ManagedItems, in decreasing order.
List<KeyValuePair<string, Business.Template>> dictTemplatesSorted = new List<KeyValuePair<string, Business.Template>>(dictTemplates);
dictTemplatesSorted.Sort(
delegate(KeyValuePair<string, Business.Template> firstPair, KeyValuePair<string, Business.Template> secondPair)
{
return secondPair.Key.CompareTo(firstPair.Key);
}
);
//Create a list for returning to the caller
List<Business.Template> templates = new List<Business.Template>(dictTemplatesSorted.Count);
foreach (KeyValuePair<string, Business.Template> kvp in dictTemplatesSorted)
{
templates.Add(kvp.Value);
}
return templates;
}
public static List<string> ReplaceEmbeddedTermNames(Template template, List<Event> notifications)
{
List<string> sErrors = new List<string>();
foreach (Event notification in notifications)
{
if (!Term.ValidID(notification.BaseDateTermID))
if (!string.IsNullOrEmpty((notification as Event).BaseDateTermName))
{
try
{
(notification as Event).BaseDateTermID = template.FindTerm((notification as Event).BaseDateTermName).ID;
}
catch (Exception)
{
sErrors.Add(string.Format("Unable to find Event term '{0}'", (notification as Event).BaseDateTermName));
}
}
if (!Term.ValidID(notification.OffsetTermID))
if (!string.IsNullOrEmpty((notification as Event).OffsetTermName))
{
try
{
(notification as Event).OffsetTermID = template.FindTerm((notification as Event).OffsetTermName).ID;
}
catch (Exception)
{
sErrors.Add(string.Format("Unable to find Event term '{0}'", (notification as Event).BaseDateTermName));
}
}
foreach (Message message in notification.Messages)
{
message.Text = Term.SubstituteTermNames(template, message.Text);
}
}
return sErrors;
}
public PlaceHolderTerm(XmlNode termNode, Template template, bool isFilter)
: base(termNode, template, isFilter)
{
NameRequired = true;
}
public PlaceHolderTerm(bool systemTerm, Template template, bool isFilter)
: base(systemTerm, template, isFilter)
{
NameRequired = true;
_template = template;
}
/// <summary>
/// Creates a new instance of a ManagedItem using the specified template where the system uses the OwningFacility concept
/// </summary>
/// <param name="template">The template that this ManagedItem is based on</param>
/// <param name="facilityIds">One or more facilities that this ManagedItem is associated with</param>
public static ManagedItem CreateRetro(Template template, bool useAlternateTemplate, Guid sourceManagedItemID, bool hasOwningFacility, Utility.DocumentStorageType documentStorageType, out bool returnToDraft)
{
ManagedItem sourceManagedItem = Business.ManagedItem.Get(sourceManagedItemID, true);
ManagedItem newManagedItem = new ManagedItem(template.ID, sourceManagedItem.ManagedItemID);
newManagedItem.RetroCopy(template, useAlternateTemplate);
returnToDraft = newManagedItem.Migrate(sourceManagedItem);
if (returnToDraft)
{
//Changed for Multiple Documents
foreach (ITATDocument doc in sourceManagedItem.Documents)
{
if (!string.IsNullOrEmpty(doc.GeneratedDocumentID))
{
RemoveGeneratedDocument(sourceManagedItem, doc.GeneratedDocumentID, documentStorageType);
newManagedItem.GetITATDocument(doc.ITATDocumentID).GeneratedDocumentID = null;
}
}
}
return newManagedItem;
}
public LinkTerm(bool systemTerm, Template template, bool isFilter)
: base(systemTerm, template, isFilter)
{
TermType = TermType.Link;
NameRequired = true;
}
public void Rollback(Guid managedItemAuditId, string sEnvironment, bool? orphanTheItem)
{
bool retroRollback;
Retro.RetroData retroData = GetRetroData(_itemNumber, _managedItemID, managedItemAuditId);
if (retroData.TemplateRetroDate.HasValue && retroData.AuditDate < retroData.TemplateRetroDate.Value)
{
//May require retro
switch (RetroModel)
{
case Retro.RetroModel.Off:
retroRollback = false;
break;
case Retro.RetroModel.OnWithEditLanguage:
if (_isOrphaned)
{
retroRollback = false;
}
else
{
if (!orphanTheItem.HasValue)
throw new Exception(string.Format("The 'orphan' value was required but not supplied for the rollback of ManagedItem '{0}'", ManagedItemID.ToString()));
retroRollback = !(orphanTheItem.Value);
_isOrphaned = orphanTheItem.Value;
if (_isOrphaned)
{
retroData.AuditType = Retro.AuditType.Orphaned;
ILog log = LogManager.GetLogger(this.GetType());
log.Debug(string.Format("ManagedItem {0} ({1}) (System {2}) Orphaned due to Rollback", ItemNumber, ManagedItemID.ToString(), SystemID.ToString()));
}
}
break;
case Retro.RetroModel.OnWithoutEditLanguage:
retroRollback = true;
break;
default:
throw new Exception(string.Format("RetroModel case '{0}' not handled for ManagedItem '{1}'", RetroModel.ToString(),ManagedItemID.ToString()));
}
}
else
retroRollback = false;
ITATSystem itatSystem = null;
Business.ManagedItem newManagedItem = null;
if (retroRollback)
{
Template currentTemplate = new Template(TemplateID, Business.DefType.Final);
itatSystem = ITATSystem.Get(SystemID);
bool returnToDraft;
newManagedItem = Business.ManagedItem.CreateRetro(currentTemplate, false, ManagedItemID, itatSystem.HasOwningFacility.Value, itatSystem.DocumentStorageType, out returnToDraft);
newManagedItem.Update(false, retroData.AuditType); //Update also calls UpdateManagedItemStateRole
if (returnToDraft)
{
//No action required here as of last spec update
}
newManagedItem.UpdateScheduledEvents(ScheduledEvent.ExecutedCalculationType.UseGracePeriod);
}
else
{
newManagedItem = new ManagedItem(TemplateID, ManagedItemID, ItemNumber, IsOrphaned, retroData.StateID, retroData.TemplateDef);
//Ensure that the database is updated with the older External term values
foreach (Term t in newManagedItem.BasicTerms)
if (t.TermType == TermType.External)
{
(t as ExternalTerm).SaveValues(false);
}
newManagedItem.Update(false, retroData.AuditType); //Update also calls UpdateManagedItemStateRole
}
//Changed for Multiple Documents
foreach (ITATDocument doc in Documents)
{
if (!string.IsNullOrEmpty(doc.GeneratedDocumentID) && newManagedItem.GetITATDocument(doc.ITATDocumentID).GeneratedDocumentID != doc.GeneratedDocumentID)
{
if (itatSystem == null)
itatSystem = ITATSystem.Get(SystemID);
//Changed for Multiple Documents
RemoveGeneratedDocument(newManagedItem, doc.GeneratedDocumentID, itatSystem.DocumentStorageType);
}
}
}
public static ManagedItemStore CreateStore(
ILog log,
Template template,
string managedItem,
Guid managedItemID,
string managedItemNumber,
string status,
string state,
Dictionary<string /* Term Name */, Term> templateTerms,
List<string> basicTermsToProcess,
List<string> complexListTermsToProcess)
{
ManagedItemStore managedItemStore = new ManagedItemStore(template.ID, template.Name, managedItemNumber, status, state);
bool basicTermsProcessed = false;
bool complexListsProcessed = false;
bool workflowsProcessed = false;
int basicTermsToProcessCount = basicTermsToProcess.Count;
int complexListTermsToProcessCount = complexListTermsToProcess.Count;
XmlTextReader txtReader = new XmlTextReader(new MemoryStream(Encoding.UTF8.GetBytes(managedItem)));
XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.IgnoreWhitespace = true;
readerSettings.IgnoreComments = true;
readerSettings.IgnoreProcessingInstructions = true;
using (XmlReader reader = XmlReader.Create(txtReader, readerSettings))
{
reader.MoveToContent(); //Reader initialized and positioned at the 'TemplateDef' node.
while (!(basicTermsProcessed && complexListsProcessed && workflowsProcessed))
{
if (!reader.Read()) //At start element of a TemplateDef child node.
{
throw new Exception(string.Format("CreateStore call stopped unexpectedly on failed reader.Read call for ManagedItemNumber '{0}', ManagedItemID '{1}'", managedItemNumber, managedItemID.ToString()));
}
//Ensure completion before quitting...
if (reader.NodeType == XmlNodeType.EndElement && reader.Name == XMLNames._E_TemplateDef)
{
string error = string.Empty;
if (basicTermsToProcessCount > 0 && !basicTermsProcessed)
error += "Basic Terms were not processed. ";
if (complexListTermsToProcessCount > 0 && !complexListsProcessed)
error += "Complex Lists were not processed. ";
if (!workflowsProcessed)
error += "WorkFlows were not processed. ";
if (!string.IsNullOrEmpty(error))
throw new Exception(string.Format("CreateStore call at end element before processing completed for ManagedItemNumber '{0}', ManagedItemID '{1}'. {2}", managedItemNumber, managedItemID.ToString(), error));
break;
}
switch (reader.Name)
{
case XMLNames._E_Workflows:
Guid activeWorkflowID = new Guid(reader.GetAttribute(XMLNames._A_ActiveWorkflowID));
//NOTE - The search for active workflow may fail if the template information does not match the manageditem's information.
Workflow activeWorkflow = template.FindWorkflow(activeWorkflowID);
if (activeWorkflow != null)
managedItemStore.ActiveWorkflow = activeWorkflow.Name;
else
managedItemStore.ActiveWorkflow = string.Empty;
using (reader.ReadSubtree()) { }
workflowsProcessed = true;
break;
case XMLNames._E_Terms:
if (basicTermsToProcess.Count > 0)
{
ReadTermStore(
template.Name,
managedItemID,
reader.ReadSubtree(),
managedItemStore,
templateTerms,
basicTermsToProcess);
}
else
{
using (reader.ReadSubtree()) { }
}
basicTermsProcessed = true;
break;
case XMLNames._E_ComplexLists:
if (complexListTermsToProcess.Count > 0)
{
ReadComplexListStore(
reader.ReadSubtree(),
managedItemStore,
templateTerms,
complexListTermsToProcess);
}
else
{
using (reader.ReadSubtree()) { }
}
complexListsProcessed = true;
break;
case XMLNames._E_Events:
case XMLNames._E_Document:
case XMLNames._E_Comments:
case XMLNames._E_TermDependencies:
case XMLNames._E_DetailedDescriptions:
case XMLNames._E_TermGroups:
case XMLNames._E_DocumentPrinters:
default:
using (reader.ReadSubtree()) { }
break;
}
}
}
return managedItemStore;
}
public static ScheduledEvent Find(Template template, Guid scheduledEventID)
{
if (template == null)
return null;
ScheduledEvent scheduledEvent = null;
foreach (Event eachEvent in template.Events)
{
scheduledEvent = Find(eachEvent.ScheduledEvents, scheduledEventID);
if (scheduledEvent != null)
return scheduledEvent;
}
foreach (Event eachEvent in template.Workflow.Events)
{
scheduledEvent = Find(eachEvent.ScheduledEvents, scheduledEventID);
if (scheduledEvent != null)
return scheduledEvent;
}
RenewalTerm renewalTerm = template.FindBasicTerm(TermType.Renewal) as RenewalTerm;
if (renewalTerm != null)
return Find(renewalTerm.RenewalEvent.ScheduledEvents, scheduledEventID);
return null;
}
internal List<string> TermReferences(Template template, string termName, string sClient)
{
return Term.TermReferences(template, termName, System.Web.HttpUtility.HtmlDecode(Text), sClient, "notification");
}
public List<string> ProcessSystem(Guid gSystemID, string systemName, ref int batchTemplateDraftCount, ref int batchTemplateFinalCount, ref int batchManagedItemCount)
{
batchTemplateDraftCount = 0;
batchTemplateFinalCount = 0;
batchManagedItemCount = 0;
Stopwatch stopWatchTemplate = new Stopwatch();
Stopwatch stopWatchManagedItem = new Stopwatch();
ILog log = Kindred.Common.Logging.LogManager.GetLogger(this.GetType());
List<string> badDraftTemplateDefGuids = new List<string>();
using (DataSet dsTemplates = Business.Template.GetTemplateList(gSystemID, null))
{
log.Info(string.Format("Processing {0:D} Templates", dsTemplates.Tables[0].Rows.Count));
foreach (DataRow drTemplate in dsTemplates.Tables[0].Rows)
{
Guid templateID = (Guid)drTemplate[Data.DataNames._C_TemplateID];
if (Business.Template.DraftTemplateDefValid(templateID))
{
batchTemplateDraftCount++;
string templateName = "UNDEFINED";
stopWatchTemplate.Start();
try
{
Business.Template template = new Business.Template(templateID, Business.DefType.Draft);
//Ensure that the SecurityModel is loaded.
Business.SecurityModel securityModel = template.SecurityModel;
//Ensure that the Terms, ComplexLists, Workflows are updated.
int nBasicTermsCount = template.BasicTerms.Count;
int nComplexListsCount = template.ComplexLists.Count;
int nWorkflowsCount = template.Workflows.Count;
templateName = template.Name;
template.SaveLoaded(false, true, null);
log.Info(string.Format("Processed Template '{0}'", templateName));
}
catch (Exception ex)
{
log.Error(string.Format("Failed to process DraftTemplateDef for System '{0}', Template '{1}' - Error Message = '{2}'", systemName, templateName, ex.Message), ex);
}
stopWatchTemplate.Stop();
if (Business.Template.FinalTemplateDefValid(templateID))
{
batchTemplateFinalCount++;
stopWatchTemplate.Start();
try
{
Business.Template template = new Business.Template(templateID, Business.DefType.Final);
//Ensure that the Terms, ComplexLists, Workflows are updated.
int nBasicTermsCount = template.BasicTerms.Count;
int nComplexListsCount = template.ComplexLists.Count;
int nWorkflowsCount = template.Workflows.Count;
template.SaveLoaded(false, true, null);
Data.Template.UpdateTemplateBaseStateRole(template.ID, Utility.ListHelper.EliminateDuplicates(template.Workflow.FindBaseState().EditorRoleNames));
}
catch (Exception ex)
{
log.Error(string.Format("Failed to process FinalTemplateDef for System '{0}', Template '{1}' - Error Message = '{2}'", systemName, templateName, ex.Message), ex);
}
stopWatchTemplate.Stop();
List<Guid> managedItemIDs = GetManagedItems(gSystemID, templateID);
if (managedItemIDs.Count > 0)
{
log.Info(string.Format("Processing {0:D} ManagedItems", managedItemIDs.Count));
int templateManagedItemCount = 0;
int nLog = 200;
foreach (Guid managedItemID in managedItemIDs)
{
batchManagedItemCount++;
templateManagedItemCount++;
stopWatchManagedItem.Start();
try
{
Business.ManagedItem managedItem = Business.ManagedItem.Get(managedItemID, true);
//Ensure that the Terms, ComplexLists, Workflows are updated.
int nBasicTermsCount = managedItem.BasicTerms.Count;
int nComplexListsCount = managedItem.ComplexLists.Count;
int nWorkflowsCount = managedItem.Workflows.Count;
managedItem.Update(false, Kindred.Knect.ITAT.Business.Retro.AuditType.Saved); //Update also calls UpdateManagedItemStateRole
managedItem.UpdateScheduledEvents(Business.ScheduledEvent.ExecutedCalculationType.UseGracePeriod);
if (templateManagedItemCount % nLog == 0)
log.Info(string.Format("Processed {0:D} ManagedItems", templateManagedItemCount));
}
catch (Exception ex)
{
log.Error(string.Format("Failed to process ManagedItem '{0}' for System '{1}', Template '{2}' - Error Message = '{3}'", managedItemID.ToString(), systemName, templateName, ex.Message), ex);
}
stopWatchManagedItem.Stop();
}
log.Info(string.Format("Processed a total of {0:D} ManagedItems", templateManagedItemCount));
}
}
else
log.Debug(string.Format("FinalTemplateDef invalid for System '{0}', Template '{1}'", systemName, templateName));
}
else
{
badDraftTemplateDefGuids.Add(templateID.ToString());
if (Business.Template.FinalTemplateDefValid(templateID))
{
log.Error(string.Format("For System '{0}', TemplateID '{1}' - DraftTemplateDef invalid BUT FinalTemplateDef valid!", systemName, templateID.ToString()));
}
}
}
}
if (badDraftTemplateDefGuids.Count > 0)
log.Error(string.Format("DraftTemplateDef invalid for the following {0:D} templates: '{1}'", badDraftTemplateDefGuids.Count, string.Join(",", badDraftTemplateDefGuids.ToArray())));
log.Debug(string.Format("System {0} - Total Template elapsed time = {1}; Average Template elapsed time = {2} sec", systemName, stopWatchTemplate.Elapsed, stopWatchTemplate.Elapsed.TotalSeconds / (batchTemplateDraftCount + batchTemplateFinalCount)));
if (batchManagedItemCount > 0)
log.Debug(string.Format("System {0} - Total ManagedItem elapsed time = {1}; Average ManagedItem elapsed time = {2} sec", systemName, stopWatchManagedItem.Elapsed, stopWatchManagedItem.Elapsed.TotalSeconds / batchManagedItemCount));
else
log.Debug(string.Format("System {0} - Total ManagedItem elapsed time = 0; Average ManagedItem elapsed time = 0 sec", systemName));
return null;
}
//Generate the Terms collection (of Term) based on an existing Template
//Called by ManagedItem.GetBasic and by ManagedItem.Get
public static List<Term> Create(XmlDocument xmlTemplateDoc, ManagedItem managedItem, Template template)
{
return Create(xmlTemplateDoc.SelectSingleNode(Utility.XMLHelper.GetXPath(true, XMLNames._E_TemplateDef, XMLNames._E_Terms)), managedItem, template);
}
//Generate the Terms collection (of Term) based on an xml document
//Called by BasicTerms.Create, once from ITATSystem.LoadFromDatabase
public static List<Term> Create(XmlNode termsNode, ManagedItem managedItem, Template template)
{
List<Term> rtn = new List<Term>(termsNode.ChildNodes.Count);
int order = 0;
foreach (XmlNode termNode in termsNode)
{
Term t = null;
switch (termNode.Name.ToString())
{
case XMLNames._E_Text:
t = new TextTerm(termNode, template, false);
break;
case XMLNames._E_Date:
t = new DateTerm(termNode, template, false);
break;
case XMLNames._E_MSO:
t = new MSOTerm(termNode, template, false);
break;
case XMLNames._E_Link:
t = new LinkTerm(termNode, template, false);
break;
case XMLNames._E_Facility:
t = new FacilityTerm(termNode, template, false);
break;
case XMLNames._E_Renewal:
t = new RenewalTerm(termNode, managedItem != null, template, false);
break;
case XMLNames._E_PickList:
t = new PickListTerm(termNode, template, false);
break;
case XMLNames._E_External:
t = new ExternalTerm(termNode, managedItem, template, false);
break;
case XMLNames._E_PlaceHolderAttachments:
t = new PlaceHolderAttachments(termNode, template, false);
break;
case XMLNames._E_PlaceHolderComments:
t = new PlaceHolderComments(termNode, template, false);
break;
default:
throw new XmlException(string.Format("Tried to create undefined term type {0}", termNode.Name.ToString()));
}
t.Order = order++;
rtn.Add(t);
}
//If this is not a load of the ITATSystem terms, then ensure that the collection includes the Attachments and Comments terms.
if (template != null)
{
List<Term> placeholderTerms = FindTermsOfType(rtn, (TermType.PlaceHolderAttachments | TermType.PlaceHolderComments));
if (placeholderTerms == null || (placeholderTerms != null && placeholderTerms.Count == 0))
{
//If this is the first time these are being added, then this should be under Basic Security.
Term t = new PlaceHolderAttachments(false, template, false);
t.TermGroupID = template.BasicSecurityTermGroupID;
t.Order = order++;
rtn.Add(t);
t = new PlaceHolderComments(false, template, false);
t.TermGroupID = template.BasicSecurityTermGroupID;
t.Order = order++;
rtn.Add(t);
}
else if (placeholderTerms.Count != 2)
{
throw new Exception(string.Format("Encountered a PlaceHolder term count of {0:D} when 2 were expected", placeholderTerms.Count));
}
}
return rtn;
}