/// <summary>
/// Updating XSLT from Resourse File into database.
/// </summary>
/// <param name="dataprefix"></param>
public void UpdateXSLT(string dataprefix)
{
string xsltString = DI7MetadataCategoryBuilder.GetMetadataXslt();
string SqlQuery = DevInfo.Lib.DI_LibDAL.Queries.Xslt.Update.UpdateXSLT(dataprefix, DICommon.RemoveQuotes(xsltString));
this.DBConnection.ExecuteNonQuery(SqlQuery);
}
/// <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 DI7MetadataCategoryInfo GetMedataCategoryInfo(DataTable table)
{
DI7MetadataCategoryInfo RetVal = new DI7MetadataCategoryInfo();
foreach (DataRow Row in table.Rows)
{
RetVal = DI7MetadataCategoryBuilder.GetMetadataCategoryInfo(Row, this.DBConnection, this.DBQueries);
break;
}
return(RetVal);
}
private void CheckNInsertMetadataReportXml(XmlDocument XmlDoc, int targetNid, bool isNameAttributeExist, string metadataTypeText)
{
XmlNamespaceManager nsManager = new XmlNamespaceManager(XmlDoc.NameTable);
DI7MetadataCategoryBuilder MDBuilder = new DI7MetadataCategoryBuilder(this.DBConnection, this.DBQueries);
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");
XmlNodeList NodeListObj = null;
try
{
//-- this code not wotk due to "name" attribute
//SDMXObjectModel.Message.GenericMetadataType Obj = new SDMXObjectModel.Message.GenericMetadataType();
//Obj = (SDMXObjectModel.Message.GenericMetadataType)SDMXObjectModel.Deserializer.LoadFromXmlDocument(typeof(SDMXObjectModel.Message.GenericMetadataType), XmlDoc);
NodeListObj = XmlDoc.SelectNodes(METADATASET_XPATH, nsManager);
foreach (XmlNode Node in NodeListObj[0].ChildNodes)
{
if (Node.Name == REPORT_ELEMENT)
{
foreach (XmlNode ReportNode in Node.ChildNodes)
{
if (ReportNode.Name == ATTRIBUTESET_ELEMENT)
{
this.InsertMetadataReportFromXML(targetNid, isNameAttributeExist, MDBuilder, ReportNode, metadataTypeText, -1);
}
}
}
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <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);
}
}
private void InsertMetadataReportFromXML(int targetNid, bool isNameAttributeExist, DI7MetadataCategoryBuilder MDBuilder, XmlNode ReportNode, string metadataTypeText, int categoryParentNId)
{
string MDCategotyID = string.Empty;
string MDCategotyName = string.Empty;
DI7MetadataCategoryInfo MDCateInfo = null;
int CategotyNid = -1;
foreach (XmlNode ReportAttNode in ReportNode.ChildNodes)
{
if (ReportAttNode.Name == ATTRIBUTESET_ELEMENT)
{
this.InsertMetadataReportFromXML(targetNid, isNameAttributeExist, MDBuilder, ReportAttNode, metadataTypeText, categoryParentNId);
}
if (ReportAttNode.Name == "ReportedAttribute")
{
MDCategotyID = Convert.ToString(ReportAttNode.Attributes[ID_ATTRIBUTE].Value);
if (isNameAttributeExist)
{
MDCategotyName = Convert.ToString(ReportAttNode.Attributes[NAME_ATTRIBUTE].Value);
}
else
{
MDCategotyName = MDCategotyID;
}
try
{
if (!string.IsNullOrEmpty(ReportAttNode.InnerXml) && Convert.ToString(ReportAttNode[COMMONTEXT_ELEMENT].Attributes[XMLLANG_ATTRIBUTE].Value).Trim('_') == this.DBQueries.LanguageCode.Trim('_'))
{
string MetadataReport = Convert.ToString(ReportAttNode[COMMONTEXT_ELEMENT].InnerText);
if (!string.IsNullOrEmpty(MetadataReport))
{
MDCateInfo = new DI7MetadataCategoryInfo();
MDCateInfo.CategoryGID = MDCategotyID;
MDCateInfo.CategoryName = MDCategotyName;
MDCateInfo.CategoryType = metadataTypeText;
MDCateInfo.ParentNid = categoryParentNId;
CategotyNid = MDBuilder.CheckNInsertCategory(MDCateInfo);
//--
this.DBConnection.ExecuteNonQuery(DevInfo.Lib.DI_LibDAL.Queries.MetadataReport.Insert.InsertMetadataReport(this.DBQueries.TablesName.MetadataReport, targetNid.ToString(), CategotyNid.ToString(), MetadataReport));
if (ReportAttNode.ChildNodes.Count > 0)
{
this.InsertMetadataReportFromXML(targetNid, isNameAttributeExist, MDBuilder, ReportAttNode, metadataTypeText, CategotyNid);
}
}
else
{
//this.DBConnection.ExecuteNonQuery(DevInfo.Lib.DI_LibDAL.Queries.MetadataReport.Delete.DeleteMetadataReport(this.DBQueries.TablesName.MetadataReport, targetNid.ToString(), CategotyNid.ToString()));
}
}
}
catch (Exception ex)
{
throw 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);
}
/// <summary>
/// Imports area metadata from template/database
/// </summary>
/// <param name="dataPrefix"></param>
/// <param name="sourceDBConnection"></param>
/// <param name="sourceDBQueries"></param>
/// <param name="selectedNIDs"></param>
/// <param name="selectionCount"></param>
/// <param name="metadataType"></param>
public void ImportAreaMetadata(string dataPrefix, DIConnection sourceDBConnection, DIQueries sourceDBQueries, string selectedNIDs, int selectionCount, MetaDataType metadataType)
{
DataTable TempDataTable;
int CurrentRecordIndex = 0;
DI7MetadataCategoryBuilder AreaMetadataCategoryBuilder;
DataTable TempTargetTable;
try
{
this.RaiseStartProcessEvent();
// import area categories
AreaMetadataCategoryBuilder = new DI7MetadataCategoryBuilder(this.DBConnection, this.DBQueries);
AreaMetadataCategoryBuilder.ImportAllMetadataCategories(sourceDBConnection, sourceDBQueries, MetadataElementType.Area);
if (selectionCount == -1)
{
// -- GET ALL
TempDataTable = sourceDBConnection.ExecuteDataTable(sourceDBQueries.Area.GetAreaMapMetadata(string.Empty));
}
else
{
// -- GET SELECTED
TempDataTable = sourceDBConnection.ExecuteDataTable(sourceDBQueries.Area.GetAreaMapMetadata(selectedNIDs));
}
// -- Initialize Progress Bar
this.RaiseBeforeProcessEvent(TempDataTable.Rows.Count);
CurrentRecordIndex = 0;
//import area metadata
foreach (DataRow Row in TempDataTable.Rows)
{
CurrentRecordIndex++;
//-- Get Target table against LayerName
TempTargetTable = this.DBConnection.ExecuteDataTable(this.DBQueries.Area.GetAreaMapMetadataByName(
Row[Area_Map_Metadata.LayerName].ToString()));
foreach (DataRow TrgRow in TempTargetTable.Rows)
{
this.ImportMetadata(sourceDBConnection, sourceDBQueries, Convert.ToInt32(Row[Area_Map_Layer.LayerNId]), Convert.ToInt32(TrgRow[Area_Map_Layer.LayerNId]), MetadataElementType.Area, MetaDataType.Map, IconElementType.MetadataArea);
break;
}
// -- Increemnt the Progress Bar Value
this.RaiseProcessInfoEvent(CurrentRecordIndex);
}
}
catch (Exception ex)
{
throw new ApplicationException(ex.ToString());
}
finally
{
this.RaiseEndProcessEvent();
}
}
/// <summary>
/// Imports source metadata from template/database
/// </summary>
/// <param name="dataPrefix"></param>
/// <param name="sourceDBConnection"></param>
/// <param name="sourceDBQueries"></param>
/// <param name="selectedNIDs"></param>
/// <param name="selectionCount"></param>
/// <param name="metadataType"></param>
public void ImportSourceMetadata(string dataPrefix, DIConnection sourceDBConnection, DIQueries sourceDBQueries, string selectedNIDs, int selectionCount, MetaDataType metadataType)
{
DataTable TempDataTable;
ICType ClassificationType;
int CurrentRecordIndex = 0;
int SrcElementNid;
int TrgElementNid;
DI7MetadataCategoryBuilder SourceMetadataCategoryBuilder;
SourceBuilder ICBuilder;
try
{
this.RaiseStartProcessEvent();
ICBuilder = new SourceBuilder(this.DBConnection, this.DBQueries);
// import source categories
SourceMetadataCategoryBuilder = new DI7MetadataCategoryBuilder(this.DBConnection, this.DBQueries);
SourceMetadataCategoryBuilder.ImportAllMetadataCategories(sourceDBConnection, sourceDBQueries, MetadataElementType.Source);
ClassificationType = ICType.Source;
if (selectionCount == -1)
{
// -- GET ALL
TempDataTable = sourceDBConnection.ExecuteDataTable(sourceDBQueries.IndicatorClassification.GetIC(FilterFieldType.None, string.Empty, ClassificationType, FieldSelection.Heavy));
}
else
{
// -- GET SELECTED
TempDataTable = sourceDBConnection.ExecuteDataTable(sourceDBQueries.IndicatorClassification.GetIC(FilterFieldType.NId, selectedNIDs, ClassificationType, FieldSelection.Heavy));
}
////// -- Initialize Progress Bar
this.RaiseBeforeProcessEvent(TempDataTable.Rows.Count);
CurrentRecordIndex = 0;
foreach (DataRow Row in TempDataTable.Rows)
{
CurrentRecordIndex++;
SrcElementNid = Convert.ToInt32(Row[IndicatorClassifications.ICNId]);
TrgElementNid = ICBuilder.CheckSourceExists(Convert.ToString(Row[IndicatorClassifications.ICName]));
// import source metadadta
if (TrgElementNid > 0)
{
this.ImportMetadata(sourceDBConnection, sourceDBQueries, SrcElementNid, TrgElementNid, MetadataElementType.Source, MetaDataType.Source, IconElementType.MetadataSource);
}
////// -- Increemnt the Progress Bar Value
this.RaiseProcessInfoEvent(CurrentRecordIndex);
}
// -- Dispose the Data Table object
TempDataTable.Dispose();
}
catch (Exception ex)
{
throw new ApplicationException(ex.ToString());
}
}
/// <summary>
/// Imports indicator metadata from template/database
/// </summary>
/// <param name="dataPrefix"></param>
/// <param name="sourceDBConnection"></param>
/// <param name="sourceDBQueries"></param>
/// <param name="selectedNIDs"></param>
/// <param name="selectionCount"></param>
/// <param name="metadataType"></param>
public void ImportIndicatorMetadata(string dataPrefix, DIConnection sourceDBConnection, DIQueries sourceDBQueries, string selectedNIDs, int selectionCount, MetaDataType metadataType)
{
DataTable TempDataTable;
int CurrentRecordIndex = 0;
DI7MetadataCategoryBuilder MetadataCategoryBuilderObj;
IndicatorInfo SourceIndicatorInfo = new IndicatorInfo();
IndicatorBuilder IndBuilder = null;
try
{
this.RaiseStartProcessEvent();
IndBuilder = new IndicatorBuilder(this.DBConnection, this.DBQueries);
// 1. import metadta categories
// import indicator metadata categories
MetadataCategoryBuilderObj = new DI7MetadataCategoryBuilder(this.DBConnection, this.DBQueries);
MetadataCategoryBuilderObj.ImportAllMetadataCategories(sourceDBConnection, sourceDBQueries, MetadataElementType.Indicator);
// 2. Imort metadata reports
if (selectionCount == -1)
{
// -- GET ALL
TempDataTable = sourceDBConnection.ExecuteDataTable(sourceDBQueries.Indicators.GetIndicator(FilterFieldType.None, string.Empty, FieldSelection.Heavy));
}
else
{
// -- GET SELECTED
TempDataTable = sourceDBConnection.ExecuteDataTable(sourceDBQueries.Indicators.GetIndicator(FilterFieldType.NId, selectedNIDs, FieldSelection.Heavy));
}
//////// -- Initialize Progress Bar
this.RaiseBeforeProcessEvent(TempDataTable.Rows.Count);
foreach (DataRow Row in TempDataTable.Rows)
{
CurrentRecordIndex++;
// get source indicator info
SourceIndicatorInfo = new IndicatorInfo();
SourceIndicatorInfo.Nid = Convert.ToInt32(Row[Indicator.IndicatorNId]);
SourceIndicatorInfo.GID = Convert.ToString(Row[Indicator.IndicatorGId]);
SourceIndicatorInfo.Name = Convert.ToString(Row[Indicator.IndicatorName]);
SourceIndicatorInfo.Global = Convert.ToBoolean(Row[Indicator.IndicatorGlobal]);
//import metadata
IndBuilder.ImportIndicatorMetadata(SourceIndicatorInfo, SourceIndicatorInfo.Nid, sourceDBQueries, sourceDBConnection);
// -- Increemnt the Progress Bar Value
this.RaiseProcessInfoEvent(CurrentRecordIndex);
}
}
catch (Exception ex)
{
throw new ApplicationException(ex.ToString());
}
finally
{
this.RaiseEndProcessEvent();
}
}
