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;
        }
Пример #2
0
		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));
        }
Пример #5
0
        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);
                    }
                }
            }
        }
Пример #6
0
        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;
            }
        }