//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 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; }
/// <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 Create(bool updateDatabase, Guid templateID, int? primaryFacilityID) { ManagedItem managedItem = new ManagedItem(templateID, Guid.NewGuid()); managedItem.LoadWorkflow(); //Load BasicTerms since we will need to update the TemplateDef based on the selected PrimaryID's managedItem.LoadBasicTerms(); managedItem.SetDefaultValues(); managedItem.LoadAttachments(); managedItem.State = managedItem.Workflow.FindBaseState(); if (primaryFacilityID.HasValue) { List<int> facilityIDs = new List<int>(1); facilityIDs.Add(primaryFacilityID.Value); managedItem.PrimaryFacility.SelectedFacilityIDs = new List<int>(facilityIDs); managedItem.PrimaryFacility.OwningFacilityIDs = new List<int>(facilityIDs); } ITATSystem system = ITATSystem.Get(managedItem.SystemID); string sFirstPart = GetFirstPart(system, managedItem); string sPrefix = string.Format("{0}{1}", sFirstPart, system.ManagedItemNumberSystemId); if (sPrefix.Length > 13) throw new Exception("The ManagedItem Number length will exceed 20 characters"); int nSequenceNumber = 0; if (updateDatabase) nSequenceNumber = Data.ManagedItem.GetSequenceNumber(managedItem.SystemID, sPrefix); else nSequenceNumber = 1; if (nSequenceNumber <= 0) { if (primaryFacilityID.HasValue) throw new Exception(string.Format("SequenceNumber not found for SystemID {0}, FacilityID {1}", managedItem.SystemID.ToString(), primaryFacilityID.Value.ToString())); else throw new Exception(string.Format("SequenceNumber not found for SystemID {0}", managedItem.SystemID.ToString())); } managedItem.ItemNumber = string.Format("{0}{1}", sPrefix, nSequenceNumber.ToString("D7")); return managedItem; }
/// <summary> /// Retrieves a ManagedItem instance from the database. Only retrieves the minimum data. /// </summary> /// <param name="id"></param> public static ManagedItem GetBasic(Guid managedItemID) { string status = ""; string templateDef = ""; string itemNumber = ""; string templateID = ""; Guid stateID = Guid.Empty; using (DataSet ds = Data.ManagedItem.GetManagedItem(managedItemID)) { DataRow row = ds.Tables[0].Rows[0]; status = (string)row[Data.DataNames._C_Status]; templateDef = (string)row[Data.DataNames._C_TemplateDef]; templateID = row[Data.DataNames._C_TemplateID].ToString(); itemNumber = row[Data.DataNames._C_ManagedItemNumber].ToString(); try { stateID = (Guid)row[Data.DataNames._C_StateID]; } catch { throw new Exception(string.Format("StateID not defined for ManagedItem {0}", itemNumber)); } } ManagedItem managedItem = new ManagedItem(new Guid(templateID), managedItemID); XmlDocument xmlTemplateDoc = new XmlDocument(); xmlTemplateDoc.PreserveWhitespace = false; xmlTemplateDoc.LoadXml(templateDef); managedItem.LoadWorkflow(xmlTemplateDoc); managedItem.LoadBasicTerms(xmlTemplateDoc); //populate external terms foreach (Term term in managedItem.FindAllBasicTerms(TermType.External)) { ExternalTerm extTerm = term as ExternalTerm; if (extTerm == null) throw new Exception(string.Format("The term '{0}' is not an external term.", term.Name)); if (!extTerm.ValuesLoaded) extTerm.LoadValues(); } managedItem.State = managedItem.Workflow.FindState(stateID); managedItem.ItemNumber = itemNumber; return managedItem; }
public static ManagedItem Get(Guid managedItemId, bool loadComplexLists, string state, Guid stateID, string status, string templateDef, string itemNumber, Guid templateID, bool orphaned) { ManagedItem managedItem = new ManagedItem(templateID, managedItemId); XmlDocument xmlTemplateDoc = new XmlDocument(); xmlTemplateDoc.PreserveWhitespace = false; xmlTemplateDoc.LoadXml(templateDef); if (loadComplexLists) { //Need Workflow in order to access the states //Need BasicTerms in order to be able to modify the Primary FacilityID's managedItem.LoadWorkflow(xmlTemplateDoc); managedItem.LoadBasicTerms(xmlTemplateDoc); managedItem.LoadComplexLists(xmlTemplateDoc); } else { managedItem.LoadWithoutComplexLists(xmlTemplateDoc); } managedItem.LoadComments(xmlTemplateDoc); managedItem.LoadAttachments(); if (!managedItem.TermGroupsLoaded) managedItem.LoadTermGroups(xmlTemplateDoc); managedItem.LoadDocuments(xmlTemplateDoc); if (stateID.Equals(Guid.Empty)) managedItem.State = managedItem.Workflow.FindState(state); else managedItem.State = managedItem.Workflow.FindState(stateID); managedItem.ItemNumber = itemNumber; managedItem.IsOrphaned = orphaned; return managedItem; }
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); } } }
private bool Migrate(ManagedItem sourceManagedItem) { _itemNumber = sourceManagedItem._itemNumber; _isOrphaned = sourceManagedItem._isOrphaned; //Changed for Multiple Documents this.Documents = sourceManagedItem.Documents; CopyExtensions(sourceManagedItem.Extensions); _attachments = new List<Attachment>(sourceManagedItem.Attachments); foreach (Term term in BasicTerms) { term.MigrateReset(); Term sourceTerm = sourceManagedItem.FindTerm(term.ID, term.Name); if (sourceTerm != null && !(sourceTerm is ComplexList) && term.TermType == sourceTerm.TermType) term.Migrate(sourceTerm); else { term.Migrate(null); } } foreach (Term term in sourceManagedItem.BasicTerms) { if (!term.Runtime.Migrated) term.Delete(); } for (int index = 0;index < ComplexLists.Count;index++) { ComplexList term = (ComplexList)ComplexLists[index]; Term sourceTerm = sourceManagedItem.FindTerm(term.ID, term.Name); if (sourceTerm != null && (sourceTerm is ComplexList)) { if (ComplexList.ModifyItems(sourceTerm as ComplexList, term)) term = (ComplexList)term.RetroCopy(false, this); term.Migrate(sourceTerm); ComplexLists[index] = term; } else term.Migrate(null); } foreach (Term term in sourceManagedItem.ComplexLists) { if (!term.Runtime.Migrated) term.Delete(); } int count = Comments.Count; //Cause the setting of _commentsLoaded Comments = new List<Comment>(sourceManagedItem.Comments); Event.Migrate(sourceManagedItem.Events, Events); Event.Migrate(sourceManagedItem.Workflow.Events, Workflow.Events); //The ActiveWorkflow is determined by the source template (that was used to create 'this'). //The ActiveWorkflow will not change. //If the sourceManagedItem happens to have the same ActiveWorkflow as the source template, and a match //can be made on the state, then keep the state. Otherwise, set the state to the base state. State currentState = null; if (ActiveWorkflowID.Equals(sourceManagedItem.ActiveWorkflowID) || Workflow.Name.Equals(sourceManagedItem.Workflow.Name)) { currentState = Workflow.FindState(sourceManagedItem.State.ID); if (currentState == null) currentState = Workflow.FindState(sourceManagedItem.State.Name); } State = currentState == null ? Workflow.FindBaseState() : currentState; return currentState == null; }
//TODO: Allow for non-numeric hard-coded value (including empty string) private static string GetFirstPart(ITATSystem system, ManagedItem managedItem) { //If ManagedItemNumberSystemType is an empty string, then return an empty string if (string.IsNullOrEmpty(system.ManagedItemNumberSystemType)) return string.Empty; //If ManagedItemNumberSystemType is a special value meaning SAP Alias, return the Owning Facility's SAP Alias if (system.ManagedItemNumberSystemType == XMLNames._SYSTEM_MINST_Fac_SAP4) { if (managedItem.PrimaryFacility.OwningFacilityIDs == null) throw new Exception(string.Format("Tried to create a sequence number for a ManagedItem which does not have any OwningFacilites defined, ManagedItem {0}", managedItem._managedItemID.ToString())); if (managedItem.PrimaryFacility.OwningFacilityIDs.Count == 0) throw new Exception(string.Format("Tried to create a sequence number for a ManagedItem which does not have any OwningFacilites defined, ManagedItem {0}", managedItem._managedItemID.ToString())); string sSAPID = ""; using (DataSet ds = Data.ManagedItem.GetFacilityInfo(FacilityTerm.GetXml(managedItem.PrimaryFacility.OwningFacilityIDs))) { if (ds.Tables.Count > 0) if (ds.Tables[0].Rows.Count > 0) //This approach assumes that we are only interested in the first facilityID sSAPID = ds.Tables[0].Rows[0][Data.DataNames._SP_FacilitySAPID].ToString(); if (string.IsNullOrEmpty(sSAPID)) throw new Exception(string.Format("SAPID not found for managedItem {0}", managedItem._managedItemID.ToString())); } return sSAPID.Substring(0, 4); } //Otherwise, return the hard-coded ManagedItemNumberSystemType return system.ManagedItemNumberSystemType; }
//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); }
private bool AnyConditionMet(ManagedItem managedItem) { foreach (TermDependencyCondition condition in _conditions) { if (condition.ConditionMet(managedItem.FindBasicTerm(condition.SourceTerm))) return true; } return false; }
public bool ShouldApplyAction(ManagedItem managedItem) { if (_quantifier == DependencyQuantifier.Any) return AnyConditionMet(managedItem); else return AllConditionsMet(managedItem); }
public ManagedItemSummary(ManagedItem managedItem) { _managedItem = managedItem; }
public ExternalTerm(XmlNode termNode, ManagedItem managedItem, Template template, bool isFilter) : base(termNode, template, isFilter) { TermType = TermType.External; NameRequired = true; XmlNode nodeInterfaceConfig = termNode.SelectSingleNode(XMLNames._E_Config); if (nodeInterfaceConfig == null) throw new Exception("Config node not found for External Term"); _interfaceConfig = new ExternalInterfaceConfig(nodeInterfaceConfig); _managedItem = managedItem; _valuesLoaded = false; XmlNode nodeValue = termNode.SelectSingleNode(XMLNames._E_Value); if (nodeValue != null) _value = Utility.XMLHelper.GetXMLText(Utility.XMLHelper.GetText(nodeValue)); else _value = MakeNameValueXml(); }
public static void RemoveGeneratedDocument(ManagedItem sourceManagedItem, string documentID, Utility.DocumentStorageType documentStorageType) { ILog log = LogManager.GetLogger(sourceManagedItem.GetType()); try { Utility.DocumentStorage documentStorageObject = Utility.DocumentStorage.GetDocumentStorageObject(documentStorageType); documentStorageObject.DeleteDocument(documentID); log.Debug(string.Format("Deleted Generated document {0} from ManagedItem {1} during CreateRetro call", documentID, sourceManagedItem.ItemNumber)); } catch { //Create a record in the Document table - for later clean up Data.Document.DeleteDocument(sourceManagedItem.ManagedItemID, "Generated Document", "Generated Document", documentID, "Generated Document", false, false); log.Error(string.Format("Failed to fully delete Generated document {0} from ManagedItem {1} during CreateRetro call", documentID, sourceManagedItem.ItemNumber)); } }
//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; }
/// <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 string Send(ManagedItem managedItem, ITATSystem system, string sEnvironment, List<int> owningFacilityIDs) { //If the subject or body or recipients are empty, then do not send anything if ((string.IsNullOrEmpty(Subject)) || (string.IsNullOrEmpty(this.Text)) || (this.Recipients == null) || (this.Recipients.Count == 0)) return string.Empty; string sError = string.Empty; string from = null; string subject = null; string text = null; Kindred.Common.Security.NameEmailPair[] emailRecipients = null; try { Kindred.Common.Email.Email email = new Kindred.Common.Email.Email(); from = XMLNames._M_EmailFrom; subject = string.IsNullOrEmpty(Subject) ? "Subject Missing" : Subject; text = string.IsNullOrEmpty(Text) ? "Text Missing" : Text; Term.SubstituteBasicTerms(managedItem, ref text); Term.SubstituteSpecialTerms(ref text, managedItem); //Now complete the 'ManagedItemReference' email links - fill in the dynamically supplied info if (!string.IsNullOrEmpty(system.Name)) text = text.Replace(XMLNames._M_SystemNameHolder, system.Name); if (!string.IsNullOrEmpty(sEnvironment)) text = text.Replace(XMLNames._M_EnvironmentHolder, sEnvironment); text = text.Replace(XMLNames._M_ManagedItemIdHolder, managedItem.ManagedItemID.ToString()); List<int> facilityIDs = null; if (owningFacilityIDs != null) facilityIDs = new List<int>(owningFacilityIDs); else facilityIDs = new List<int>(); bool overrideFacilities = false; //Note - HasOwningFacility trumps use of filterFacilityTerm if (!(system.HasOwningFacility ?? false)) { if (FilterFacilityTermID.HasValue) { Term filterFacilityTerm = managedItem.FindTerm(FilterFacilityTermID.Value); if (filterFacilityTerm != null) { FacilityTerm facilityTerm = null; if (filterFacilityTerm.TermType == TermType.Facility) facilityTerm = filterFacilityTerm as FacilityTerm; else facilityTerm = new FacilityTerm(false, managedItem, filterFacilityTerm); if (facilityTerm != null) { facilityIDs = facilityTerm.SelectedFacilityIDs; overrideFacilities = true; } } } } List<int> allRecipientFacilityIDs = new List<int>(); if ((system.HasOwningFacility ?? false) || overrideFacilities) { foreach (string recipient in Recipients) { List<int> absoluteLevels = null; List<int> relativeLevels = null; system.GetFacilityLevels(recipient, ref absoluteLevels, ref relativeLevels); List<int> recipientFacilityIDs = FacilityCollection.FacilityAncestry(facilityIDs, absoluteLevels, relativeLevels); foreach (int facilityID in recipientFacilityIDs) if (!allRecipientFacilityIDs.Contains(facilityID)) allRecipientFacilityIDs.Add(facilityID); } emailRecipients = SecurityHelper.GetEmailRecipients(system, Recipients, allRecipientFacilityIDs); } else { emailRecipients = SecurityHelper.GetEmailRecipients(system, Recipients); } EmailHelper.SendEmail(from, subject, text, emailRecipients, system, Recipients, allRecipientFacilityIDs); } catch (Exception e) { sError = string.Format("Email={0} Exception={1}", EmailInfo(from, emailRecipients, subject, text), e.ToString()); } return sError; }
public static void SendNotificationToOwner(ITATSystem system, ManagedItem managedItem, string message, string errorMessage) { string[] ownerRecipients = system.OwnerEmail.Split(new char[] { ',', '|' }, StringSplitOptions.RemoveEmptyEntries); if (ownerRecipients.Length > 0) { Kindred.Common.Email.Email email = new Kindred.Common.Email.Email(); foreach (string recipient in ownerRecipients) email.AddRecipient(Kindred.Common.Email.EmailRecipientType.To, recipient); email.Subject = string.Format("ITAT-{0} -- Unable to send notification for {1} {2}", system.Name, system.ManagedItemName, managedItem.ItemNumber); email.From = XMLNames._M_EmailFrom; email.Format = Kindred.Common.Email.EmailFormat.Html; email.Body = string.Format("<b>ITAT-{0} was unable to send a notification for {1} {2}.<br /><br />{3}</b><br /><br /><br />{4}", system.Name, system.ManagedItemName, managedItem.ItemNumber, errorMessage, message); email.ApplicationName = EmailName(system.Name); email.Send(); } }
public override void Migrate(Term term) { if (term == null) base.Migrate(term); if (!(term is ExternalTerm)) return; else { ExternalTerm sourceTerm = term as ExternalTerm; _managedItem = sourceTerm._managedItem; //This is okay since we only need the ManagedItemID _value = sourceTerm._value; _interfaceConfig = sourceTerm._interfaceConfig.Copy(); SaveValues(false); LoadValues(); term.Runtime.Migrated = true; } Runtime.Migrated = true; }