private void LoadManagedItems(bool updateDatabase) { List<string> errors = new List<string>(); if (ddlSystem.SelectedIndex == 0) { RegisterAlert("A valid system must be selected."); return; } if (ddlSourceTemplate.SelectedIndex == 0) { RegisterAlert("A valid template must be selected."); return; } if (filUpload.PostedFile == null || filUpload.PostedFile.ContentLength == 0) { RegisterAlert("A valid load file must be selected."); return; } List<string> fileRows = new List<string>(); if (filUpload.HasFile) { string extension = filUpload.FileName.Substring(filUpload.FileName.Length - 4, 4); if (extension.ToUpper().Equals(".TXT") || extension.ToUpper().Equals(".CSV")) { using (StreamReader sr = new StreamReader(filUpload.PostedFile.InputStream)) { string allContent = sr.ReadToEnd(); string current = string.Empty; for (int index = 0; index < allContent.Length; index++) { current += allContent[index]; if (IsEndOfLine(ref index, allContent)) { fileRows.Add(current); current = string.Empty; } } if (current.Length > 0) fileRows.Add(current); } } else { RegisterAlert("You must upload a file with a '.txt' or a '.csv' extension"); return; } } else { RegisterAlert("No uploaded file was found"); return; } string exception = string.Empty; try { _dtExcelData = Business.ManagedItem.QueryFile(fileRows.ToArray(), _ROW_MAIN_COLUMN_HEADINGS, _ROW_SECONDARY_COLUMN_HEADINGS, _TERM_DELIMITER, out exception); } catch (Exception ex) { exception = ex.Message; } if (_dtExcelData == null || !string.IsNullOrEmpty(exception)) { RegisterAlert(string.Format("Failed to extract from supplied file '{0}'. Error: '{1}'", HttpUtility.HtmlDecode(filUpload.PostedFile.FileName), exception)); return; } int? primaryFacilityID = null; int nRowsTotal = 0; int nRowsUnsuccessful = 0; List<string> confirmationMessage = new List<string>(); if (!updateDatabase) { confirmationMessage.Add("**************************************************************************"); confirmationMessage.Add("*************************** THIS IS A TEST ***************************"); confirmationMessage.Add("**************************************************************************"); confirmationMessage.Add(""); confirmationMessage.Add(""); } confirmationMessage.Add("Results for Load of"); confirmationMessage.Add(string.Format("\tSystem = {0}", ddlSystem.SelectedItem.Text)); confirmationMessage.Add(string.Format("\tTemplate = {0}", ddlSourceTemplate.SelectedItem.Text)); string fileName = filUpload.PostedFile.FileName; int nPos = fileName.LastIndexOf('\\') + 1; fileName = fileName.Substring(nPos, fileName.Length - nPos); confirmationMessage.Add(string.Format("\tSource File = {0}", fileName)); List<string> feedBack = new List<string>(); bool feedBackExists = false; divConfirmationMessage.Visible = false; btnExportFeedbackExcel.Visible = false; _dtExcelData.Columns.Add(_COL_ERRORS); _dtExcelData.Columns.Add(_COL_DO_NOT_OUTPUT); List<string> skipColumns = new List<string>(); skipColumns.Add(_COL_ERRORS); skipColumns.Add(_COL_DO_NOT_OUTPUT); //See if this is a load of a complex list if (IsComplexListLoad(_dtExcelData.Rows[_ROW_FIRST_DATA][0].ToString())) { string complexListName = GetComplexListName(_dtExcelData.Rows[_ROW_FIRST_DATA][0].ToString()); if (string.IsNullOrEmpty(complexListName)) { RegisterAlert("No complex list name was found"); return; } //Process bool firstRow = true; List<Guid> managedItemTracker = new List<Guid>(); Business.ManagedItem managedItem = null; for (int index = _ROW_FIRST_DATA + 1; index < _dtExcelData.Rows.Count; index++) { //Determine MI here, pass in to call //Detect when a new one is encountered.... DataRow row = _dtExcelData.Rows[index]; switch (row[_COL_ACTION].ToString()) { case _ACTION_INSERT: case _ACTION_UPDATE: case _ACTION_DELETE: feedBack.Add(string.Format("Action '{0}' was requested, but only '{1}' will be processed", row[_COL_ACTION].ToString(), _ACTION_UPDATE_COMPLEX_LIST)); continue; case _ACTION_UPDATE_COMPLEX_LIST: break; default: feedBack.Add(string.Format("Unknown action '{0}' - no processing performed", row[_COL_ACTION].ToString())); continue; } bool managedItemDefined = false; Guid managedItemID = Guid.Empty; try { DataTable dtMI = Business.ManagedItem.GetManagedItemByNumber(row[_COL_MI_NUMBER].ToString()); managedItemID = new Guid(dtMI.Rows[0][Data.DataNames._C_ManagedItemID].ToString()); managedItemDefined = !managedItemID.Equals(Guid.Empty); } catch (Exception ex) { feedBack.Add(string.Format("Unable to retrieve ManagedItem {0} - Error: {1}. ", row[_COL_MI_NUMBER].ToString(), ex.Message)); } if (managedItemDefined) { //TODO: If requested, input the config info - Default,xx,xx,xx,etc.... as separate columns //TODO: Need to change the BW Interface to output the config info for the upload as separate columns firstRow = !managedItemTracker.Contains(managedItemID); if (firstRow) { managedItemTracker.Add(managedItemID); managedItem = Business.ManagedItem.Get(managedItemID, true); } feedBack.AddRange(SetComplexListValues(managedItem, complexListName, _dtExcelData, row, firstRow)); } if (feedBack.Count == 0) { row[_COL_DO_NOT_OUTPUT] = "*"; row[_COL_ERRORS] = string.Empty; } else { row[_COL_DO_NOT_OUTPUT] = string.Empty; row[_COL_ERRORS] = string.Join("\n", feedBack.ToArray()); nRowsUnsuccessful++; feedBack = new List<string>(); feedBackExists = true; } nRowsTotal++; } } else { //Create a list of expected column headings for this template Guid sourceTemplateID = new Guid(ddlSourceTemplate.SelectedValue.ToString()); Business.Template template = new Business.Template(sourceTemplateID, Business.DefType.Final); DataTable dtTemplate = GetTemplateTable(template); List<string> templateColumns = new List<string>(dtTemplate.Rows.Count); foreach (DataColumn col in dtTemplate.Columns) templateColumns.Add(col.ColumnName); List<string> excelColumns = new List<string>(_dtExcelData.Rows.Count); foreach (DataColumn col in _dtExcelData.Columns) excelColumns.Add(col.ColumnName); //Ensure that the Excel contains the 'required' columns... List<string> requiredColumns = new List<string>(); if (!excelColumns.Contains(_COL_ACTION)) requiredColumns.Add(_COL_ACTION); if (!excelColumns.Contains(_COL_MI_NUMBER)) requiredColumns.Add(_COL_MI_NUMBER); if (!excelColumns.Contains(_COL_ACTIVE_WF)) requiredColumns.Add(_COL_ACTIVE_WF); if (!excelColumns.Contains(_COL_ACTIVE_WF_STATE)) requiredColumns.Add(_COL_ACTIVE_WF_STATE); if (!excelColumns.Contains(_COL_OWNING_FAC_ID)) requiredColumns.Add(_COL_OWNING_FAC_ID); if (requiredColumns.Count > 0) errors.Add(string.Format("The following required columns were not found in the excel file: {0}. ", string.Join(",", requiredColumns.ToArray()).TrimEnd(','))); if (!CompareLists(templateColumns, excelColumns, skipColumns)) { errors.Add("There was a mismatch between the excel file and the template..."); string columnListing = string.Empty; for (int index = 0; index < excelColumns.Count; index++) { if (index == excelColumns.Count - 1) columnListing += string.Format("'{0}'", excelColumns[index]); else columnListing += string.Format("'{0}',\\n", excelColumns[index]); } errors.Add(string.Format("The following excel columns were not found in the template:\\n{0}. ", columnListing).TrimEnd(new char[]{'\\','n'})); } if (errors.Count > 0) { RegisterAlert(string.Join("\\n", errors.ToArray())); return; } //Process Business.ITATSystem itatSystem = null; Business.Template destinationTemplate = null; if (ddlDestinationTemplate.SelectedIndex > 0) { Guid destinationTemplateID = new Guid(ddlDestinationTemplate.SelectedValue); if (!sourceTemplateID.Equals(destinationTemplateID)) { destinationTemplate = new Business.Template(destinationTemplateID, Business.DefType.Final); } } for (int index = _ROW_FIRST_DATA; index < _dtExcelData.Rows.Count; index++) { bool success = false; DataRow row = _dtExcelData.Rows[index]; primaryFacilityID = null; string owningFacilityID = row[_COL_OWNING_FAC_ID].ToString(); if (!string.IsNullOrEmpty(owningFacilityID)) primaryFacilityID = int.Parse(owningFacilityID); switch (row[_COL_ACTION].ToString()) { case _ACTION_INSERT: feedBack.AddRange(InsertManagedItem(updateDatabase, sourceTemplateID, primaryFacilityID, _dtExcelData, row, out success)); break; case _ACTION_UPDATE: if (itatSystem == null) itatSystem = Business.ITATSystem.Get(new Guid(ddlSystem.SelectedValue)); feedBack.AddRange(UpdateManagedItem(updateDatabase, itatSystem, sourceTemplateID, destinationTemplate, ddlSystem.SelectedItem.Text, _dtExcelData, row)); break; case _ACTION_UPDATE_COMPLEX_LIST: feedBack.Add(string.Format("Action '{0}' was requested, but will not be performed", row[_COL_ACTION].ToString())); break; case _ACTION_DELETE: if (itatSystem == null) itatSystem = Business.ITATSystem.Get(new Guid(ddlSystem.SelectedValue)); feedBack.AddRange(DeleteManagedItem(updateDatabase, itatSystem, row)); break; default: feedBack.Add(string.Format("Unknown action '{0}' - no processing performed", row[_COL_ACTION].ToString())); break; } if (feedBack.Count == 0) { row[_COL_DO_NOT_OUTPUT] = "*"; row[_COL_ERRORS] = string.Empty; } else { row[_COL_DO_NOT_OUTPUT] = string.Empty; row[_COL_ERRORS] = string.Join("\n", feedBack.ToArray()); if (!success) nRowsUnsuccessful++; feedBack = new List<string>(); feedBackExists = true; } nRowsTotal++; } } confirmationMessage.Add(string.Format("\t{0:D5}\t\tRow{1} Successful", nRowsTotal - nRowsUnsuccessful, nRowsTotal - nRowsUnsuccessful == 1 ? string.Empty : "s")); confirmationMessage.Add(string.Format("\t{0:D5}\t\tRow{1} Unsuccessful", nRowsUnsuccessful, nRowsUnsuccessful == 1 ? string.Empty : "s")); confirmationMessage.Add("\t---------------------"); confirmationMessage.Add(string.Format("\t{0:D5}\t\tRow{1} Total", nRowsTotal, nRowsTotal == 1 ? string.Empty : "s")); if (feedBackExists) { confirmationMessage.Add(string.Empty); confirmationMessage.Add("\tPlease click button 'Export Feedback Excel' for more information"); } divConfirmationMessage.Visible = true; txtConfirmationMessage.Text = string.Join("\r\n", confirmationMessage.ToArray()); btnExportFeedbackExcel.Visible = feedBackExists; }
public bool DefineTerms(SearchResults searchResults) { //Get a unique collection of Templates from the search results ManagedItems List<Template> templates = new List<Template>(); foreach (SearchResultItem searchResultItem in searchResults) { Predicate<Template> p = delegate(Template t) { return t.ID == searchResultItem.TemplateId; }; Template foundTemplate = templates.Find(p); if (foundTemplate == null) { Template template = new Business.Template(searchResultItem.TemplateId, DefType.Final); templates.Add(template); } } //Get a unique collection of Terms from the list of Templates List<Term> terms = new List<Term>(); foreach (Template template in templates) { foreach (Term templateTerm in template.BasicTerms) { //exclude External Terms from this list switch (templateTerm.TermType) { case TermType.None: break; default: Predicate<Term> p = delegate(Term t) { return ((t.Name == templateTerm.Name) && (t.TermType == templateTerm.TermType)); }; Term foundTerm = terms.Find(p); if (foundTerm == null) terms.Add(templateTerm); break; } } } //Now build the _reportTerms collection. If it was previously defined, want to keep the original //order, but also want to incorporate any new basic-terms found in the 'terms' collection. if (_reportTerms != null) { List<ReportTerm> newReportTerms = new List<ReportTerm>(terms.Count); foreach (ReportTerm reportTerm in _reportTerms) { if (ReportTerm.GetTermType(reportTerm.ReportTermType) == null) { //This is a 'special' term - so keep it newReportTerms.Add(reportTerm); } else { TermType termType = (TermType)Enum.Parse(typeof(TermType), ReportTerm.GetTermType(reportTerm.ReportTermType)); Predicate<Term> p = delegate(Term t) { return ((t.Name == reportTerm.Name) && (t.TermType == termType)); }; Term foundTerm = terms.Find(p); if (foundTerm != null) { //This is a reportTerm found in the basic terms, so keep it. newReportTerms.Add(reportTerm); terms.Remove(foundTerm); } else { //This report term was not found in the basic terms collection, so it will not be saved. //TODO - In the future, may want to warn the user that this is the case. } } } //All done - now add new ReportTerms for all the basic terms that are left (not previously found in ReportTerms) foreach (Term term in terms) { if (ReportTerm.GetReportTermType(term.TermType) != ReportTermType.NotReported) newReportTerms.Add(new ReportTerm(null, term)); } _reportTerms = newReportTerms; } else { //Convert the unique list of BasicTerms into a list of ReportTerms _reportTerms = CreateReportTerms(null,terms, null, null, null); } SetDisplayNames(); return true; }
protected void ddlSystem_SelectedIndexChanged(object sender, EventArgs e) { if (ddlSystem.SelectedIndex > 0) { using (DataTable dt = Business.Template.GetActiveTemplates(new Guid(ddlSystem.SelectedValue))) { ddlSourceTemplate.DataSource = dt; ddlSourceTemplate.DataTextField = "TemplateName"; ddlSourceTemplate.DataValueField = "TemplateID"; ddlSourceTemplate.DataBind(); } ddlSourceTemplate.Items.Insert(0, new ListItem("(Please select a template)", string.Empty)); //Check to see if the system has Retro enabled divDestinationTemplate.Visible = false; Business.ITATSystem itatSystem = Business.ITATSystem.Get(new Guid(ddlSystem.SelectedValue)); if (itatSystem.AllowRetro) { divDestinationTemplate.Visible = true; using (DataTable dtDB = Business.Template.GetActiveTemplates(new Guid(ddlSystem.SelectedValue))) { DataTable dtSource = new DataTable(); dtSource.Columns.Add(Data.DataNames._C_TemplateName); dtSource.Columns.Add(Data.DataNames._C_TemplateID); foreach (DataRow dr in dtDB.Rows) { Business.Template template = new Business.Template(new Guid(dr[Data.DataNames._C_TemplateID].ToString()), Business.DefType.Final); if (template.RetroModel != Business.Retro.RetroModel.Off) { DataRow drSource = dtSource.NewRow(); drSource[Data.DataNames._C_TemplateName] = dr[Data.DataNames._C_TemplateName]; drSource[Data.DataNames._C_TemplateID] = dr[Data.DataNames._C_TemplateID]; dtSource.Rows.Add(drSource); } } ddlDestinationTemplate.DataSource = dtSource; ddlDestinationTemplate.DataTextField = Data.DataNames._C_TemplateName; ddlDestinationTemplate.DataValueField = Data.DataNames._C_TemplateID; ddlDestinationTemplate.DataBind(); } ddlDestinationTemplate.Items.Insert(0, new ListItem("(Please select a template)", string.Empty)); } else { ddlDestinationTemplate.Items.Clear(); } } else { ddlSourceTemplate.Items.Clear(); ddlDestinationTemplate.Items.Clear(); } }
protected void btnExportTemplateExcel_Click(object sender, EventArgs e) { if (ddlSystem.SelectedIndex == 0) { RegisterAlert("A valid system must be selected."); return; } string templateGuid = null; string templateName = string.Empty; if (divDestinationTemplate.Visible && ddlDestinationTemplate.SelectedIndex > 0) { templateGuid = ddlDestinationTemplate.SelectedValue.ToString(); templateName = ddlDestinationTemplate.SelectedItem.Text; } if (string.IsNullOrEmpty(templateGuid)) { if (ddlSourceTemplate.SelectedIndex == 0) { if (divDestinationTemplate.Visible) RegisterAlert("A valid source or destination template must be selected."); else RegisterAlert("A valid source template must be selected."); return; } templateGuid = ddlSourceTemplate.SelectedValue.ToString(); templateName = ddlSourceTemplate.SelectedItem.Text; } Business.Template template = new Business.Template(new Guid(templateGuid), Business.DefType.Final); DataTable dtTemplate = GetTemplateTable(template); string excelFileName = string.Format("[{0}]{1}", ddlSystem.SelectedItem.Text, templateName); ExportToExcel(excelFileName, ConvertTableToExcelString(dtTemplate, true, null, null)); }
public static void GetTermAndFieldNameLookup(Guid systemID, ref Dictionary<Guid, Dictionary<Guid, string>> termNameLookup, ref Dictionary<Guid /*TemplateID*/, Dictionary<Guid /*ComplexListID*/, Dictionary<Guid /*FieldID*/, string /*FieldName*/>>> fieldNameLookup) { termNameLookup = new Dictionary<Guid, Dictionary<Guid, string>>(); fieldNameLookup = new Dictionary<Guid, Dictionary<Guid, Dictionary<Guid, string>>>(); DataSet ds = GetActiveSearchOnlySystemTemplateList(systemID); foreach (DataRow rowTemplate in ds.Tables[0].Rows) { Guid templateID = (Guid)rowTemplate["TemplateID"]; string templateName = (string)rowTemplate["TemplateName"]; Business.Template template = new Business.Template(templateID, DefType.Final); termNameLookup.Add(templateID, new Dictionary<Guid, string>()); fieldNameLookup.Add(templateID, new Dictionary<Guid,Dictionary<Guid,string>>()); foreach (Business.Term term in template.BasicTerms) { termNameLookup[templateID].Add(term.ID, term.Name); } foreach (Business.Term complexList in template.ComplexLists) { termNameLookup[templateID].Add(complexList.ID, complexList.Name); fieldNameLookup[templateID].Add(complexList.ID, new Dictionary<Guid,string>()); foreach (Business.ComplexListField clf in (complexList as Business.ComplexList).Fields) { fieldNameLookup[templateID][complexList.ID].Add(clf.ID, clf.Name); } } } }
public static void GetTermAndFieldIDLookup(Guid systemID, ref Dictionary<Guid, Dictionary<string, Guid>> termIDLookup, ref Dictionary<Guid /*TemplateID*/, Dictionary<Guid /*ComplexListID*/, Dictionary<string /*FieldName*/, Guid /*FieldID*/>>> fieldIDLookup) { termIDLookup = new Dictionary<Guid, Dictionary<string, Guid>>(); fieldIDLookup = new Dictionary<Guid, Dictionary<Guid, Dictionary<string, Guid>>>(); DataSet ds = GetActiveSearchOnlySystemTemplateList(systemID); foreach (DataRow rowTemplate in ds.Tables[0].Rows) { List<string> repeatedTermNames = new List<string>(); Guid templateID = (Guid)rowTemplate["TemplateID"]; string templateName = (string)rowTemplate["TemplateName"]; Business.Template template = new Business.Template(templateID, DefType.Final); termIDLookup.Add(templateID, new Dictionary<string,Guid>()); fieldIDLookup.Add(templateID, new Dictionary<Guid,Dictionary<string,Guid>>()); foreach (Business.Term term in template.BasicTerms) { if (termIDLookup[templateID].ContainsKey(term.Name)) { if (!repeatedTermNames.Contains(term.Name)) repeatedTermNames.Add(term.Name); } else termIDLookup[templateID].Add(term.Name, term.ID); } foreach (Business.Term complexList in template.ComplexLists) { if (termIDLookup[templateID].ContainsKey(complexList.Name)) { if (!repeatedTermNames.Contains(complexList.Name)) repeatedTermNames.Add(complexList.Name); } else { termIDLookup[templateID].Add(complexList.Name, complexList.ID); fieldIDLookup[templateID].Add(complexList.ID, new Dictionary<string, Guid>()); foreach (Business.ComplexListField clf in (complexList as Business.ComplexList).Fields) { fieldIDLookup[templateID][complexList.ID].Add(clf.Name, clf.ID); } } } if (repeatedTermNames.Count > 1) throw new Exception(string.Format("For Template {0} the following term names were repeated: {1}", templateName, string.Join(",", repeatedTermNames.ToArray()).TrimEnd(','))); } }
private void LoadTermList() { lstTerms.Items.Clear(); lvSelectedTerms.Items.Clear(); if (lstSelectedTemplates.Items.Count > 0) { List<Template> templates = new List<Template>(); foreach (ListItem li in lstSelectedTemplates.Items) { Predicate<Template> p = delegate(Template t) { return t.ID == new Guid(li.Value); }; Template foundTemplate = templates.Find(p); if (foundTemplate == null) { Template template = new Business.Template(new Guid(li.Value), DefType.Final); templates.Add(template); } } //Get a unique collection of Terms from the list of Templates // listTerms = (List<DataStoreField>)ViewState[LIST_TERMS]; listTerms = null; foreach (Template template in templates) { foreach (Term templateTerm in template.BasicTerms) { //exclude External Terms from this list if (templateTerm.IsStored) { Predicate<DataStoreField> p = delegate(DataStoreField t) { return ((t.Name.Equals(templateTerm.Name))); }; DataStoreField foundTerm = listTerms.Find(p); if (foundTerm == null) { switch (templateTerm.TermType) { case TermType.ComplexList: foreach (string termname in templateTerm.StoreColumns) { listTerms.Add(new DataStoreField(TermStore.GetTermConcatenatedName(template.Name, templateTerm.Name, termname), termname, templateTerm.RequiredSize, templateTerm.TermType, false)); } break; case TermType.MSO: foreach (string termname in templateTerm.StoreColumns) { listTerms.Add(new DataStoreField(TermStore.GetTermConcatenatedName(template.Name, templateTerm.Name, termname), termname, templateTerm.RequiredSize, templateTerm.TermType, false)); } break; case TermType.External: foreach (string termname in templateTerm.StoreColumns) { listTerms.Add(new DataStoreField(TermStore.GetTermConcatenatedName(template.Name, templateTerm.Name, termname), termname, templateTerm.RequiredSize, templateTerm.TermType, false)); } break; case TermType.Text: listTerms.Add(new DataStoreField(TermStore.GetTermConcatenatedName(template.Name, templateTerm.Name, ""), templateTerm.Name, templateTerm.RequiredSize, templateTerm.TermType, false)); break; default: listTerms.Add(new DataStoreField(TermStore.GetTermConcatenatedName(template.Name, templateTerm.Name, ""), templateTerm.Name, null, templateTerm.TermType, false)); break; } } } } foreach (Term complextListTerm in template.ComplexLists) { if (complextListTerm.IsStored) { Predicate<DataStoreField> p = delegate(DataStoreField t) { return ((t.Name.Equals(complextListTerm.Name))); }; DataStoreField foundTerm = listTerms.Find(p); if (foundTerm == null) { switch (complextListTerm.TermType) { case TermType.ComplexList: //DataStoreField foundTerm = listTerms.Find(p); foreach (ComplexListField field in ((ComplexList)complextListTerm).Fields) { if(field.FilterTerm.TermType == TermType.Text) listTerms.Add(new DataStoreField(TermStore.GetTermConcatenatedName(template.Name, complextListTerm.Name, field.Name), field.Name, complextListTerm.RequiredSize, field.FilterTerm.TermType,((TextTerm)field.FilterTerm).Format, false)); else listTerms.Add(new DataStoreField(TermStore.GetTermConcatenatedName(template.Name, complextListTerm.Name, field.Name), field.Name, complextListTerm.RequiredSize, field.FilterTerm.TermType, false)); } break; } } } } } IList<string> lstStandardColumn = Enum.GetNames(typeof(SystemStore.StandardColumn)).ToList(); foreach (string standardColum in lstStandardColumn) { listTerms.Add(new DataStoreField(standardColum, standardColum, null, TermType.None, true)); } List<DataStoreField> selectedTerms = SelectedTerms; //This logic removes the selected terms that are no longer found in the template. selectedTerms = listTerms.Intersect(selectedTerms, new DataStoreFieldComparer()).OrderBy(dsf => selectedTerms.FindIndex(st => st.Name == dsf.Name)).ToList(); List<DataStoreField> updatedSelectedTerms = SelectedTerms; updatedSelectedTerms = updatedSelectedTerms.Except(selectedTerms, new DataStoreFieldComparer()).ToList(); //This message is no longer needed - the selected terms must be removed by the user whenm deleting the term from the template. //string erroneousterms = ""; //if (updatedSelectedTerms.Count > 0) //{ // foreach (DataStoreField udsf in updatedSelectedTerms) // { // erroneousterms = erroneousterms + string.Format("- {0} \\n", udsf.Name); // } // RegisterAlert("Following Selected Terms are changed/removed from selected templates \\n" + erroneousterms); //} selectedTerms = selectedTerms.Select(dsf => { dsf.Length = SelectedTerms.Find(x => x.Name == dsf.Name).Length; dsf.Alias = SelectedTerms.Find(x => x.Name == dsf.Name).Alias; dsf.SortSequence = SelectedTerms.Find(x => x.Name == dsf.Name).SortSequence; return dsf; }).ToList(); //listTerms.RemoveAll(t => selectedTerms.Exists(x => x.Name.Equals(t.Name))); lstTerms.DataSource = listTerms; lstTerms.DataValueField = FIELD_NAME; lstTerms.DataTextField = FIELD_NAME; lstTerms.DataBind(); lvSelectedTerms.DataSource = selectedTerms.OrderBy(d => d.SortSequence); lvSelectedTerms.DataBind(); SelectedTerms = selectedTerms; ViewState[LIST_TERMS] = listTerms; SortlistItems(lstTerms); } else { IList<string> lstStandardColumn = Enum.GetNames(typeof(SystemStore.StandardColumn)).ToList(); foreach (string standardColum in lstStandardColumn) { listTerms.Add(new DataStoreField(standardColum, standardColum, null, TermType.None, true)); } //listTerms = null; lstTerms.DataSource = listTerms; lstTerms.DataValueField = FIELD_NAME; lstTerms.DataTextField = FIELD_NAME; lstTerms.DataBind(); lvSelectedTerms.DataSource = SelectedTerms.Intersect(listTerms, new DataStoreFieldComparer()).ToList(); lvSelectedTerms.DataBind(); ViewState[LIST_TERMS] = listTerms; } }