public XmlDocument GetMetadataReportWCategoryName(string mdXml, MetadataElementType mdType) { XmlDocument RetVal = new XmlDocument(); RetVal.XmlResolver = null; RetVal.LoadXml(mdXml); Dictionary <string, string> MDCatGIDandNameColl = null; try { XmlNamespaceManager nsManager = new XmlNamespaceManager(RetVal.NameTable); nsManager.AddNamespace("generic", "http://www.sdmx.org/resources/sdmxml/schemas/v2_1/data/generic"); nsManager.AddNamespace("message", "http://www.sdmx.org/resources/sdmxml/schemas/v2_1/message"); //-- Get Metadata Name and CategoryID MDCatGIDandNameColl = this.GetMetadataCategoryNameGIDCollection(mdType); XmlNodeList NodeListObj = RetVal.SelectNodes(METADATASET_XPATH, nsManager); foreach (XmlNode Node in NodeListObj[0].ChildNodes) { if (Node.Name == REPORT_ELEMENT) { this.AddNameAttribteInAttributeSet(RetVal, MDCatGIDandNameColl, Node); } } } catch (Exception ex) { throw ex; } return(RetVal); }
private Dictionary <string, string> GetMetadataCategoryNameGIDCollection(MetadataElementType mdType) { Dictionary <string, string> RetVal = new Dictionary <string, string>(); DataTable Table = this.DBConnection.ExecuteDataTable(this.DBQueries.Metadata_Category.GetMetadataCategories(FilterFieldType.None, string.Empty)); if (mdType == MetadataElementType.Indicator) { Table.DefaultView.RowFilter = Metadata_Category.CategoryType + "='I'"; } else if (mdType == MetadataElementType.Area) { Table.DefaultView.RowFilter = Metadata_Category.CategoryType + "='A'"; } else { Table.DefaultView.RowFilter = Metadata_Category.CategoryType + "='S'"; } Table = Table.DefaultView.ToTable(); foreach (DataRow Row in Table.Rows) { if (!RetVal.ContainsKey(Convert.ToString(Row[Metadata_Category.CategoryGId]))) { RetVal.Add(Convert.ToString(Row[Metadata_Category.CategoryGId]), Convert.ToString(Row[Metadata_Category.CategoryName])); } } return(RetVal); }
/// <summary> /// Returns categories table from database for the given metadata type /// </summary> /// <param name="metadataType"></param> /// <returns></returns> private DataTable GetCategoryDataTableFrmDB(MetaDataType metadataType) { DataTable RetVal = null; MetadataElementType MDElementType = MetadataElementType.Indicator; string ColumnInfo = string.Empty; switch (metadataType) { case MetaDataType.Indicator: MDElementType = MetadataElementType.Indicator; break; case MetaDataType.Map: MDElementType = MetadataElementType.Area; break; case MetaDataType.Source: MDElementType = MetadataElementType.Source; break; default: break; } RetVal = this.DBConnection.ExecuteDataTable(this.DBQueries.Metadata_Category.GetMetadataCategories(FilterFieldType.Type, DIQueries.MetadataElementTypeText[MDElementType])); return(RetVal); }
/// <summary> /// Updates ElementXslt table /// </summary> /// <param name="elementNid"></param> /// <param name="mdElementType"></param> /// <returns></returns> protected bool UpdateElementXsltTable(int elementNid, MetadataElementType mdElementType, string mdXslTtype) { bool RetVal = false; int XsltNid = 0; int ElementXsltNid = 0; try { // 1. get xslt nid from XSLT table XsltNid = this.GetXslNidFrmXSLTTable(mdXslTtype); if (XsltNid > 0) { // 2. check record exists in Element_Xslt table or not ElementXsltNid = this.GetElementXsltNidFrmDB(mdElementType, elementNid); // 3. If not then insert record if (ElementXsltNid <= 0) { this.DBConnection.ExecuteNonQuery(DevInfo.Lib.DI_LibDAL.Queries.Xslt.Insert.InsertElementXSLT(this.DBQueries.DataPrefix, elementNid, mdElementType, XsltNid)); } else { // 4. if exists then update record this.DBConnection.ExecuteNonQuery(DevInfo.Lib.DI_LibDAL.Queries.Xslt.Update.UpdateElementXSLT(this.DBQueries.DataPrefix, XsltNid, elementNid, mdElementType)); } RetVal = true; } } catch (Exception ex) { ExceptionFacade.ThrowException(ex); } return(RetVal); }
/// <summary> /// Import Metdata report /// </summary> /// <param name="xmlFileNameWPath"></param> /// <param name="mdType"></param> /// <param name="selectedNidInTrgDatabase"></param> /// <param name="selectedFiles"></param> /// <param name="XsltFolderPath"></param> public void ImportMetadataFromXML(string xmlString, MetadataElementType metadataElementType, int selectedNidInTrgDatabase, string XsltFolderPath) { XmlDocument XmlDoc = new XmlDocument(); DI7MetadataCategoryBuilder MDBuilder = new DI7MetadataCategoryBuilder(this.DBConnection, this.DBQueries); XmlDoc.LoadXml(xmlString); try { //-- check that Value/Name attribute exists or not if (this.IsMetadataNameAttributeExists(XmlDoc)) { this.CheckNInsertMetadataReportXml(XmlDoc, selectedNidInTrgDatabase, true, DIQueries.MetadataElementTypeText[metadataElementType]); } else { // if not then use ID for mapping . // If category ID exists in trg database then only import metadata report this.CheckNInsertMetadataReportXml(XmlDoc, selectedNidInTrgDatabase, false, DIQueries.MetadataElementTypeText[metadataElementType]); } } catch (Exception ex) { throw ex; } }
private DataTable GetCategoryDataTable(MetadataElementType elementType) { DataTable RetVal = null; RetVal = this.DBConnection.ExecuteDataTable(this.DBQueries.Metadata_Category.GetMetadataCategoriesForEditor(FilterFieldType.Type, DIQueries.MetadataElementTypeText[elementType])); return(RetVal); }
/// <summary> /// Returns sql query to delete XsltNid from UT_Element_XSLT table /// </summary> /// <param name="elementNIds"></param> /// <param name="elementType"></param> /// <returns></returns> public string DeleteElementXSLT( string elementNIds, MetadataElementType elementType) { string RetVal = string.Empty; RetVal = "DELETE FROM " + this.TablesName.ElementXSLT + " WHERE " + DIColumns.EelementXSLT.ElementNId + " IN (" + elementNIds + " ) AND " + DIColumns.EelementXSLT.ElementType + "=" + DIQueries.MetadataElementTypeText[elementType]; return RetVal; }
public static string DeleteMetadataReportByCategory(DITables tables, MetadataElementType categoryType) { string RetVal=string.Empty; RetVal = "DELETE MR.* FROM " + tables.MetadataCategory + " MC INNER JOIN " + tables.MetadataReport + " MR ON MC." + DIColumns.Metadata_Category.CategoryNId + " = MR." + DIColumns.MetadataReport.CategoryNid + " where MC." + DIColumns.Metadata_Category.CategoryType + "=" + DIQueries.MetadataElementTypeText[categoryType] +";"; return RetVal; }
/// <summary> /// Returns sql query to insert element's xslt relationship into UT_Element_XSLT table /// </summary> /// <param name="dataprefix"></param> /// <param name="elementNId"></param> /// <param name="elementType"></param> /// <param name="XsltNid"></param> /// <returns></returns> public static string InsertElementXSLT(string dataprefix, int elementNId, MetadataElementType elementType, int XsltNid) { string RetVal = string.Empty; RetVal = "insert into " + dataprefix + Insert.ElementTableName + "(" + DIColumns.EelementXSLT.ElementNId + "," + DIColumns.EelementXSLT.ElementType + "," + DIColumns.XSLT.XSLTNId + ") values(" + elementNId + "," + DIQueries.MetadataElementTypeText[elementType] + "," + XsltNid + ")"; return RetVal; }
private DataTable GetMetadataReportsTableFrmDB(int elementNid, MetadataElementType elementType) { DataTable RetVal = null; // get indicator metadata from metadatareport table RetVal = this.DBConnection.ExecuteDataTable(this.DBQueries.MetadataReport.GetMetadataReportsByTargetNid(elementNid.ToString(), elementType)); return(RetVal); }
/// <summary> /// Returns sql query to update XsltNid into UT_Element_XSLT table /// </summary> /// <param name="dataprefix"></param> /// <param name="XSLTNid"></param> /// <param name="elementNId"></param> /// <param name="elementType"></param> /// <returns></returns> public static string UpdateElementXSLT(string dataprefix, int XSLTNid, int elementNId,MetadataElementType elementType) { string RetVal = string.Empty; RetVal = "Update " + dataprefix+ Update.ElementTableName + " set "+ DIColumns.EelementXSLT.XSLTNId +" =" + XSLTNid + " WHERE "+ DIColumns.EelementXSLT.ElementNId+"=" + elementNId+ " AND "+DIColumns.EelementXSLT.ElementType +"="+ DIQueries.MetadataElementTypeText[elementType] ; return RetVal; }
/// <summary> /// Deletes metadata information /// </summary> /// <param name="elementNIds"></param> /// <param name="elementType"></param> public void DeleteMetadata(string elementNIds, MetadataElementType elementType) { try { this.DBConnection.ExecuteNonQuery(this.DBQueries.Delete.Xslt.DeleteElementXSLT(elementNIds, elementType)); } catch (Exception ex) { ExceptionFacade.ThrowException(ex); } }
protected int GetElementXsltNidFrmDB(MetadataElementType mdElementtype, int elementNid) { int RetVal = -1; foreach (DataRow Row in this.DBConnection.ExecuteDataTable(this.DBQueries.Xslt.GetElementXSLTTable(elementNid.ToString(), mdElementtype)).Rows) { RetVal = Convert.ToInt32(Row[EelementXSLT.ElementXSLTNId]); break; } return(RetVal); }
/// <summary> /// Returns sql query to get ElementXSLT table for a given elementNId and ElementType /// </summary> /// <param name="elementNId">elementNId </param> /// <param name="metadataElementType">Indicator / Area / Source</param> /// <returns></returns> public string GetElementXSLTTable(string elementNId, MetadataElementType metadataElementType) { string RetVal = string.Empty; StringBuilder sbQuery = new StringBuilder(); sbQuery.Append("SELECT * "); sbQuery.Append(" FROM " + this.TablesName.ElementXSLT + " "); sbQuery.Append(" WHERE "); sbQuery.Append(DIColumns.EelementXSLT.ElementType + " = " + DIQueries.MetadataElementTypeText[metadataElementType]); sbQuery.Append(" AND " + DIColumns.EelementXSLT.ElementNId + " IN (" + elementNId + ")"); RetVal = sbQuery.ToString(); return RetVal; }
/// <summary> /// Get StyleSheet details from XSLT table for a given elementNId and ElementType /// </summary> /// <param name="elementNId">elementNId for which icon is to be extracted</param> /// <param name="metadataElementType">Indicator / Area / Source</param> /// <returns></returns> public string GetXSLT(string elementNId, MetadataElementType metadataElementType) { string RetVal = string.Empty; StringBuilder sbQuery = new StringBuilder(); sbQuery.Append("SELECT X." + DIColumns.XSLT.XSLTNId + ",EX." + DIColumns.EelementXSLT.ElementNId + ",X." + DIColumns.XSLT.XSLTText + ",X." + DIColumns.XSLT.XSLTFile); sbQuery.Append(" FROM " + this.TablesName.XSLT + " AS X," + this.TablesName.ElementXSLT + " AS EX"); sbQuery.Append(" WHERE X." + DIColumns.XSLT.XSLTNId + " = EX." + DIColumns.EelementXSLT.XSLTNId); sbQuery.Append(" AND EX." + DIColumns.EelementXSLT.ElementType + " = " + DIQueries.MetadataElementTypeText[metadataElementType]); if (elementNId.Trim().Length >= 0) { sbQuery.Append(" AND EX." + DIColumns.EelementXSLT.ElementNId + " IN (" + elementNId + ")"); } RetVal = sbQuery.ToString(); return RetVal; }
void MetadataConverter_WrongMetdataFoundEvent(MetadataElementType elementType, string name, string GID) { // check n create list object if (this._WrongMetadataElementList == null) { this._WrongMetadataElementList = new SortedDictionary <MetadataElementType, List <string> >(); } // check n create element type key into dictionary object if (!this._WrongMetadataElementList.ContainsKey(elementType)) { this._WrongMetadataElementList.Add(elementType, new List <string>()); } // add name into list if doesnt exist if (!this._WrongMetadataElementList[elementType].Contains(name)) { this._WrongMetadataElementList[elementType].Add(name); } }
private void UpdateMetadataInfo(DIQueries queries, string targetNid, MetadataElementType categoryType, String metadataCategoryInfo) { switch (categoryType) { case MetadataElementType.Indicator: this._DBConnection.ExecuteNonQuery("update " + queries.TablesName.Indicator + " set " + Indicator.IndicatorInfo + "='" + DIQueries.RemoveQuotesForSqlQuery(metadataCategoryInfo) + "'where " + Indicator.IndicatorNId + "=" + targetNid); break; case MetadataElementType.Area: this._DBConnection.ExecuteNonQuery("update " + queries.TablesName.AreaMapMetadata + " set " + Area_Map_Metadata.MetadataText + "='" + DIQueries.RemoveQuotesForSqlQuery(metadataCategoryInfo) + "' where " + Area_Map_Layer.LayerNId + "=" + targetNid); break; case MetadataElementType.Source: this._DBConnection.ExecuteNonQuery("update " + queries.TablesName.IndicatorClassifications + " set " + IndicatorClassifications.ICInfo + "='" + DIQueries.RemoveQuotesForSqlQuery(metadataCategoryInfo) + "'where " + IndicatorClassifications.ICNId + "=" + targetNid); break; default: break; } }
private void UpdateMetadataInfoByCategoryType(MetadataElementType categoryType, MetadataCategoryBuilder metadataCategoryBuilder, DIQueries queries) { List <string> TargetNids; DataTable SrcCategoryTable = null; StringBuilder Metadata_Category_Info = new StringBuilder(); SrcCategoryTable = this._DBConnection.ExecuteDataTable(queries.MetadataReport.GetAllMetadataReportsByCategoryType(categoryType)); TargetNids = DICommon.GetCommaSeperatedListOfGivenColumn(SrcCategoryTable, MetadataReport.TargetNid, false, string.Empty); //for every target like for indicator one there is many metadata category may be definition, Classification, Method of Computation foreach (string targetNid in TargetNids) { Metadata_Category_Info.Remove(0, Metadata_Category_Info.Length); //Step 1 Create metadata Info in xml format this.CreateMetadataXML(SrcCategoryTable.Select(MetadataReport.TargetNid + "='" + targetNid + "'"), ref Metadata_Category_Info, metadataCategoryBuilder, DIQueries.MetadataElementTypeText[categoryType].Trim("'".ToCharArray())); //Step 2 Update metadata Info in xml format this.UpdateMetadataInfo(queries, targetNid, categoryType, Metadata_Category_Info.ToString()); } }
public void DeleteMetadataReports(MetadataElementType categoryType) { DITables TableNames; try { // Step1: Delete records from metadata Report table foreach (DataRow Row in this.DBConnection.DILanguages(this.DBQueries.DataPrefix).Rows) { // Get table name TableNames = new DITables(this.DBQueries.DataPrefix, Row[Language.LanguageCode].ToString()); // delete records this.DBConnection.ExecuteNonQuery(DevInfo.Lib.DI_LibDAL.Queries.MetadataReport.Delete.DeleteMetadataReportByCategory(TableNames, categoryType)); } } catch (Exception ex) { throw new ApplicationException(ex.ToString()); } }
private string GetCategoryTypeText(MetadataElementType categoryMaskType) { string RetVal = string.Empty; switch (categoryMaskType) { case MetadataElementType.Indicator: RetVal = "I"; break; case MetadataElementType.Area: RetVal = "A"; break; case MetadataElementType.Source: RetVal = "S"; break; } return(RetVal); }
public void DeleteMetadataReports(MetadataElementType categoryType) { DITables TableNames; try { // Step1: Delete records from metadata Report table foreach (DataRow Row in this.DBConnection.DILanguages(this.DBQueries.DataPrefix).Rows) { // Get table name TableNames = new DITables(this.DBQueries.DataPrefix, Row[Language.LanguageCode].ToString()); // delete records this.DBConnection.ExecuteNonQuery(DevInfo.Lib.DI_LibDAL.Queries.MetadataReport.Delete.DeleteMetadataReportByCategory(TableNames, categoryType)); } } catch (Exception ex) { throw new ApplicationException(ex.ToString()); } }
/// <summary> /// Export metadata to excel file /// </summary> /// <param name="ExcelFilePath">Excel File Path to be written as export data</param> public void ExportMetaDataToExcel(string ExcelFilePath, MetadataElementType elementType, string elementName, string elementGId, int targetElementNID) { try { // --Open excel and get first worksheet this.DiExcel = new DIExcel(ExcelFilePath); MetadataSheet = DiExcel.GetWorksheet(0); // --Set Matadata Type in Cell 0,0 switch (elementType) { case MetadataElementType.Indicator: SetMetadataCommonCellValues(DILanguage.GetLanguageString("INDICATOR") + "-" + DILanguage.GetLanguageString("METADATA"), elementName, elementGId); break; case MetadataElementType.Area: SetMetadataCommonCellValues(DILanguage.GetLanguageString("AREA") + "-" + DILanguage.GetLanguageString("METADATA"), elementName, elementGId); break; case MetadataElementType.Source: SetMetadataCommonCellValues(DILanguage.GetLanguageString("SOURCE") + "-" + DILanguage.GetLanguageString("METADATA"), elementName, elementGId); break; default: break; } // --Load data from xml to excel file this.LoadData(elementType, targetElementNID); //-- Save excel this.DiExcel.Save(); } catch (Exception ex) { } }
/// <summary> /// Imports metadata from the source database into current database /// </summary> /// <param name="srcConnection"></param> /// <param name="srcQueries"></param> /// <param name="srcElementNid"></param> /// <param name="trgElementNid"></param> /// <param name="categoryType"></param> /// <param name="metadataType"></param> /// <param name="iconType"></param> public void ImportMetadata(DIConnection srcConnection, DIQueries srcQueries, int srcElementNid, int trgElementNid, MetadataElementType categoryType, MetaDataType metadataType, IconElementType iconType) { string SrcCategoryGID = string.Empty; string MetadataText = string.Empty; int TrgCategoryNid = 0; DataTable TrgCategoryTable = null; Dictionary <String, String> OldIconNIdnNewIconNId = new Dictionary <string, string>(); try { // Get target Category table TrgCategoryTable = this.DBConnection.ExecuteDataTable(this.DBQueries.Metadata_Category.GetMetadataCategories(FilterFieldType.Type, DIQueries.MetadataElementTypeText[categoryType])); // update metadata icon in DICon table OldIconNIdnNewIconNId = DIIcons.ImportElement(srcElementNid, trgElementNid, iconType, srcQueries, srcConnection, this.DBQueries, this.DBConnection); //get source metadata reports foreach (DataRow SrcRow in srcConnection.ExecuteDataTable(srcQueries.MetadataReport.GetMetadataReportsByTargetNid(srcElementNid.ToString(), categoryType)).Rows) { SrcCategoryGID = Convert.ToString(SrcRow[Metadata_Category.CategoryGId]); // check source category GID exists in current database // Import metadta report only if category exists in current database foreach (DataRow TrgCategoryRow in TrgCategoryTable.Select(Metadata_Category.CategoryGId + "='" + DIQueries.RemoveQuotesForSqlQuery(SrcCategoryGID) + "' ")) { MetadataText = Convert.ToString(SrcRow[MetadataReport.Metadata]); // Update IconNids in metadata if exists foreach (string OldIconName in OldIconNIdnNewIconNId.Keys) { MetadataText = MetadataText.Replace(OldIconName, OldIconNIdnNewIconNId[OldIconName].ToString()); } TrgCategoryNid = Convert.ToInt32(TrgCategoryRow[Metadata_Category.CategoryNId]); this.InsertORUpdateMetadataInfo(metadataType, TrgCategoryNid.ToString(), trgElementNid, MetadataText); } } } catch (Exception ex) { ExceptionHandler.ExceptionFacade.ThrowException(ex); } }
private void UpdateMetadataInfo(DIQueries queries, string targetNid, MetadataElementType categoryType, String metadataCategoryInfo) { switch (categoryType) { case MetadataElementType.Indicator: this._DBConnection.ExecuteNonQuery("update " + queries.TablesName.Indicator + " set " + Indicator.IndicatorInfo + "='" + DIQueries.RemoveQuotesForSqlQuery(metadataCategoryInfo) + "'where " + Indicator.IndicatorNId + "=" + targetNid); break; case MetadataElementType.Area: this._DBConnection.ExecuteNonQuery("update " + queries.TablesName.AreaMapMetadata + " set " + Area_Map_Metadata.MetadataText + "='" + DIQueries.RemoveQuotesForSqlQuery(metadataCategoryInfo) + "' where " + Area_Map_Layer.LayerNId + "=" + targetNid); break; case MetadataElementType.Source: this._DBConnection.ExecuteNonQuery("update " + queries.TablesName.IndicatorClassifications + " set " + IndicatorClassifications.ICInfo + "='" + DIQueries.RemoveQuotesForSqlQuery(metadataCategoryInfo) + "'where " + IndicatorClassifications.ICNId + "=" + targetNid); break; default: break; } }
/// <summary> /// Load Data into excel report file /// </summary> private void LoadData(MetadataElementType elementType,int elementNID) { string ParaNodeText = string.Empty; string ConcatenatedParaNodeText = string.Empty; DataTable CategoryTable = null; DataTable MetadataReportTable = null; string CategoryName = string.Empty; string CategoryNid = string.Empty; string MetadataText = string.Empty; string ReplaceableSymbol = "{{~}}"; string CategoryGID = string.Empty; try { // 1. Get category table from database where ispresentational is false CategoryTable = this.GetCategoryDataTable(elementType); // rearrange categories CategoryTable = DI7MetadataCategoryBuilder.RearrangeCategoryTableByCategoryOrder(CategoryTable); // 2. get metadata reports MetadataReportTable = this.GetMetadataReportsTableFrmDB(elementNID,elementType); // 3. Add Title // writes metadata values in excel report. this.WriteMetadataField(CategoryIndex, DILanguage.GetLanguageString("CATEGORY"), DILanguage.GetLanguageString("CATEGORY_GID")); //Write values to excel this.WriteMetadataValueToExcel(CategoryIndex, DILanguage.GetLanguageString("METADATA")); this.MetadataSheet.Cells[this._MetadataStartRowIndexInExl + CategoryIndex, 0, this._MetadataStartRowIndexInExl + CategoryIndex, 2].Font.Bold = true; this.MetadataSheet.Cells[this._MetadataStartRowIndexInExl + CategoryIndex, 0, this._MetadataStartRowIndexInExl + CategoryIndex, 2].Interior.Color = SpreadsheetGear.Drawing.Color.FromArgb(System.Drawing.Color.LightGray.ToArgb()); CategoryIndex++; //Iterate through category node foreach (DataRow CategoryRow in CategoryTable.Rows) { // 4.2 get category label form table CategoryName = Convert.ToString(CategoryRow[Metadata_Category.CategoryName]); CategoryNid = Convert.ToString(CategoryRow[Metadata_Category.CategoryNId]); CategoryGID = Convert.ToString(CategoryRow[Metadata_Category.CategoryGId]); // writes metadata values in excel report. this.WriteMetadataField(CategoryIndex, CategoryName,CategoryGID); // Get metadata report from metadata report table for the current category foreach (DataRow Row in MetadataReportTable.Select(MetadataReport.CategoryNid + "=" + CategoryNid)) { MetadataText = Convert.ToString(Row[MetadataReport.Metadata]).Replace(ReplaceableSymbol, Microsoft.VisualBasic.ControlChars.NewLine); //Write values to excel WriteMetadataValueToExcel(CategoryIndex, MetadataText); } CategoryIndex = CategoryIndex + 1; } } catch (Exception ex) { ExceptionHandler.ExceptionFacade.ThrowException(ex); } }
private DataTable GetCategoryDataTable( MetadataElementType elementType) { DataTable RetVal = null; RetVal = this.DBConnection.ExecuteDataTable(this.DBQueries.Metadata_Category.GetMetadataCategoriesForEditor(FilterFieldType.Type, DIQueries.MetadataElementTypeText[elementType])); return RetVal; }
public XmlDocument GetMetadataReportWCategoryName(string mdXml, MetadataElementType mdType) { XmlDocument RetVal = new XmlDocument(); RetVal.XmlResolver = null; RetVal.LoadXml(mdXml); Dictionary<string, string> MDCatGIDandNameColl = null; try { XmlNamespaceManager nsManager = new XmlNamespaceManager(RetVal.NameTable); nsManager.AddNamespace("generic", "http://www.sdmx.org/resources/sdmxml/schemas/v2_1/data/generic"); nsManager.AddNamespace("message", "http://www.sdmx.org/resources/sdmxml/schemas/v2_1/message"); //-- Get Metadata Name and CategoryID MDCatGIDandNameColl = this.GetMetadataCategoryNameGIDCollection(mdType); XmlNodeList NodeListObj = RetVal.SelectNodes(METADATASET_XPATH, nsManager); foreach (XmlNode Node in NodeListObj[0].ChildNodes) { if (Node.Name == REPORT_ELEMENT) { this.AddNameAttribteInAttributeSet(RetVal, MDCatGIDandNameColl, Node); } } } catch (Exception ex) { throw ex; } return RetVal; }
/// <summary> /// Returns MetadaataInfo object from the given metadata text /// </summary> /// <param name="mdElementType"></param> /// <returns></returns> private MetadataInfo GetMetadataInfoFrmMetadataText(string metadataText, MetadataElementType mdElementType) { MetadataInfo RetVal = new MetadataInfo(); CategoryInfo Category; XmlDocument XmlDoc; //string ConcatinatedParaNodeText = string.Empty; //XmlElement CategoryNode = default(XmlElement); //XmlNode CategoryXmlNode = null; //DataTable CategoryTable; //XmlElement RootNode = default(XmlElement); //XmlDocument XmldocumentNew = new XmlDocument(); //XmlDeclaration xmlDeclaration = default(XmlDeclaration); //string XmlString = string.Empty; //String ConcatenatedParaNodeText = string.Empty; //string CategoryParaXml; try { //xmlDeclaration = XmldocumentNew.CreateXmlDeclaration("1.0", "utf-8", null); //RootNode = XmldocumentNew.CreateElement(MetadataManagerConstants.Metadata); //XmldocumentNew.InsertBefore(xmlDeclaration, XmldocumentNew.DocumentElement); //XmldocumentNew.AppendChild(RootNode); //--Load xml from database. XmlDoc = new XmlDocument(); XmlDoc.LoadXml(metadataText); //--get categories foreach (XmlNode Node in XmlDoc.SelectNodes("metadata/Category")) { Category = new CategoryInfo(); Category.CategoryName = Convert.ToString(Node.Attributes["name"].Value); Category.CategoryType = DIQueries.MetadataElementTypeText[mdElementType]; // get metadata text from xml's Para node if (Node.ChildNodes.Count > 0) { Category.MetadataText = Convert.ToString(Node.ChildNodes[0].InnerXml); } // add category into metadataInfo object if (!RetVal.Categories.ContainsKey(Category.CategoryName)) { RetVal.Categories.Add(Category.CategoryName, Category); } } //foreach (DataRow CategoryNameRow in CategoryTable.Rows) //{ // Category = new CategoryInfo(); // Category.CategoryName = Convert.ToString(CategoryNameRow[DIColumns.Metadata_Category.CategoryName]); // Category.CategoryType = metadataType.ToString(); // //--Create new xmlelement as Category // CategoryNode = XmldocumentNew.CreateElement(MetadataManagerConstants.Category); // //--Set attribute values of category element. // CategoryNode.SetAttribute(MetadataManagerConstants.NameAttribute, Category.CategoryName); // //--Select Category node with appropriate attribute name(category name) // CategoryXmlNode = XmlDoc.SelectSingleNode(MetadataManagerConstants.CategoryName + Category.CategoryName + MetadataManagerConstants.ClosingSymbol); // //--Add in category collection // if (CategoryXmlNode != null) // { // CategoryParaXml = CategoryXmlNode.InnerXml; // Category.MetadataText = CategoryXmlNode.InnerXml; // //--check for category in collection // if (!RetVal.Categories.ContainsKey(Category.CategoryName)) // { // RetVal.Categories.Add(Category.CategoryName, Category); // } // } //} //return RetVal; } catch { RetVal = null; } return(RetVal); }
/// <summary> /// Import Metdata report /// </summary> /// <param name="xmlFileNameWPath"></param> /// <param name="mdType"></param> /// <param name="selectedNidInTrgDatabase"></param> /// <param name="selectedFiles"></param> /// <param name="XsltFolderPath"></param> public void ImportMetadataFromXML(string xmlString, MetadataElementType metadataElementType, int selectedNidInTrgDatabase, string XsltFolderPath) { XmlDocument XmlDoc = new XmlDocument(); DI7MetadataCategoryBuilder MDBuilder = new DI7MetadataCategoryBuilder(this.DBConnection, this.DBQueries); XmlDoc.LoadXml(xmlString); try { //-- check that Value/Name attribute exists or not if (this.IsMetadataNameAttributeExists(XmlDoc)) { this.CheckNInsertMetadataReportXml(XmlDoc, selectedNidInTrgDatabase, true, DIQueries.MetadataElementTypeText[metadataElementType]); } else { // if not then use ID for mapping . // If category ID exists in trg database then only import metadata report this.CheckNInsertMetadataReportXml(XmlDoc, selectedNidInTrgDatabase, false, DIQueries.MetadataElementTypeText[metadataElementType]); } } catch (Exception ex) { throw ex; } }
private Dictionary<string, string> GetMetadataCategoryNameGIDCollection(MetadataElementType mdType) { Dictionary<string, string> RetVal = new Dictionary<string, string>(); DataTable Table = this.DBConnection.ExecuteDataTable(this.DBQueries.Metadata_Category.GetMetadataCategories(FilterFieldType.None, string.Empty)); if (mdType == MetadataElementType.Indicator) { Table.DefaultView.RowFilter = Metadata_Category.CategoryType + "='I'"; } else if (mdType == MetadataElementType.Area) { Table.DefaultView.RowFilter = Metadata_Category.CategoryType + "='A'"; } else { Table.DefaultView.RowFilter = Metadata_Category.CategoryType + "='S'"; } Table = Table.DefaultView.ToTable(); foreach (DataRow Row in Table.Rows) { if (!RetVal.ContainsKey(Convert.ToString(Row[Metadata_Category.CategoryGId]))) { RetVal.Add(Convert.ToString(Row[Metadata_Category.CategoryGId]), Convert.ToString(Row[Metadata_Category.CategoryName])); } } return RetVal; }
private void UpdateMetadataInfoByCategoryType(MetadataElementType categoryType, MetadataCategoryBuilder metadataCategoryBuilder, DIQueries queries) { List<string> TargetNids; DataTable SrcCategoryTable = null; StringBuilder Metadata_Category_Info = new StringBuilder(); SrcCategoryTable = this._DBConnection.ExecuteDataTable(queries.MetadataReport.GetAllMetadataReportsByCategoryType(categoryType)); TargetNids = DICommon.GetCommaSeperatedListOfGivenColumn(SrcCategoryTable, MetadataReport.TargetNid, false, string.Empty); //for every target like for indicator one there is many metadata category may be definition, Classification, Method of Computation foreach (string targetNid in TargetNids) { Metadata_Category_Info.Remove(0, Metadata_Category_Info.Length); //Step 1 Create metadata Info in xml format this.CreateMetadataXML(SrcCategoryTable.Select(MetadataReport.TargetNid + "='" + targetNid + "'"), ref Metadata_Category_Info, metadataCategoryBuilder, DIQueries.MetadataElementTypeText[categoryType].Trim("'".ToCharArray())); //Step 2 Update metadata Info in xml format this.UpdateMetadataInfo(queries, targetNid, categoryType, Metadata_Category_Info.ToString()); } }
/// <summary> /// Load Data into excel report file /// </summary> private void LoadData(MetadataElementType elementType, int elementNID) { string ParaNodeText = string.Empty; string ConcatenatedParaNodeText = string.Empty; DataTable CategoryTable = null; DataTable MetadataReportTable = null; string CategoryName = string.Empty; string CategoryNid = string.Empty; string MetadataText = string.Empty; string ReplaceableSymbol = "{{~}}"; string CategoryGID = string.Empty; try { // 1. Get category table from database where ispresentational is false CategoryTable = this.GetCategoryDataTable(elementType); // rearrange categories CategoryTable = DI7MetadataCategoryBuilder.RearrangeCategoryTableByCategoryOrder(CategoryTable); // 2. get metadata reports MetadataReportTable = this.GetMetadataReportsTableFrmDB(elementNID, elementType); // 3. Add Title // writes metadata values in excel report. this.WriteMetadataField(CategoryIndex, DILanguage.GetLanguageString("CATEGORY"), DILanguage.GetLanguageString("CATEGORY_GID")); //Write values to excel this.WriteMetadataValueToExcel(CategoryIndex, DILanguage.GetLanguageString("METADATA")); this.MetadataSheet.Cells[this._MetadataStartRowIndexInExl + CategoryIndex, 0, this._MetadataStartRowIndexInExl + CategoryIndex, 2].Font.Bold = true; this.MetadataSheet.Cells[this._MetadataStartRowIndexInExl + CategoryIndex, 0, this._MetadataStartRowIndexInExl + CategoryIndex, 2].Interior.Color = SpreadsheetGear.Drawing.Color.FromArgb(System.Drawing.Color.LightGray.ToArgb()); CategoryIndex++; //Iterate through category node foreach (DataRow CategoryRow in CategoryTable.Rows) { // 4.2 get category label form table CategoryName = Convert.ToString(CategoryRow[Metadata_Category.CategoryName]); CategoryNid = Convert.ToString(CategoryRow[Metadata_Category.CategoryNId]); CategoryGID = Convert.ToString(CategoryRow[Metadata_Category.CategoryGId]); // writes metadata values in excel report. this.WriteMetadataField(CategoryIndex, CategoryName, CategoryGID); // Get metadata report from metadata report table for the current category foreach (DataRow Row in MetadataReportTable.Select(MetadataReport.CategoryNid + "=" + CategoryNid)) { MetadataText = Convert.ToString(Row[MetadataReport.Metadata]).Replace(ReplaceableSymbol, Microsoft.VisualBasic.ControlChars.NewLine); //Write values to excel WriteMetadataValueToExcel(CategoryIndex, MetadataText); } CategoryIndex = CategoryIndex + 1; } } catch (Exception ex) { ExceptionHandler.ExceptionFacade.ThrowException(ex); } }
private void AddWrongMetadataElement(SortedDictionary<MetadataElementType, List<string>> wrongMetadataElementList, MetadataElementType metadataType) { DataTable Table = new DataTable(); DataRow Row; Table.Columns.Add(metadataType.ToString() + " Name"); // add indicators if (wrongMetadataElementList.ContainsKey(metadataType)) { foreach (string ElementName in wrongMetadataElementList[metadataType]) { Row = Table.NewRow(); Row[0] = ElementName; Table.Rows.Add(Row); } this.LogFile.AddDataTable(Table, metadataType.ToString() + "s where metadata exist in a wrong format:"); } }
/// <summary> /// Main Method for Displaying Metadata /// </summary> /// <param name="elementType"> Element Type.<example>ElementType.All, ElementType.Indicator </example> <seealso cref="DI_MetaInfo.ElementType"/></param> /// <param name="elementNid">ID of selected Data.IND - IndicatorNId, Area - AreaNId, Source - ICNId</param> /// <param name="DI_QueryBase"> This contain Connection Details</param> /// <param name="outPutPath">This contains the path where output files were created</param> /// <param name="outputFileName"> /// this will be the name of outputFile without extention /// which will be created at the output path to display metadata /// <remarks> extension like ".xml" ".xsl" and ".html" are added to this outputFile name /// while creating files </remarks> /// </param> /// <returns> /// </returns> public static bool ExtractXmlMetadata(MetadataElementType metadataElementType, int elementNId, DIConnection DIConnection, DIQueries DIQueries, string outputFolder, string outputFileName, ref string infoTitle) { bool RetVal = false; infoTitle = string.Empty; //Will return the Element name against ElementNId IconElementType IconElementType = IconElementType.MetadataIndicator; XmlDocument XMLDoc = new XmlDocument(); DataTable DTMetaDataInfo = null; string MetadataInfo = string.Empty; String sSql = ""; int LayerNId = -1; string TargetObjectID = string.Empty; Lib.DI_LibSDMX.MetadataTypes SDMXMetadataType = DevInfo.Lib.DI_LibSDMX.MetadataTypes.Indicator; switch (metadataElementType) { case MetadataElementType.Area: IconElementType = IconElementType.MetadataArea; SDMXMetadataType = DevInfo.Lib.DI_LibSDMX.MetadataTypes.Area; //-- Get LayerNId associated with AreaNId if (_LayerNId == -1) { LayerNId = GetLayerNId(elementNId.ToString(), DIConnection, DIQueries); } else { LayerNId = _LayerNId; } //if (LayerNId != -1) //{ // //-- Get Layer Metadata Info // sSql = DIQueries.Area.GetAreaMapMetadata(LayerNId.ToString()); // DTMetaDataInfo = DIConnection.ExecuteDataTable(sSql); // if (DTMetaDataInfo != null & DTMetaDataInfo.Rows.Count > 0) // { // MetadataInfo = DTMetaDataInfo.Rows[0][Area_Map_Metadata.MetadataText].ToString(); // } //} // Set Meta Info title. sSql = DIQueries.Area.GetArea(FilterFieldType.NId, elementNId.ToString()); DTMetaDataInfo = DIConnection.ExecuteDataTable(sSql); if (DTMetaDataInfo != null & DTMetaDataInfo.Rows.Count > 0) { infoTitle = DTMetaDataInfo.Rows[0][Area.AreaName].ToString() + " (" + DTMetaDataInfo.Rows[0][Area.AreaID].ToString() + ")"; TargetObjectID = Convert.ToString(DTMetaDataInfo.Rows[0][Area.AreaID]); } break; case MetadataElementType.Indicator: IconElementType = IconElementType.MetadataIndicator; SDMXMetadataType = DevInfo.Lib.DI_LibSDMX.MetadataTypes.Indicator; sSql = DIQueries.Indicators.GetIndicator(FilterFieldType.NId, elementNId.ToString(), FieldSelection.Heavy); DTMetaDataInfo = DIConnection.ExecuteDataTable(sSql); if (DTMetaDataInfo != null & DTMetaDataInfo.Rows.Count > 0) { infoTitle = DTMetaDataInfo.Rows[0][Indicator.IndicatorName].ToString(); TargetObjectID = Convert.ToString(DTMetaDataInfo.Rows[0][Indicator.IndicatorGId]); } break; case MetadataElementType.Source: IconElementType = IconElementType.MetadataSource; SDMXMetadataType = DevInfo.Lib.DI_LibSDMX.MetadataTypes.Source; sSql = DIQueries.IndicatorClassification.GetIC(FilterFieldType.NId, elementNId.ToString(), ICType.Source, FieldSelection.Heavy); DTMetaDataInfo = DIConnection.ExecuteDataTable(sSql); if (DTMetaDataInfo != null & DTMetaDataInfo.Rows.Count > 0) { infoTitle = DTMetaDataInfo.Rows[0][IndicatorClassifications.ICName].ToString(); TargetObjectID = Convert.ToString(DTMetaDataInfo.Rows[0][IndicatorClassifications.ICGId]); } break; } try { // Get metadata xml file using SDMX library MetadataInfo = Lib.DI_LibSDMX.SDMXUtility.Get_MetadataReport(DevInfo.Lib.DI_LibSDMX.SDMXSchemaType.Two_One, TargetObjectID, SDMXMetadataType, "MDAgency", DIQueries.LanguageCode.Replace("_", ""), DIConnection, DIQueries).InnerXml; DevInfo.Lib.DI_LibBAL.DA.DML.DI7MetaDataBuilder MetadataBuilder = new DevInfo.Lib.DI_LibBAL.DA.DML.DI7MetaDataBuilder(DIConnection, DIQueries); // Get metadata xml file with category name.. XMLDoc = MetadataBuilder.GetMetadataReportWCategoryName(MetadataInfo, metadataElementType); MetadataInfo = XMLDoc.InnerXml; //Write Metadata text to physical file // --Change on 18-03-08 .blank xml with root element will be written in case of no metadata info found in database // If no metadata info create a blank xml file. with root element. if (string.IsNullOrEmpty(MetadataInfo) || MetadataInfo.Trim().Length == 0) { WriteToFile("<?xml version='1.0'?><root ></root >", System.IO.Path.Combine(outputFolder, outputFileName + ".xml")); } else { WriteToFile(MetadataInfo, System.IO.Path.Combine(outputFolder, outputFileName + ".xml")); } // Commented on 18-march -2008. shifted in if else part above. ////WriteToFile(MetadataInfo, System.IO.Path.Combine(outputFolder, outputFileName + ".xml")); } catch (Exception ex) { RetVal = false; } if (MetadataInfo.Trim().Length > 0) { RetVal = true; //Write XLS and HTMLFile try { switch (metadataElementType) { case MetadataElementType.Area: //In Case Area Get Xslt associated with LayerNId (not with AreaNId) sSql = DIQueries.Xslt.GetXSLT(LayerNId.ToString(), metadataElementType); break; case MetadataElementType.Indicator: case MetadataElementType.Source: sSql = DIQueries.Xslt.GetXSLT(elementNId.ToString(), metadataElementType); break; default: break; } DataTable XSLTInfo = (DIConnection.ExecuteDataTable(sSql)); // If XSLT info was Found Write write Xsl and Html file if (XSLTInfo != null & XSLTInfo.Rows.Count > 0) { // Creating Xsl File String xslString = XSLTInfo.Rows[0]["XSLT_Text"].ToString(); WriteToFile(xslString, System.IO.Path.Combine(outputFolder, outputFileName + ".xsl")); //Write HTml file WriteHtmlFile(outputFolder, outputFileName); } } catch (Exception) { } //Extract Images associated with metadata try { if (metadataElementType == MetadataElementType.Area) { ExtractImage(LayerNId, IconElementType, DIConnection, DIQueries, outputFolder); } else { ExtractImage(elementNId, IconElementType, DIConnection, DIQueries, outputFolder); } } catch (Exception) { //Old database may not have Icon table } } infoTitle = infoTitle.Replace("&", "&&"); //label control do not display & character return(RetVal); }
/// <summary> /// Set metadata master tables for Indicator / Area / Source /// </summary> /// <param name="metadataElementType">Indicator / Area / Source</param> /// <param name="userPreference"></param> /// <param name="dIConnection"></param> /// <param name="dIQueries"></param> /// <returns></returns> private bool SetMetedataTables(MetadataElementType metadataElementType, UserPreference.UserPreference userPreference, DI_LibDAL.Connection.DIConnection dIConnection, DI_LibDAL.Queries.DIQueries dIQueries) { bool RetVal = false; string MaskFilePath = string.Empty; XmlDocument MaskFileDocument = new XmlDocument(); XmlNodeList MaskNodeList; string MaskPathText = string.Empty; string MaskPositionText = string.Empty; string[] MaskPositionArray; XmlDocument MetadataDocument = new XmlDocument(); string MetadataXml = string.Empty; XmlNodeList MetadataFld_ValNodeList; string[] arrSelectedMetadataFields = null; string JoinColumnName = string.Empty; string MetadataColumnName = string.Empty; string _Query = string.Empty; DataTable DistinctElementTable; string[] DistinctNIds = null; DataView dvMetadataInfo = null; DataTable ElementMetadataTable = null; string CategoryType = string.Empty; // I / A / S string MetadataPrefix = string.Empty; //MD_IND_, MD_SRC_ switch (metadataElementType) { case MetadataElementType.Indicator: // Set Category Type CategoryType = DIQueries.MetadataElementTypeText[MetadataElementType.Indicator]; MetadataPrefix = UserPreference.UserPreference.DataviewPreference.MetadataIndicator; // Get Metadata fields from userPreference arrSelectedMetadataFields = userPreference.DataView.MetadataIndicatorField.Split(",".ToCharArray(), System.StringSplitOptions.RemoveEmptyEntries); // Set Mask file path MaskFilePath = Path.Combine(this.msMaskFolder, MASK_FILE_INDICATOR); //Set Join column and Metadata Column name JoinColumnName = Indicator.IndicatorNId; MetadataColumnName = Indicator.IndicatorInfo; // Get distinct indicator nids DistinctElementTable = this._IUSIndicator.DefaultView.ToTable(true, JoinColumnName); DistinctNIds = new string[DistinctElementTable.Rows.Count]; for (int i = 0; i < DistinctElementTable.Rows.Count; i++) { DistinctNIds[i] = DistinctElementTable.Rows[i][JoinColumnName].ToString(); } // Get Metadata Info for all Indicators _Query = this.mdIQueries.Indicators.GetIndicator(FilterFieldType.NId, string.Join(",", DistinctNIds), FieldSelection.Heavy); dvMetadataInfo = this.ExecuteInvariantDataTable(_Query).DefaultView; ElementMetadataTable = this._MetadataIndicator; break; case MetadataElementType.Area: // Set Category Type CategoryType = DIQueries.MetadataElementTypeText[MetadataElementType.Area]; MetadataPrefix = UserPreference.UserPreference.DataviewPreference.MetadataArea; // Get Metadata fields from userPreference arrSelectedMetadataFields = userPreference.DataView.MetadataAreaField.Split(",".ToCharArray(), System.StringSplitOptions.RemoveEmptyEntries); // Set Mask file path MaskFilePath = Path.Combine(this.msMaskFolder, MASK_FILE_AREA); //Get LayerNids for these areas _Query = this.mdIQueries.Area.GetAreaMapByAreaNIds(this._AreaNIds, false); DataTable dtAreaMap = this.ExecuteInvariantDataTable(_Query); //Get Distinct LayerNIds string[] ColumnArray = new string[1]; ColumnArray[0] = Area_Map.LayerNId; DistinctElementTable = dtAreaMap.DefaultView.ToTable(true, ColumnArray); DistinctNIds = new string[DistinctElementTable.Rows.Count]; for (int i = 0; i < DistinctElementTable.Rows.Count; i++) { DistinctNIds[i] = DistinctElementTable.Rows[i][ColumnArray[0]].ToString(); } //Get Metadata for LayerNIds along with associated AreaNIds DataTable dtMetadata = GetInvariantDataTable(); if (DistinctNIds.Length > 0) { //Join to Associate AreaNId and LayerNId DataSet dsParentChild = GetInvariantDataSet(); // Add AreaMap Table dtMetadata = dtAreaMap.Copy(); // Since it might be part if a relationship, therefore adding the COPY dtMetadata.TableName = "Parent"; dtMetadata.Columns.Add(Area_Map_Metadata.MetadataText, typeof(string)); dsParentChild.Tables.Add(dtMetadata); // Add AreaMapMetadata Table _Query = this.mdIQueries.Area.GetAreaMapMetadata(string.Join(",", DistinctNIds)); DataTable dtAreaMapMetadata = this.ExecuteInvariantDataTable(_Query); dtAreaMapMetadata.TableName = "Child"; // Set Primaty Key in the AreaMapMetadata DataColumn[] PK = new DataColumn[1]; PK[0] = dtAreaMapMetadata.Columns[Area_Map_Metadata.LayerNId]; dtAreaMapMetadata.PrimaryKey = PK; dsParentChild.Tables.Add(dtAreaMapMetadata); // Define relationship dsParentChild.Relations.Add("RelAreaMap", dsParentChild.Tables[1].Columns[Area_Map.LayerNId], dsParentChild.Tables[0].Columns[Area_Map_Metadata.LayerNId], false); dsParentChild.Tables[0].Columns[Area_Map_Metadata.MetadataText].Expression = "Parent(RelAreaMap)." + Area_Map_Metadata.MetadataText; dsParentChild.AcceptChanges(); } dvMetadataInfo = dtMetadata.DefaultView; //(AreaNId-LayerNId-MetadataText) //Set Join column and Metadata Column name JoinColumnName = Area.AreaNId; MetadataColumnName = Area_Map_Metadata.MetadataText; // Get distinct area nids DistinctNIds = this._AreaNIds.Split(",".ToCharArray(), System.StringSplitOptions.RemoveEmptyEntries); // Set metadata table ElementMetadataTable = this._MetadataArea; break; case MetadataElementType.Source: // Set Category Type CategoryType = DIQueries.MetadataElementTypeText[MetadataElementType.Source]; MetadataPrefix = UserPreference.UserPreference.DataviewPreference.MetadataSource; // Get Metadata fields from userPreference arrSelectedMetadataFields = userPreference.DataView.MetadataSourceField.Split(",".ToCharArray(), System.StringSplitOptions.RemoveEmptyEntries); // Set Mask file path MaskFilePath = Path.Combine(this.msMaskFolder, MASK_FILE_SOURCE); //Set Join column and Metadata Column name JoinColumnName = IndicatorClassifications.ICNId; MetadataColumnName = IndicatorClassifications.ICInfo; // Get distinct source nids DistinctNIds = new string[this._Sources.Rows.Count]; for (int i = 0; i < this._Sources.Rows.Count; i++) { DistinctNIds[i] = this._Sources.Rows[i][JoinColumnName].ToString(); } // Get Metadata Info for all sources _Query = this.mdIQueries.IndicatorClassification.GetIC(FilterFieldType.NId, string.Join(",", DistinctNIds), ICType.Source, FieldSelection.Heavy); dvMetadataInfo = this.ExecuteInvariantDataTable(_Query).DefaultView; // Set metadata table ElementMetadataTable = this._MetadataSource; break; } // Check for existence of indicator mask file if (File.Exists(MaskFilePath)) { // Try loading indicator mask file try { MaskFileDocument.Load(MaskFilePath); } catch (Exception) { //TODO do not proceed further } } // Add Join columns to Metadata table ElementMetadataTable.Columns.Clear(); ElementMetadataTable.Columns.Add(JoinColumnName, typeof(int)); if (this._CensusInfoFeature) { _Query = this.mdIQueries.Metadata_Category.GetMetadataCategories(FilterFieldType.Type, CategoryType); DataView dvMetadataCategory = this.ExecuteInvariantDataTable(_Query).DefaultView; for (int j = 0; j < arrSelectedMetadataFields.Length; j++) { // Add Metadata columns to Metadata table ElementMetadataTable.Columns.Add(arrSelectedMetadataFields[j], typeof(string)); ElementMetadataTable.Columns[arrSelectedMetadataFields[j]].DefaultValue = string.Empty; // For each distinct Element for (int i = 0; i < DistinctNIds.Length; i++) { DataRow drMetadata; if (j == 0) { // Create data row for each Element (Indicator / Area / Source) only once drMetadata = ElementMetadataTable.NewRow(); drMetadata[JoinColumnName] = DistinctNIds[i]; } else { // If data row alreday exists simply update the desired field drMetadata = ElementMetadataTable.Select(JoinColumnName + " = " + DistinctNIds[i])[0]; } if (dvMetadataInfo != null && dvMetadataInfo.Table.Columns.Contains(JoinColumnName)) { dvMetadataInfo.RowFilter = JoinColumnName + " = " + DistinctNIds[i]; // Check for valid xml content if (dvMetadataInfo.Count > 0) { MetadataXml = dvMetadataInfo[0][MetadataColumnName].ToString(); if (MetadataXml != null && MetadataXml.Trim().Length > 0) { try // Try loading metadata xml { //Get all FLD_VAL contents into a Nodelist XmlDocument xmlDoc = new XmlDocument(); xmlDoc.LoadXml(dvMetadataInfo[0][MetadataColumnName].ToString()); dvMetadataCategory.RowFilter = Metadata_Category.CategoryNId + " = " + arrSelectedMetadataFields[j].Replace(MetadataPrefix, ""); if (dvMetadataCategory != null && dvMetadataCategory.Count > 0) { XmlNode CategoryXmlNode = xmlDoc.SelectSingleNode("//Category[@name='" + dvMetadataCategory[0][Metadata_Category.CategoryName].ToString() + "']"); string ParaNodeText = string.Empty; if (!String.IsNullOrEmpty(CategoryXmlNode.InnerText)) { // Replace Para defining delimiter by new line character ParaNodeText = CategoryXmlNode.InnerText.Replace(DevInfo.Lib.DI_LibBAL.DA.DML.MetadataManagerConstants.ReplaceableSymbol, Environment.NewLine); } // get category value from xml (from <para> tags) //foreach (XmlNode ParaNode in CategoryXmlNode.ChildNodes) //{ // // get para node text // // add para node into concatenated category value // if (!string.IsNullOrEmpty(ParaNodeText)) // { // ParaNodeText += Microsoft.VisualBasic.ControlChars.NewLine ; // } // ParaNodeText += ParaNode.InnerText.Trim(); //} // Based on position information (index) get Metadata content drMetadata[arrSelectedMetadataFields[j]] = ParaNodeText; } } catch (Exception) { //If unable to load metadata text then fields shall remain empty } } } dvMetadataInfo.RowFilter = string.Empty; } // Add element row only while looping for first field if (j == 0) { ElementMetadataTable.Rows.Add(drMetadata); } } } } else { // For each selected field for indicator / area (map) / source metadata for (int j = 0; j < arrSelectedMetadataFields.Length; j++) { // Add Metadata columns to Metadata table ElementMetadataTable.Columns.Add(arrSelectedMetadataFields[j], typeof(string)); ElementMetadataTable.Columns[arrSelectedMetadataFields[j]].DefaultValue = string.Empty; // Get position information from mask file MaskNodeList = MaskFileDocument.SelectNodes("*/*[ID='" + arrSelectedMetadataFields[j] + "']"); //root/Input1/ID if (MaskNodeList.Count > 0) { if (MaskNodeList[0].SelectNodes("Position")[0] != null) //TODO Remove Hardcoding "Position" { MaskPositionText = MaskNodeList[0].SelectNodes("Position")[0].InnerText; //TODO Remove Hardcoding "Position" MaskPositionArray = MaskPositionText.Split("/".ToCharArray(), System.StringSplitOptions.RemoveEmptyEntries); if (MaskPositionArray.Length == 5) // 1/1/1/n/1 1/2/1/n/1 { // For each distinct Element for (int i = 0; i < DistinctNIds.Length; i++) { DataRow drMetadata; if (j == 0) { // Create data row for each Element (Indicator / Area / Source) only once drMetadata = ElementMetadataTable.NewRow(); drMetadata[JoinColumnName] = DistinctNIds[i]; } else { // If data row alreday exists simply update the desired field drMetadata = ElementMetadataTable.Select(JoinColumnName + " = " + DistinctNIds[i])[0]; } if (dvMetadataInfo != null && dvMetadataInfo.Table.Columns.Contains(JoinColumnName)) { dvMetadataInfo.RowFilter = JoinColumnName + " = " + DistinctNIds[i]; // Check for valid xml content if (dvMetadataInfo.Count > 0) { MetadataXml = dvMetadataInfo[0][MetadataColumnName].ToString(); if (MetadataXml.Trim().Length > 0) { try // Try loading metadata xml { MetadataDocument.LoadXml(MetadataXml); //Get all FLD_VAL contents into a Nodelist MetadataFld_ValNodeList = MetadataDocument.SelectNodes("Indicator_Info/Row1/FLD_VAL"); //TODO Remove Hardcoding // Based on position information (index) get Metadata content //drMetadata[arrSelectedMetadataFields[j]] = "abc"; if (MetadataFld_ValNodeList.Count >= int.Parse(MaskPositionArray[1])) { drMetadata[arrSelectedMetadataFields[j]] = MetadataFld_ValNodeList[(int.Parse(MaskPositionArray[1]) - 1)].InnerText.Trim(); } } catch (Exception) { //If unable to load metadata text then fields shall remain empty } } } } // Add element row only while looping for first field if (j == 0) { ElementMetadataTable.Rows.Add(drMetadata); } } } } } } } return RetVal; }
private void CreateIndicatorTransformInfo(string XSLTText, string XsltFilename, string elementNId, MetadataElementType elementType) { // -- this function insert the values into RT_XSLT table string SqlString = string.Empty; try { int XsltNid = 0; // -- step1 : check xslt info already exists or not SqlString = this.DBQueries.Xslt.GetXSLT(FilterFieldType.Name, XsltFilename); if (this.DBConnection.ExecuteDataTable(SqlString).Rows.Count == 0) { //-- step 2: insert into xslt table SqlString = DALQueries.Xslt.Insert.InsertXSLT(this.DBQueries.DataPrefix, DICommon.RemoveQuotes(XSLTText), DICommon.RemoveQuotes(XsltFilename)); this.DBConnection.ExecuteNonQuery(SqlString); } else { //-- step 2: Update xslt table SqlString = DALQueries.Xslt.Update.UpdateXSLT(this.DBQueries.DataPrefix, DICommon.RemoveQuotes(XSLTText), XsltFilename); this.DBConnection.ExecuteNonQuery(SqlString); } //-- step 3: find the xslt_nid against xslFilename SqlString = this.DBQueries.Xslt.GetXSLT(FilterFieldType.Name, XsltFilename); // -- step 4: insert into Element_xslt table XsltNid = Convert.ToInt32(this.DBConnection.ExecuteScalarSqlQuery(SqlString)); SqlString = DALQueries.Xslt.Insert.InsertElementXSLT(this.DBQueries.DataPrefix, Convert.ToInt32(elementNId), elementType, Convert.ToInt32(XsltNid)); this.DBConnection.ExecuteNonQuery(SqlString); } catch (Exception ex) { throw new ApplicationException(ex.ToString()); } }
public bool ImportMetataFromExcel(MetadataElementType categoryType, MetaDataType metadataType, int elementNId, string xlsFileNameWPath, string xsltFldrPath) { bool RetVal = true; string MetadataText = string.Empty; string FirstColumnValue = string.Empty; string SecondColumnValue = string.Empty; string ThirdColumnValue = string.Empty; string ElementName = string.Empty; string ElementGID = string.Empty; DataTable ExcelDataTable = null; DataRow Row; DI7MetaDataBuilder MDBuilder; DI7MetadataCategoryBuilder MDCategoryBuilder; DI7MetadataCategoryInfo MetadataCategory; DIExcel ExcelFile = null; try { // -- Get data table from excel file ExcelFile = new DIExcel(xlsFileNameWPath); ExcelDataTable = ExcelFile.GetDataTableFromSheet(ExcelFile.GetSheetName(0)); // -- create database builder objects MDCategoryBuilder = new DI7MetadataCategoryBuilder(this.DBConnection, this.DBQueries); MDBuilder = new DI7MetaDataBuilder(this.DBConnection, this.DBQueries); // -- import metadata reports with category for (int RowIndex = 1; RowIndex < ExcelDataTable.Rows.Count; RowIndex++) { Row = ExcelDataTable.Rows[RowIndex]; FirstColumnValue = Convert.ToString(Row[0]); SecondColumnValue = Convert.ToString(Row[1]); ThirdColumnValue = Convert.ToString(Row[2]); // get element name if (string.IsNullOrEmpty(ElementName)) { if (string.IsNullOrEmpty(FirstColumnValue)) { break; } else { ElementName = FirstColumnValue; continue; } } // get element gid/id if (string.IsNullOrEmpty(ElementGID)) { if (string.IsNullOrEmpty(FirstColumnValue)) { break; } else { ElementGID = FirstColumnValue; // get element nid by element gid if (metadataType == MetaDataType.Source) { elementNId = this.GetElementNidByGID(ElementName, metadataType); } else { elementNId = this.GetElementNidByGID(ElementGID, metadataType); } // Skip title row by incrementing row index RowIndex++; continue; } } // continue if row is blank if (string.IsNullOrEmpty(FirstColumnValue) && string.IsNullOrEmpty(SecondColumnValue) && string.IsNullOrEmpty(ThirdColumnValue)) { // reset element value elementNId = 0; ElementName = string.Empty; ElementGID = string.Empty; continue; } else if (elementNId > 0) { // import metadata report with metadata category // get metadata category and metedata report MetadataCategory = new DI7MetadataCategoryInfo(); MetadataCategory.CategoryName = SecondColumnValue; MetadataCategory.CategoryGID = FirstColumnValue; MetadataCategory.CategoryType = DIQueries.MetadataElementTypeText[categoryType]; // import metadata category MetadataCategory.CategoryNId = MDCategoryBuilder.CheckNInsertCategory(MetadataCategory); // import metadata report if (MetadataCategory.CategoryNId > 0) { MDBuilder.InsertORUpdateMetadataInfo(metadataType, MetadataCategory.CategoryNId.ToString(), elementNId, this.ReplaceNewLineInMetadataReport(ThirdColumnValue)); } } } } catch (Exception) { RetVal = false; } finally { if (ExcelFile != null) { ExcelFile.Close(); } } return RetVal; }
///// <summary> ///// Save metadata into database ///// </summary> ///// <param name="mdType"></param> ///// <param name="elementNid"></param> ///// <param name="metadataString"></param> //private void SaveMetadataIntoDatabase(MetaDataType mdType, int elementNid, string metadataString) //{ //} #endregion #region "-- Public --" #region "-- Properties --" ///// <summary> ///// stores updated categories ///// </summary> //private Dictionary<int, string> _UpdatedCategories = new Dictionary<int, string>(); //public Dictionary<int, string> UpdatedCategories //{ // get { return this._UpdatedCategories; } // set { this._UpdatedCategories = value; } //} //private DataTable CategoryTable; //private DIConnection _DBConnection; ///// <summary> ///// Gets or sets instance of DIConnection ///// </summary> //public DIConnection DBConnection //{ // get { return this._DBConnection; } // set { this._DBConnection = value; } //} //private DIQueries _DBQueries; ///// <summary> ///// Gets or sets instance of DIQueries ///// </summary> //public DIQueries DBQueries //{ // get { return this._DBQueries; } // set { this._DBQueries = value; } //} #endregion #region "-- Methods --" ///// <summary> ///// Removes categories from collection. ///// </summary> //public void RemoveCategoriesFromCollection() //{ // this.UpdatedCategories.Clear(); //} /// <summary> /// Update category in metadata in database. /// </summary> /// <param name="oldCategories"></param> public void UpdateCategoryInMetadataIntoDB(Dictionary <int, string> oldCategories, MetaDataType mdType) { DataTable Table = null; MetadataInfo MetadataInfoObject = null; MetadataElementType MDElementType = MetadataElementType.Indicator; string MetadataColumnName = string.Empty; string MetadataString = string.Empty; string ElementNidColumnName = string.Empty; int ElementNid = 0; string MetadataText = string.Empty; DataTable CategoryTable; MetaDataBuilder MDBuilder = new MetaDataBuilder(this.DBConnection, this.DBQueries); // 1. get category table order by category_order CategoryTable = this.GetCategoryDataTableFrmDB(mdType); // 2. Get indicators/Area/Source from database where metadata text is not null or empty switch (mdType) { case MetaDataType.Indicator: MDElementType = MetadataElementType.Indicator; MetadataColumnName = DIColumns.Indicator.IndicatorInfo; ElementNidColumnName = DIColumns.Indicator.IndicatorNId; Table = this.DBConnection.ExecuteDataTable(this.DBQueries.Indicators.GetIndicator(FilterFieldType.None, String.Empty, FieldSelection.Heavy)); break; case MetaDataType.Map: MDElementType = MetadataElementType.Area; MetadataColumnName = DIColumns.Area_Map_Metadata.MetadataText; ElementNidColumnName = DIColumns.Area_Map_Metadata.MetadataNId; Table = this.DBConnection.ExecuteDataTable(this.DBQueries.Area.GetAreaMapMetadata(string.Empty)); break; case MetaDataType.Source: MDElementType = MetadataElementType.Source; MetadataColumnName = DIColumns.IndicatorClassifications.ICInfo; ElementNidColumnName = DIColumns.IndicatorClassifications.ICNId; Table = this.DBConnection.ExecuteDataTable(this.DBQueries.IndicatorClassification.GetIC(FilterFieldType.None, string.Empty, ICType.Source, FieldSelection.Heavy)); break; default: break; } // update metedata into database foreach (DataRow IndicatorRow in Table.Rows) { // get metadata from row MetadataString = Convert.ToString(IndicatorRow[MetadataColumnName]); if (string.IsNullOrEmpty(MetadataString)) { XmlDocument XmlDoc = new XmlDocument(); DevInfo.Lib.DI_LibBAL.Metadata.MetadataConverter.InsertRootNode(XmlDoc); MetadataString = XmlDoc.InnerXml; } //--check metadata string. if (!string.IsNullOrEmpty(MetadataString)) { // get metadataInfo object from metadata text MetadataInfoObject = this.GetMetadataInfoFrmMetadataText(MetadataString, MDElementType); if (MetadataInfoObject != null) { //-- update metadata categories into indicator metadataInfo object MetadataInfoObject = this.UpdateCategryInMetadataInfo(MetadataInfoObject, oldCategories, CategoryTable); ElementNid = Convert.ToInt32(IndicatorRow[ElementNidColumnName]); // get new metadata text and update it into database MetadataText = this.GetNewMetadataText(MetadataInfoObject); MDBuilder.UpdateMetadataInfo(mdType, string.Empty, ElementNid, MetadataText); #region "-- to be deleted --" //switch (mdType) //{ // //-if Indicator // case MetaDataType.Indicator: // MetadataInfoObject = this.UpdateCategryInMetadataInfo(MetadataInfoObject, oldCategories, DIQueries.MetadataElementTypeText[MetadataElementType.Indicator]); // ElementNid = Convert.ToInt32(IndicatorRow[DIColumns.Indicator.IndicatorNId]); // MetadataText = this.GetNewMetadataText(MetadataInfoObject); // this.SaveMetadataIntoDatabase(MetaDataType.Indicator, ElementNid, MetadataText); // break; // //-If map // case MetaDataType.Map: // MetadataInfoObject = this.UpdateCategryInMetadataInfo(MetadataInfoObject, oldCategories, DIQueries.MetadataElementTypeText[MetadataElementType.Area]); // ElementNid = Convert.ToInt32(IndicatorRow[DIColumns.Area_Map_Metadata .MetadataNId ]); // MetadataText = this.GetNewMetadataText(MetadataInfoObject); // this.SaveMetadataIntoDatabase(MetaDataType.Map, ElementNid, MetadataText); // break; // //-If source. // case MetaDataType.Source: // MetadataInfoObject = this.UpdateCategryInMetadataInfo(MetadataInfoObject, oldCategories, DIQueries.MetadataElementTypeText[MetadataElementType.Source]); // ElementNid = Convert.ToInt32(IndicatorRow[DIColumns.IndicatorClassifications.ICNId]); // MetadataText = this.GetNewMetadataText(MetadataInfoObject); // this.SaveMetadataIntoDatabase(MetaDataType.Source, ElementNid, MetadataText); // break; // default: // break; //} #endregion } //else ////--save metadata into database. //{ // switch (mdType) // { // case MetaDataType.Indicator: // ElementNid = Convert.ToInt32(IndicatorRow[DIColumns.Indicator.IndicatorNId]); // MetadataText = ""; // this.SaveMetadataIntoDatabase(MetaDataType.Indicator, ElementNid, MetadataText); // break; // case MetaDataType.Map: // ElementNid = Convert.ToInt32(IndicatorRow[DIColumns .Area_Map_Metadata.MetadataNId]); // MetadataText = ""; // this.SaveMetadataIntoDatabase(MetaDataType.Map, ElementNid, MetadataText); // break; // case MetaDataType.Source: // ElementNid = Convert.ToInt32(IndicatorRow[DIColumns .IndicatorClassifications .ICNId ]); // MetadataText = ""; // this.SaveMetadataIntoDatabase(MetaDataType.Source, ElementNid, MetadataText); // break; // default: // break; // } //} } } }
/// <summary> /// Imports all metadata categories from given source database to current database /// </summary> /// <param name="srcDBConnection"></param> /// <param name="srcDBQueries"></param> /// <param name="categoryType"></param> public void ImportAllMetadataCategories(DIConnection srcDBConnection, DIQueries srcDBQueries, MetadataElementType categoryType) { // import by GID. If GID exists then update existing category otherwise insert it into current database // update process will update in current langauge but insert process will insert in all langauges DataTable SrcCategoryTable = null; DI7MetadataCategoryInfo SrcCategoryInfo = null; DataTable TrgCategoryTable = null; int TrgCategoryNid = 0; int TrgCategoryParentNid = -1; try { // get source category table SrcCategoryTable = srcDBConnection.ExecuteDataTable(srcDBQueries.Metadata_Category.GetMetadataCategories(FilterFieldType.Type, DIQueries.MetadataElementTypeText[categoryType])); // get target(current database) category table TrgCategoryTable = this.DBConnection.ExecuteDataTable(this.DBQueries.Metadata_Category.GetMetadataCategories(FilterFieldType.Type, DIQueries.MetadataElementTypeText[categoryType])); // import categories & sub categories from source database into current database foreach (DataRow SrcRow in SrcCategoryTable.Select(Metadata_Category.ParentCategoryNId + "=-1")) { // get category from source database SrcCategoryInfo = DI7MetadataCategoryBuilder.GetMetadataCategoryInfo(SrcRow, srcDBConnection, srcDBQueries); // check src category gid exists in current(target) database of not TrgCategoryNid = 0; TrgCategoryParentNid = -1; foreach (DataRow TrgRow in TrgCategoryTable.Select(Metadata_Category.CategoryGId + "='" + DIQueries.RemoveQuotesForSqlQuery(SrcCategoryInfo.CategoryGID) + "' OR " + Metadata_Category.CategoryName + "='" + DIQueries.RemoveQuotesForSqlQuery(SrcCategoryInfo.CategoryName) + "'")) { // if exists then get nid and parent nid TrgCategoryNid = Convert.ToInt32(TrgRow[Metadata_Category.CategoryNId]); TrgCategoryParentNid = Convert.ToInt32(TrgRow[Metadata_Category.ParentCategoryNId]); } // update nid & parent nid in src category info SrcCategoryInfo.CategoryNId = TrgCategoryNid; SrcCategoryInfo.ParentNid = TrgCategoryParentNid; if (TrgCategoryNid > 0) { // update category info this.UpdateMetadataCategory(SrcCategoryInfo); } else { // insert category into current database TrgCategoryNid = this.InsertIntoDatabase(SrcCategoryInfo); } #region -- insert/update sub categories into current database -- // insert/update only if target category parent nid is equal to -1 (means at level1) if (TrgCategoryParentNid == -1) { foreach (DI7MetadataCategoryInfo SrcSubCategory in SrcCategoryInfo.SubCategories.Values) { SrcSubCategory.CategoryNId = 0; SrcSubCategory.ParentNid = TrgCategoryNid; // check sub category exists ( where gid=<src gid> and parent nid=<trg nid> foreach (DataRow TrgSubCategoryRow in TrgCategoryTable.Select(Metadata_Category.CategoryGId + "='" + DIQueries.RemoveQuotesForSqlQuery(SrcSubCategory.CategoryGID) + "' AND " + Metadata_Category.ParentCategoryNId + "=" + TrgCategoryNid)) { // if exists then get nid SrcSubCategory.CategoryNId = Convert.ToInt32(TrgSubCategoryRow[Metadata_Category.CategoryNId]); } if (SrcSubCategory.CategoryNId > 0) { // update sub category into current database this.UpdateMetadataCategory(SrcSubCategory); } else { // insert sub category into current database this.InsertIntoDatabase(SrcSubCategory); } } } #endregion } } catch (Exception ex) { ExceptionHandler.ExceptionFacade.ThrowException(ex); } }
/// <summary> /// Imports metadata from the source database into current database /// </summary> /// <param name="srcConnection"></param> /// <param name="srcQueries"></param> /// <param name="srcElementNid"></param> /// <param name="trgElementNid"></param> /// <param name="categoryType"></param> /// <param name="metadataType"></param> /// <param name="iconType"></param> public void ImportMetadata(DIConnection srcConnection, DIQueries srcQueries, int srcElementNid, int trgElementNid, MetadataElementType categoryType, MetaDataType metadataType, IconElementType iconType) { string SrcCategoryGID = string.Empty; string MetadataText = string.Empty; int TrgCategoryNid = 0; DataTable TrgCategoryTable = null; Dictionary<String, String> OldIconNIdnNewIconNId = new Dictionary<string, string>(); try { // Get target Category table TrgCategoryTable = this.DBConnection.ExecuteDataTable(this.DBQueries.Metadata_Category.GetMetadataCategories(FilterFieldType.Type, DIQueries.MetadataElementTypeText[categoryType])); // update metadata icon in DICon table OldIconNIdnNewIconNId = DIIcons.ImportElement(srcElementNid, trgElementNid, iconType, srcQueries, srcConnection, this.DBQueries, this.DBConnection); //get source metadata reports foreach (DataRow SrcRow in srcConnection.ExecuteDataTable(srcQueries.MetadataReport.GetMetadataReportsByTargetNid(srcElementNid.ToString(), categoryType)).Rows) { SrcCategoryGID = Convert.ToString(SrcRow[Metadata_Category.CategoryGId]); // check source category GID exists in current database // Import metadta report only if category exists in current database foreach (DataRow TrgCategoryRow in TrgCategoryTable.Select(Metadata_Category.CategoryGId + "='" + DIQueries.RemoveQuotesForSqlQuery(SrcCategoryGID) + "' ")) { MetadataText = Convert.ToString(SrcRow[MetadataReport.Metadata]); // Update IconNids in metadata if exists foreach (string OldIconName in OldIconNIdnNewIconNId.Keys) { MetadataText = MetadataText.Replace(OldIconName, OldIconNIdnNewIconNId[OldIconName].ToString()); } TrgCategoryNid = Convert.ToInt32(TrgCategoryRow[Metadata_Category.CategoryNId]); this.InsertORUpdateMetadataInfo(metadataType, TrgCategoryNid.ToString(), trgElementNid, MetadataText); } } } catch (Exception ex) { ExceptionHandler.ExceptionFacade.ThrowException(ex); } }
void MetadataConverter_WrongMetdataFoundEvent(MetadataElementType elementType, string name, string GID) { // check n create list object if (this._WrongMetadataElementList == null) { this._WrongMetadataElementList = new SortedDictionary<MetadataElementType, List<string>>(); } // check n create element type key into dictionary object if (!this._WrongMetadataElementList.ContainsKey(elementType)) { this._WrongMetadataElementList.Add(elementType, new List<string>()); } // add name into list if doesnt exist if (!this._WrongMetadataElementList[elementType].Contains(name)) { this._WrongMetadataElementList[elementType].Add(name); } }
/// <summary> /// Export metadata to excel file /// </summary> /// <param name="ExcelFilePath">Excel File Path to be written as export data</param> public void ExportMetaDataToExcel(string ExcelFilePath, MetadataElementType elementType, string elementName, string elementGId,int targetElementNID) { try { // --Open excel and get first worksheet this.DiExcel = new DIExcel(ExcelFilePath); MetadataSheet = DiExcel.GetWorksheet(0); // --Set Matadata Type in Cell 0,0 switch (elementType) { case MetadataElementType.Indicator: SetMetadataCommonCellValues(DILanguage.GetLanguageString("INDICATOR") + "-" + DILanguage.GetLanguageString("METADATA"), elementName, elementGId); break; case MetadataElementType.Area: SetMetadataCommonCellValues(DILanguage.GetLanguageString("AREA") + "-" + DILanguage.GetLanguageString("METADATA"), elementName, elementGId); break; case MetadataElementType.Source: SetMetadataCommonCellValues(DILanguage.GetLanguageString("SOURCE") + "-" + DILanguage.GetLanguageString("METADATA"), elementName, elementGId); break; default: break; } // --Load data from xml to excel file this.LoadData(elementType,targetElementNID); //-- Save excel this.DiExcel.Save(); } catch (Exception ex) { } }
public bool ImportMetataFromExcel(MetadataElementType categoryType, MetaDataType metadataType, int elementNId, string xlsFileNameWPath, string xsltFldrPath) { bool RetVal = true; string MetadataText = string.Empty; string FirstColumnValue = string.Empty; string SecondColumnValue = string.Empty; string ThirdColumnValue = string.Empty; string ElementName = string.Empty; string ElementGID = string.Empty; DataTable ExcelDataTable = null; DataRow Row; DI7MetaDataBuilder MDBuilder; DI7MetadataCategoryBuilder MDCategoryBuilder; DI7MetadataCategoryInfo MetadataCategory; DIExcel ExcelFile = null; try { // -- Get data table from excel file ExcelFile = new DIExcel(xlsFileNameWPath); ExcelDataTable = ExcelFile.GetDataTableFromSheet(ExcelFile.GetSheetName(0)); // -- create database builder objects MDCategoryBuilder = new DI7MetadataCategoryBuilder(this.DBConnection, this.DBQueries); MDBuilder = new DI7MetaDataBuilder(this.DBConnection, this.DBQueries); // -- import metadata reports with category for (int RowIndex = 1; RowIndex < ExcelDataTable.Rows.Count; RowIndex++) { Row = ExcelDataTable.Rows[RowIndex]; FirstColumnValue = Convert.ToString(Row[0]); SecondColumnValue = Convert.ToString(Row[1]); ThirdColumnValue = Convert.ToString(Row[2]); // get element name if (string.IsNullOrEmpty(ElementName)) { if (string.IsNullOrEmpty(FirstColumnValue)) { break; } else { ElementName = FirstColumnValue; continue; } } // get element gid/id if (string.IsNullOrEmpty(ElementGID)) { if (string.IsNullOrEmpty(FirstColumnValue)) { break; } else { ElementGID = FirstColumnValue; // get element nid by element gid if (metadataType == MetaDataType.Source) { elementNId = this.GetElementNidByGID(ElementName, metadataType); } else { elementNId = this.GetElementNidByGID(ElementGID, metadataType); } // Skip title row by incrementing row index RowIndex++; continue; } } // continue if row is blank if (string.IsNullOrEmpty(FirstColumnValue) && string.IsNullOrEmpty(SecondColumnValue) && string.IsNullOrEmpty(ThirdColumnValue)) { // reset element value elementNId = 0; ElementName = string.Empty; ElementGID = string.Empty; continue; } else if (elementNId > 0) { // import metadata report with metadata category // get metadata category and metedata report MetadataCategory = new DI7MetadataCategoryInfo(); MetadataCategory.CategoryName = SecondColumnValue; MetadataCategory.CategoryGID = FirstColumnValue; MetadataCategory.CategoryType = DIQueries.MetadataElementTypeText[categoryType]; // import metadata category MetadataCategory.CategoryNId = MDCategoryBuilder.CheckNInsertCategory(MetadataCategory); // import metadata report if (MetadataCategory.CategoryNId > 0) { MDBuilder.InsertORUpdateMetadataInfo(metadataType, MetadataCategory.CategoryNId.ToString(), elementNId, this.ReplaceNewLineInMetadataReport(ThirdColumnValue)); } } } } catch (Exception) { RetVal = false; } finally { if (ExcelFile != null) { ExcelFile.Close(); } } return(RetVal); }
private DataTable GetMetadataReportsTableFrmDB(int elementNid, MetadataElementType elementType) { DataTable RetVal = null; // get indicator metadata from metadatareport table RetVal = this.DBConnection.ExecuteDataTable(this.DBQueries.MetadataReport.GetMetadataReportsByTargetNid(elementNid.ToString(), elementType)); return RetVal; }
protected int GetElementXsltNidFrmDB(MetadataElementType mdElementtype, int elementNid) { int RetVal = -1; foreach (DataRow Row in this.DBConnection.ExecuteDataTable(this.DBQueries.Xslt.GetElementXSLTTable(elementNid.ToString(),mdElementtype)).Rows) { RetVal = Convert.ToInt32(Row[EelementXSLT.ElementXSLTNId]); break; } return RetVal; }
private void CreateIndicatorTransformInfo(string XSLTText, string XsltFilename, string elementNId, MetadataElementType elementType) { // -- this function insert the values into RT_XSLT table string SqlString = string.Empty; try { int XsltNid = 0; // -- step1 : check xslt info already exists or not SqlString = this.DBQueries.Xslt.GetXSLT(FilterFieldType.Name, XsltFilename); if (this.DBConnection.ExecuteDataTable(SqlString).Rows.Count == 0) { //-- step 2: insert into xslt table SqlString = DALQueries.Xslt.Insert.InsertXSLT(this.DBQueries.DataPrefix, DICommon.RemoveQuotes(XSLTText), DICommon.RemoveQuotes(XsltFilename)); this.DBConnection.ExecuteNonQuery(SqlString); } else { //-- step 2: Update xslt table SqlString = DALQueries.Xslt.Update.UpdateXSLT(this.DBQueries.DataPrefix, DICommon.RemoveQuotes(XSLTText), XsltFilename); this.DBConnection.ExecuteNonQuery(SqlString); } //-- step 3: find the xslt_nid against xslFilename SqlString = this.DBQueries.Xslt.GetXSLT(FilterFieldType.Name, XsltFilename); // -- step 4: insert into Element_xslt table XsltNid = Convert.ToInt32(this.DBConnection.ExecuteScalarSqlQuery(SqlString)); SqlString = DALQueries.Xslt.Insert.InsertElementXSLT(this.DBQueries.DataPrefix, Convert.ToInt32(elementNId), elementType, Convert.ToInt32(XsltNid)); this.DBConnection.ExecuteNonQuery(SqlString); } catch (Exception ex) { throw new ApplicationException(ex.ToString()); } }
/// <summary> /// Updates ElementXslt table /// </summary> /// <param name="elementNid"></param> /// <param name="mdElementType"></param> /// <returns></returns> protected bool UpdateElementXsltTable(int elementNid,MetadataElementType mdElementType,string mdXslTtype) { bool RetVal = false; int XsltNid = 0; int ElementXsltNid = 0; try { // 1. get xslt nid from XSLT table XsltNid = this.GetXslNidFrmXSLTTable(mdXslTtype); if (XsltNid > 0) { // 2. check record exists in Element_Xslt table or not ElementXsltNid = this.GetElementXsltNidFrmDB(mdElementType, elementNid); // 3. If not then insert record if (ElementXsltNid <= 0) { this.DBConnection.ExecuteNonQuery(DevInfo.Lib.DI_LibDAL.Queries.Xslt.Insert.InsertElementXSLT(this.DBQueries.DataPrefix, elementNid, mdElementType, XsltNid)); } else { // 4. if exists then update record this.DBConnection.ExecuteNonQuery(DevInfo.Lib.DI_LibDAL.Queries.Xslt.Update.UpdateElementXSLT(this.DBQueries.DataPrefix, XsltNid, elementNid, mdElementType)); } RetVal = true; } } catch (Exception ex) { ExceptionFacade.ThrowException(ex); } return RetVal; }
private void AddWrongMetadataElement(SortedDictionary <MetadataElementType, List <string> > wrongMetadataElementList, MetadataElementType metadataType) { DataTable Table = new DataTable(); DataRow Row; Table.Columns.Add(metadataType.ToString() + " Name"); // add indicators if (wrongMetadataElementList.ContainsKey(metadataType)) { foreach (string ElementName in wrongMetadataElementList[metadataType]) { Row = Table.NewRow(); Row[0] = ElementName; Table.Rows.Add(Row); } this.LogFile.AddDataTable(Table, metadataType.ToString() + "s where metadata exist in a wrong format:"); } }
/// <summary> /// Main Method for Displaying Metadata /// </summary> /// <param name="elementType"> Element Type.<example>ElementType.All, ElementType.Indicator </example> <seealso cref="DI_MetaInfo.ElementType"/></param> /// <param name="elementNid">ID of selected Data.IND - IndicatorNId, Area - AreaNId, Source - ICNId</param> /// <param name="DI_QueryBase"> This contain Connection Details</param> /// <param name="outPutPath">This contains the path where output files were created</param> /// <param name="outputFileName"> /// this will be the name of outputFile without extention /// which will be created at the output path to display metadata /// <remarks> extension like ".xml" ".xsl" and ".html" are added to this outputFile name /// while creating files </remarks> /// </param> /// <returns> /// </returns> public static bool ExtractXmlMetadata(MetadataElementType metadataElementType, int elementNId, DIConnection DIConnection, DIQueries DIQueries, string outputFolder, string outputFileName, ref string infoTitle) { bool RetVal = false; infoTitle = string.Empty; //Will return the Element name against ElementNId IconElementType IconElementType = IconElementType.MetadataIndicator; XmlDocument XMLDoc = new XmlDocument(); DataTable DTMetaDataInfo = null; string MetadataInfo = string.Empty; String sSql = ""; int LayerNId = -1; string TargetObjectID = string.Empty; Lib.DI_LibSDMX.MetadataTypes SDMXMetadataType = DevInfo.Lib.DI_LibSDMX.MetadataTypes.Indicator; switch (metadataElementType) { case MetadataElementType.Area: IconElementType = IconElementType.MetadataArea; SDMXMetadataType = DevInfo.Lib.DI_LibSDMX.MetadataTypes.Area; //-- Get LayerNId associated with AreaNId if (_LayerNId == -1) { LayerNId = GetLayerNId(elementNId.ToString(), DIConnection, DIQueries); } else { LayerNId = _LayerNId; } //if (LayerNId != -1) //{ // //-- Get Layer Metadata Info // sSql = DIQueries.Area.GetAreaMapMetadata(LayerNId.ToString()); // DTMetaDataInfo = DIConnection.ExecuteDataTable(sSql); // if (DTMetaDataInfo != null & DTMetaDataInfo.Rows.Count > 0) // { // MetadataInfo = DTMetaDataInfo.Rows[0][Area_Map_Metadata.MetadataText].ToString(); // } //} // Set Meta Info title. sSql = DIQueries.Area.GetArea(FilterFieldType.NId, elementNId.ToString()); DTMetaDataInfo = DIConnection.ExecuteDataTable(sSql); if (DTMetaDataInfo != null & DTMetaDataInfo.Rows.Count > 0) { infoTitle = DTMetaDataInfo.Rows[0][Area.AreaName].ToString() + " (" + DTMetaDataInfo.Rows[0][Area.AreaID].ToString() + ")"; TargetObjectID = Convert.ToString(DTMetaDataInfo.Rows[0][Area.AreaID]); } break; case MetadataElementType.Indicator: IconElementType = IconElementType.MetadataIndicator; SDMXMetadataType = DevInfo.Lib.DI_LibSDMX.MetadataTypes.Indicator; sSql = DIQueries.Indicators.GetIndicator(FilterFieldType.NId, elementNId.ToString(), FieldSelection.Heavy); DTMetaDataInfo = DIConnection.ExecuteDataTable(sSql); if (DTMetaDataInfo != null & DTMetaDataInfo.Rows.Count > 0) { infoTitle = DTMetaDataInfo.Rows[0][Indicator.IndicatorName].ToString(); TargetObjectID = Convert.ToString(DTMetaDataInfo.Rows[0][Indicator.IndicatorGId]); } break; case MetadataElementType.Source: IconElementType = IconElementType.MetadataSource; SDMXMetadataType = DevInfo.Lib.DI_LibSDMX.MetadataTypes.Source; sSql = DIQueries.IndicatorClassification.GetIC(FilterFieldType.NId, elementNId.ToString(), ICType.Source, FieldSelection.Heavy); DTMetaDataInfo = DIConnection.ExecuteDataTable(sSql); if (DTMetaDataInfo != null & DTMetaDataInfo.Rows.Count > 0) { infoTitle = DTMetaDataInfo.Rows[0][IndicatorClassifications.ICName].ToString(); TargetObjectID = Convert.ToString(DTMetaDataInfo.Rows[0][IndicatorClassifications.ICGId]); } break; } try { // Get metadata xml file using SDMX library MetadataInfo = Lib.DI_LibSDMX.SDMXUtility.Get_MetadataReport(DevInfo.Lib.DI_LibSDMX.SDMXSchemaType.Two_One, TargetObjectID, SDMXMetadataType, "MDAgency", DIQueries.LanguageCode.Replace("_", ""), DIConnection, DIQueries).InnerXml; DevInfo.Lib.DI_LibBAL.DA.DML.DI7MetaDataBuilder MetadataBuilder = new DevInfo.Lib.DI_LibBAL.DA.DML.DI7MetaDataBuilder(DIConnection,DIQueries); // Get metadata xml file with category name.. XMLDoc = MetadataBuilder.GetMetadataReportWCategoryName(MetadataInfo,metadataElementType); MetadataInfo= XMLDoc.InnerXml; //Write Metadata text to physical file // --Change on 18-03-08 .blank xml with root element will be written in case of no metadata info found in database // If no metadata info create a blank xml file. with root element. if (string.IsNullOrEmpty(MetadataInfo) || MetadataInfo.Trim().Length == 0) { WriteToFile("<?xml version='1.0'?><root ></root >", System.IO.Path.Combine(outputFolder, outputFileName + ".xml")); } else { WriteToFile(MetadataInfo, System.IO.Path.Combine(outputFolder, outputFileName + ".xml")); } // Commented on 18-march -2008. shifted in if else part above. ////WriteToFile(MetadataInfo, System.IO.Path.Combine(outputFolder, outputFileName + ".xml")); } catch (Exception ex) { RetVal = false; } if (MetadataInfo.Trim().Length > 0) { RetVal = true; //Write XLS and HTMLFile try { switch (metadataElementType) { case MetadataElementType.Area: //In Case Area Get Xslt associated with LayerNId (not with AreaNId) sSql = DIQueries.Xslt.GetXSLT(LayerNId.ToString(), metadataElementType); break; case MetadataElementType.Indicator: case MetadataElementType.Source: sSql = DIQueries.Xslt.GetXSLT(elementNId.ToString(), metadataElementType); break; default: break; } DataTable XSLTInfo = (DIConnection.ExecuteDataTable(sSql)); // If XSLT info was Found Write write Xsl and Html file if (XSLTInfo != null & XSLTInfo.Rows.Count > 0) { // Creating Xsl File String xslString = XSLTInfo.Rows[0]["XSLT_Text"].ToString(); WriteToFile(xslString, System.IO.Path.Combine(outputFolder, outputFileName + ".xsl")); //Write HTml file WriteHtmlFile(outputFolder, outputFileName); } } catch (Exception) { } //Extract Images associated with metadata try { if (metadataElementType == MetadataElementType.Area) { ExtractImage(LayerNId, IconElementType, DIConnection, DIQueries, outputFolder); } else { ExtractImage(elementNId, IconElementType, DIConnection, DIQueries, outputFolder); } } catch (Exception) { //Old database may not have Icon table } } infoTitle = infoTitle.Replace("&", "&&"); //label control do not display & character return RetVal; }
/// <summary> /// Returns MetadaataInfo object from the given metadata text /// </summary> /// <param name="mdElementType"></param> /// <returns></returns> private MetadataInfo GetMetadataInfoFrmMetadataText(string metadataText, MetadataElementType mdElementType) { MetadataInfo RetVal = new MetadataInfo(); CategoryInfo Category; XmlDocument XmlDoc; //string ConcatinatedParaNodeText = string.Empty; //XmlElement CategoryNode = default(XmlElement); //XmlNode CategoryXmlNode = null; //DataTable CategoryTable; //XmlElement RootNode = default(XmlElement); //XmlDocument XmldocumentNew = new XmlDocument(); //XmlDeclaration xmlDeclaration = default(XmlDeclaration); //string XmlString = string.Empty; //String ConcatenatedParaNodeText = string.Empty; //string CategoryParaXml; try { //xmlDeclaration = XmldocumentNew.CreateXmlDeclaration("1.0", "utf-8", null); //RootNode = XmldocumentNew.CreateElement(MetadataManagerConstants.Metadata); //XmldocumentNew.InsertBefore(xmlDeclaration, XmldocumentNew.DocumentElement); //XmldocumentNew.AppendChild(RootNode); //--Load xml from database. XmlDoc = new XmlDocument(); XmlDoc.LoadXml(metadataText); //--get categories foreach (XmlNode Node in XmlDoc.SelectNodes("metadata/Category")) { Category = new CategoryInfo(); Category.CategoryName = Convert.ToString(Node.Attributes["name"].Value); Category.CategoryType = DIQueries.MetadataElementTypeText[mdElementType]; // get metadata text from xml's Para node if (Node.ChildNodes.Count > 0) { Category.MetadataText = Convert.ToString(Node.ChildNodes[0].InnerXml); } // add category into metadataInfo object if (!RetVal.Categories.ContainsKey(Category.CategoryName)) { RetVal.Categories.Add(Category.CategoryName, Category); } } //foreach (DataRow CategoryNameRow in CategoryTable.Rows) //{ // Category = new CategoryInfo(); // Category.CategoryName = Convert.ToString(CategoryNameRow[DIColumns.Metadata_Category.CategoryName]); // Category.CategoryType = metadataType.ToString(); // //--Create new xmlelement as Category // CategoryNode = XmldocumentNew.CreateElement(MetadataManagerConstants.Category); // //--Set attribute values of category element. // CategoryNode.SetAttribute(MetadataManagerConstants.NameAttribute, Category.CategoryName); // //--Select Category node with appropriate attribute name(category name) // CategoryXmlNode = XmlDoc.SelectSingleNode(MetadataManagerConstants.CategoryName + Category.CategoryName + MetadataManagerConstants.ClosingSymbol); // //--Add in category collection // if (CategoryXmlNode != null) // { // CategoryParaXml = CategoryXmlNode.InnerXml; // Category.MetadataText = CategoryXmlNode.InnerXml; // //--check for category in collection // if (!RetVal.Categories.ContainsKey(Category.CategoryName)) // { // RetVal.Categories.Add(Category.CategoryName, Category); // } // } //} //return RetVal; } catch { RetVal = null; } return RetVal; }
/// <summary> /// Set language based captions for metadata fields in main data table (mdtData) /// </summary> /// <param name="MetadataFields">Comma delimited metadata fields. MD_IND_1,MD_IND_3...</param> /// <param name="MaskFilePath">Mask file path with extension</param> /// <param name="languageCode">language code against which caption shall be picked from mask file. en / fr / ru ...</param> private void SetMetadataCaption(MetadataElementType metadataElementType, string MetadataFields, string MaskFilePath) { string[] arrSelectedMetadataFields = null; DataTable MetadataTable = null; string CategoryType = string.Empty; // I / A / S string MetadataPrefix = string.Empty; //MD_IND_, MD_SRC_ switch (metadataElementType) { case MetadataElementType.Indicator: MetadataTable = this._MetadataIndicator; CategoryType = DIQueries.MetadataElementTypeText[MetadataElementType.Indicator]; MetadataPrefix = UserPreference.UserPreference.DataviewPreference.MetadataIndicator; break; case MetadataElementType.Area: MetadataTable = this._MetadataArea; CategoryType = DIQueries.MetadataElementTypeText[MetadataElementType.Area]; MetadataPrefix = UserPreference.UserPreference.DataviewPreference.MetadataArea; break; case MetadataElementType.Source: MetadataTable = this._MetadataSource; // Set Category Type CategoryType = DIQueries.MetadataElementTypeText[MetadataElementType.Source]; MetadataPrefix = UserPreference.UserPreference.DataviewPreference.MetadataSource; break; } // Get Metadata fields from userPreference arrSelectedMetadataFields = MetadataFields.Split(",".ToCharArray(), System.StringSplitOptions.RemoveEmptyEntries); if (this._CensusInfoFeature) { try { string _Query = this.mdIQueries.Metadata_Category.GetMetadataCategories(FilterFieldType.Type, CategoryType); DataView dvMetadataCategory = this.ExecuteInvariantDataTable(_Query).DefaultView; //Set Metadata captions for (int i = 0; i < arrSelectedMetadataFields.Length; i++) { // Filter for Category dvMetadataCategory.RowFilter = Metadata_Category.CategoryNId + " = " + arrSelectedMetadataFields[i].Replace(MetadataPrefix, ""); // Get Caption from Mask file based on current interface language if (dvMetadataCategory != null && dvMetadataCategory.Count > 0) { // Set Column caption for both main table as well as metadata master tables this._MainDataTable.Columns[arrSelectedMetadataFields[i]].Caption = dvMetadataCategory[0][Metadata_Category.CategoryName].ToString(); MetadataTable.Columns[arrSelectedMetadataFields[i]].Caption = dvMetadataCategory[0][Metadata_Category.CategoryName].ToString(); } } } catch (Exception) { } } else { string languageCode = DILanguage.GetLanguageString("LANGUAGE_CODE"); XmlDocument MaskFileDocument = new XmlDocument(); XmlNodeList MaskNodeList; XmlNode MaskCaptionNode; // Check for existence of indicator mask file if (File.Exists(MaskFilePath)) { try { // Try loading indicator mask file MaskFileDocument.Load(MaskFilePath); //Set Metadata captions for (int i = 0; i < arrSelectedMetadataFields.Length; i++) { // Get position information from mask file MaskNodeList = MaskFileDocument.SelectNodes("*/*[ID='" + arrSelectedMetadataFields[i] + "']"); //root/Input1/ID // Get Caption from Mask file based on current interface language //TODO Remove Hardcoding "Caption" if (MaskNodeList[0].SelectNodes("Caption[@lang='" + languageCode + "']") != null) { MaskCaptionNode = MaskNodeList[0].SelectNodes("Caption[@lang='" + languageCode + "']")[0]; if (MaskCaptionNode != null) { // Set Column caption for both main table as well as metadata master tables this._MainDataTable.Columns[arrSelectedMetadataFields[i]].Caption = MaskCaptionNode.InnerText; MetadataTable.Columns[arrSelectedMetadataFields[i]].Caption = MaskCaptionNode.InnerText; } } } } catch (Exception) { } } } }