private void saveFTPConnection()
{
try
{
//_dbcontext = new InnonAnalyticsEngineEntities();
tblConnector objtblConnector = _dbcontext.tblConnectors.SingleOrDefault(t => t.ID == this._connectorDTO.ConnectionID);
if (objtblConnector == null)
{
ConnectorDTO.ConvertDTOToTable(this._connectorDTO, ref objtblConnector);
_dbcontext.tblConnectors.Add(objtblConnector);
//ConnectorConvert.ConvertDTOtoTable(this._dataconnector, ref objtblConnector);
//_dbcontext.tblConnectors.Add(objtblConnector);
}
else
{
ConnectorDTO.ConvertDTOToTable(this._connectorDTO, ref objtblConnector);
}
_dbcontext.SaveChanges();
}
catch (Exception ex)
{
throw ex;
}
}
public IList <RawDataDTO> Get_Raw_Data_By_Element_Id(long element_id)
{
try
{
tblElement tbl_element = _dbcontext.tblElements.Find(element_id);
if (tbl_element?.Connector_History_ID != null)
{
//Get connection information
int connection_id = (int)tbl_element.Connector_History_ID;
ConnectorDTO _dto_connector = _connector_rep.GetExistingConnectionById(connection_id);
InnonAnalyticsEngineEntities __dbcontext = new InnonAnalyticsEngineEntities();
IRawDataRepository _rawDataRepository = new RawDataRepository();
DateTime fromDate = DateTime.Now.AddMonths(-6);
DateTime ToDate = DateTime.Now;
return(_rawDataRepository.GetRowData(tbl_element.Source_Element_Name_History, fromDate, ToDate, _dto_connector, __dbcontext));
}
return(null);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Get UnStructuce Elements
/// </summary>
/// <param name="strDataConnectorType, iDataConnectorID"></param>
/// <returns></returns>
//public IList<DiscoveryElementDTO> GetDiscoveryViewModel(string strDataConnectorType,int iDataConnectorID)
//{
// try
// {
// return GetNonDiscoverElementByConnectorID(strDataConnectorType, iDataConnectorID);
// }
// catch (ConnectorException conex)
// {
// throw conex;
// }
//}
/// <summary>
/// Getiing the table onformation from the Database nad obix points
/// </summary>
/// <param name="strDataConnectorType"></param>
/// <param name="iDataConnectorID"></param>
/// <returns>IList<DiscoveryElementDTO></returns>
public IList <DiscoveryPoint_DTO> GetNonDiscoverElementByConnectorID(int iDataConnectorID)
{
ConnectorDTO objDataConnectorDTO = _objConectorRepository.GetExistingConnectionById(iDataConnectorID);
IList <ElementDTO> strucutredlist = _objElementRepository.GetElementByConnectionID(iDataConnectorID);
ExistingConnectionNameDTO objExistingConnectionNameDTO = ExistingConnectionNameDTO.ConvertTableToDTO(objDataConnectorDTO);
try
{
if (objExistingConnectionNameDTO.DataConnectorType == Common.Enums.DataSouceConnectionType.Live)
{
ILiveVariable obix = new Obix(objDataConnectorDTO.ServerOrIP, objDataConnectorDTO.ServerUserName, objDataConnectorDTO.ServerPassword);
IList <LivePointModel> list_of_Live_Point = obix.GetPoints(objDataConnectorDTO.ServerOrIP);
return(DiscoveryPoint_DTO_Conversion.ConvertTableToDTO(list_of_Live_Point, objExistingConnectionNameDTO.ConnectionID, objExistingConnectionNameDTO.ConnectionID, strucutredlist).ToList());
//return DiscoveryElementDTO.ConvertTableToDTO(list_of_Live_Point, objExistingConnectionNameDTO, strucutredlist).ToList();
}
else
{
_objRawTableName.GetRowTableNames(objDataConnectorDTO.ServerOrIP, objDataConnectorDTO.ServerUserName, objDataConnectorDTO.ServerPassword, objDataConnectorDTO.DatabaseName);
return(DiscoveryPoint_DTO_Conversion.ConvertTableToDTO(_objRawTableName.RowTableNames, objExistingConnectionNameDTO, strucutredlist).ToList());
}
}
catch (ConnectorException conex)
{
throw conex;
}
}
public IList <DiscoveryPoint_DTO> GetNonDiscoverElementByConnectorID(int iDataConnectorID, string Element_Source_ID, int parent_id)
{
ConnectorDTO objDataConnectorDTO = _objConectorRepository.GetExistingConnectionById(iDataConnectorID);
IList <ElementDTO> strucutredlist = _objElementRepository.GetElementByConnectionID(iDataConnectorID);
ExistingConnectionNameDTO objExistingConnectionNameDTO = ExistingConnectionNameDTO.ConvertTableToDTO(objDataConnectorDTO);
ILiveVariable obix = new Obix(objDataConnectorDTO.ServerOrIP, objDataConnectorDTO.ServerUserName, objDataConnectorDTO.ServerPassword);
IList <LivePointModel> list_of_Live_Point = obix.GetPoints(Element_Source_ID);
return(DiscoveryPoint_DTO_Conversion.ConvertTableToDTO(list_of_Live_Point, parent_id, objExistingConnectionNameDTO.ConnectionID, strucutredlist).ToList());
}
private void UnlinkProduct(object sender, EventArgs e)
{
if (listBoxUnlinkProducts.SelectedItem != null)
{
ConnectorDTO connector = (ConnectorDTO)listBoxUnlinkProducts.SelectedItem;
Services.HomeDeviceService.UnlinkFromConnector(connector.Id);
UpdateForm();
}
}
public IList <ConnectorDTO> GetExistingConnections()
{
try
{
//_dbcontext = new InnonAnalyticsEngineEntities();
ICollection <tblConnector> objtblConnector = _dbcontext.tblConnectors.ToList();
return(ConnectorDTO.ConvertTableToDTO(objtblConnector));
}
catch
{ throw; }
}
/// <summary>
/// Constructor to create the objects for child object on the basis of DataConnectionType
/// </summary>
/// <param name="strDataConnectionType"></param>
//public ConnectorRepository(string strDataConnectionType)
//{
// _dataConnectorVM = new DataConnectorViewModel();
// if (Enum.IsDefined(typeof(DataSouceConnectionType), strDataConnectionType))
// {
// //every connection can be in different language thats why we need to get all the languagea
// _dataConnectorVM.DataConnectors.NameofConnection = LanguageRepository.GetAllActiveLanguageValue();
// switch ((DataSouceConnectionType)Enum.Parse(typeof(DataSouceConnectionType), strDataConnectionType))
// {
// case DataSouceConnectionType.Database:
// _dataConnectorVM.DataConnectors.objConnectionDatabaseDTO = new ConnectionDataBaseDTO();
// _dataConnectorVM.DataConnectors.DataConnectorConnectionType = DataSouceConnectionType.Database;
// break;
// case DataSouceConnectionType.API:
// _dataConnectorVM.DataConnectors.objConnectionAPIDTO = new ConnectionAPIDTO();
// _dataConnectorVM.DataConnectors.DataConnectorConnectionType = DataSouceConnectionType.API;
// break;
// case DataSouceConnectionType.FTP:
// _dataConnectorVM.DataConnectors.objConnectionFTPDTO = new ConnectionFTPDTO();
// _dataConnectorVM.DataConnectors.DataConnectorConnectionType = DataSouceConnectionType.FTP;
// break;
// default:
// throw new ConnectorException(Resources.DataSouceConnectionTypeInvalid);
// }
// }
// else
// {
// throw new ConnectorException(Resources.DataSouceConnectionTypeInvalid);
// // Handle values not in enum here if needed
// }
//}
/// <summary>
/// This constructor is only for to test
/// </summary>
/// <param name="objDBDTO"></param>
//public ConnectorRepository(DataConnectorsDTO objDataConnectorDTO)
//{
// try
// {
// this._dataconnector = objDataConnectorDTO;
// //this._dbdto = objDataConnectorDTO.objConnectionDatabaseDTO;
// }
// catch(Exception ex)
// {
// throw ex;
// }
//}
public ConnectorRepository(ConnectorDTO objConnectorDTO)
{
try
{
this._connectorDTO = objConnectorDTO;
//this._dbdto = objDataConnectorDTO.objConnectionDatabaseDTO;
}
catch (Exception ex)
{
throw ex;
}
}
private void LinkHomeDeviceToConnector(object sender, EventArgs e)
{
HomeDeviceDTO homeDev = (HomeDeviceDTO)listBoxFreeHomeDevices.SelectedItem;
ConnectorDTO connector = (ConnectorDTO)listBoxCapableFreeConnector.SelectedItem;
if (homeDev != null && connector != null)
{
Services.HomeDeviceService.LinkHomeDevice(connector.Id, homeDev.Id);
UpdateForm();
}
}
private void LinkProduct(object sender, EventArgs e)
{
if (listBoxConnectorsAvailable.SelectedItem != null && comboBoxListProduct.SelectedItem != null)
{
string product = (string)comboBoxListProduct.SelectedItem;
ConnectorDTO connector = (ConnectorDTO)listBoxConnectorsAvailable.SelectedItem;
Services.HomeDeviceService.LinkProduct(connector.Id, product);
UpdateForm();
}
}
public ActionResult DataConnection_TestConnection(ConnectorDTO _dtoConnector)
{
try
{
objConnectorRepository = new ConnectorRepository(_dtoConnector);
objConnectorRepository.TestConnection();
return(Json(new { success = true, message = Resources.Resources.ConnectorTestMessage }));
}
catch (Exception ex)
{
return(Json(new { success = false, message = ex.Message + " " + ex.InnerException.Message }));
}
}
/// <summary>
/// This method is not in use
/// GetRawdata call the stored procedure called (GetRawData) for getting the rawdata for the dataware house
/// </summary>
/// <param name="data_source_name">data_source_name is the table name where we need to get the raw for the Datawarehouse</param>
/// <param name="connectorId"></param>
public IList <RawDataDTO> GetRawData(string data_source_name, ConnectorDTO _dto_connector, InnonAnalyticsEngineEntities _dbcontext)
{
try
{
IEnumerable <RawDataDTO> rawdata = _dbcontext.Database.SqlQuery <RawDataDTO>("EXEC GetRawData '" + _dto_connector.ServerOrIP + "', '" +
_dto_connector.ServerUserName + "' , '" + _dto_connector.ServerPassword + "', '" + _dto_connector.DatabaseName + "' , '" + data_source_name + "'");
return(rawdata.ToList());
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Get connection by ConnectorID this method only use for the Connector Page or for datawarehouse, do not use any other page
/// </summary>
/// <param name="ConnectorID"></param>
/// <returns>ConnectorDTO</returns>
public ConnectorDTO GetExistingConnectionById(int ConnectorID)
{
try
{
//_dbcontext = new InnonAnalyticsEngineEntities();
tblConnector objtblConnector = _dbcontext.tblConnectors.SingleOrDefault(s => s.ID == ConnectorID);
if (objtblConnector == null)
{
throw new ConnectorException(Resources.ConnectorNotFound);
}
return(ConnectorDTO.ConvertTableToDTO(objtblConnector));
}
catch
{ throw; }
}
private static IList <RawDataDTO> GetRawMissingData(ElementDTO element, ConnectorDTO _dto_connector)
{
try
{
//Checking the missing data
InnonAnalyticsWarehouseEntities ctx = new InnonAnalyticsWarehouseEntities();
ctx.Database.CommandTimeout = 300;
IList <RawDataDTO> rawdata = ctx.Database.SqlQuery <RawDataDTO>("EXEC GetRawMissingData '" + _dto_connector.ServerOrIP + "', '" +
_dto_connector.ServerUserName + "' , '" + _dto_connector.ServerPassword + "', '" + _dto_connector.DatabaseName + "' , '" + element.Source_Element_Name_History + "' ,'" + Convert.ToDateTime(System.DateTime.Now.AddYears(-1).ToShortDateString() + " 00:00:00").ToString("yyyy-MM-dd HH:mm:ss.fff") + "','" + System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + "'," + element.ID).ToList();
ctx.Database.Connection.Close();
return(rawdata);
}
catch (Exception ex)
{
throw ex;
}
}
public static List <ConnectorDTO> MappingConnectorDTO(DataTable dt)
{
List <ConnectorDTO> list = new List <ConnectorDTO>();
for (int i = 0; i < dt.Rows.Count; i++)
{
ConnectorDTO dto = new ConnectorDTO();
dto.WF_ID = Convert.ToString(dt.Rows[i]["WF_ID"]);
dto.LINE_ID = Convert.ToString(dt.Rows[i]["LINE_ID"]);
dto.ROW_INDEX = Convert.ToInt32(dt.Rows[i]["ROW_INDEX"]);
dto.COL_INDEX = Convert.ToInt32(dt.Rows[i]["COL_INDEX"]);
dto.STATUS = Convert.ToInt32(dt.Rows[i]["STATUS"]);
list.Add(dto);
}
return(list);
}
public void GetData()
{
IElementRepository _ElementRepository;
IInnonAnalyticsEngineEntities _dbcontext;
_dbcontext = new InnonAnalyticsEngineEntities();
_ElementRepository = new ElementRepository(_dbcontext);
IList <ElementDTO> list_element_dto = _ElementRepository.Get_Element_By_Element_Tag_Type(Common.Enums.TagType.point, false);
// BlockingCollection<ElementDTO> entityQueue = new BlockingCollection<ElementDTO>();
try
{
_dbContext = new InnonAnalyticsEngineEntities();
// for (int j = 0; j < list_element_dto.Count(); j++)
for (int j = 0; j < 1; j++)
{
IConnectorRepository _connector_rep = new ConnectorRepository(_dbContext);
_dto_connector = _connector_rep.GetExistingConnectionById(list_element_dto[j].ConnectionInfo.ConnectionID);
//Task[] taskArray = { Task.Factory.StartNew(() => GetRowsForEachTable(list_element_dto[j]))
// //,Task.Factory.StartNew(() => GetRowsForEachTable(list_element_dto[1]))
// //,Task.Factory.StartNew(() => GetRowsForEachTable(list_element_dto[2]))
// };
Task[] taskArray = { Task.Factory.StartNew(() =>
{
GetRowsForEachTable(list_element_dto[j]);
}
) };
}
}
catch (Exception ex)
{
this.EventLog.WriteEntry("Error GetData " + "- Error" + ex.Message + " - Inner exception " + ex.InnerException, EventLogEntryType.Error);
}
}
public ActionResult DataConnection_Update([DataSourceRequest] DataSourceRequest request, ConnectorDTO _dtoConnector)
{
if (_dtoConnector != null && ModelState.IsValid)
{
_dtoConnector.SessionId = Session.SessionID;
objConnectorRepository = new ConnectorRepository(_dtoConnector);
objConnectorRepository.SaveConnection();
}
return(Json(new[] { _dtoConnector }.ToDataSourceResult(request, ModelState), JsonRequestBehavior.AllowGet));
}
private static IList <RawDataDTO> GetRawData(ElementDTO element, DateTime fromdate, DateTime ToDate, ConnectorDTO _dto_connector, InnonAnalyticsEngineEntities _dbcontext)
{
try
{
IRawDataRepository _rawDataRepository = new RawDataRepository();
return(_rawDataRepository.GetRowData(element.Source_Element_Name_History, Convert.ToDateTime(fromdate.ToString("yyyy-MM-dd HH:mm:ss.fff")), Convert.ToDateTime(ToDate.ToString("yyyy-MM-dd HH:mm:ss.fff")), _dto_connector, _dbcontext));
}
catch (Exception ex)
{
throw ex;
}
}
static void Main(string[] args)
{
try
{
Console.WriteLine("Initialization...... ");
//Aggregate_Save obj = new Aggregate_Save();
//obj.Update_Hour_Aggregation(3628);
// Interpolation.Get_Previous_and_Next_Good_Value(DateTime.Parse("2015-09-01 00:30:00"), 3575);
//data_staus is used for the interpoliation of data
string[] data_status = ConfigurationManagerHelper.AppSettings["bad_data_status"].ToString().Split(',');
InnonAnalyticsEngineEntities _dbcontext = new InnonAnalyticsEngineEntities();
IElementRepository _ElementRepository = new ElementRepository(_dbcontext);
//Get All Elements from the tblElement where Elemet Type is point (point has data)
IList <ElementDTO> list_element_dto = _ElementRepository.Get_Element_By_Element_Tag_Type(Common.Enums.TagType.point, false);
//list_element_dto = list_element_dto.Where(e => e.ID == 2366).ToList();
//GenerateMissingData(list_element_dto[0]);
ITagRepository _TagRepository = new TagRepository(_dbcontext);
//Get All non deleted tag type mapping
IList <Tag_Type_Mapping_DTO> list_tag_type_dto = _TagRepository.Get_Tag_Type_Mapping(false);
Console.WriteLine("Updating point dim ");
IPoint_Dim_Service _Point_dim_service = new Point_Dim_Service();
_Point_dim_service.Update_Point_Dim(list_element_dto, list_tag_type_dto);
Console.WriteLine("Start Data Migration ");
IDatawareHouseMigrationLogRepository _DatawareHouseMigrationLogRepository = new DatawareHouseMigrationLogRepository(_dbcontext);
//Get all element data migration history from [tblDatawareHouseMigrationLog]
IList <DatawareHouseMigrationLogDTO> list_datawaredousemigrationLog_dto = _DatawareHouseMigrationLogRepository.get_Data_Migration_Logs();
//Creat an arry of tasks, Number of Point element found in tblElement table
Task[] taskArray = new Task[list_element_dto.Count];
DateTime starttime = DateTime.Now;
Console.WriteLine("Start " + starttime);
//Initialize Connector Repository for getting the data connection info of each table
IConnectorRepository _connector_rep = _connector_rep = new ConnectorRepository(_dbcontext);
ConnectorDTO _dto_connector = new ConnectorDTO();
//running loop on each task in the task array ()
for (int i = 0; i < taskArray.Length; i++)
{
DateTime default_from_dt, default_to_dt = System.DateTime.Now;;
taskArray[i] = Task.Factory.StartNew(() =>
{
try
{
//First Step get database or data connector information of each points
//The connection info is same as the previous we will not get the connector info again
if (_dto_connector.ConnectionID != list_element_dto[i].ConnectionInfo.ConnectionID)
{
_dto_connector = _connector_rep.GetExistingConnectionById(list_element_dto[i].ConnectionInfo.ConnectionID);
}
//Console.WriteLine("No." + i + " " + _dto_connector.ConnectionID + " -- " + _dto_connector.ConnectionName);
//Sec Step set from_date and to_date
//If the element is not runing first time than change the from datetime (get last run datetime), All log save in the tbldatawaredousemigrationLog
if (list_datawaredousemigrationLog_dto.Any(element => element.Element_ID == list_element_dto[i].ID))
{
DateTime?_timestamp_to = list_datawaredousemigrationLog_dto.Where(element => element.Element_ID == list_element_dto[i].ID).OrderByDescending(t => t.Last_Run_Start).First().Timestamp_To;
if (_timestamp_to.HasValue)
{
default_from_dt = Convert.ToDateTime(_timestamp_to.Value.AddMilliseconds(2).ToString("yyyy-MM-dd,HH:mm:ss.fff"));
// GetRowsForEachTable(list_element_dto[j], _dto_connector, j);
}
else
{
default_from_dt = CheckLastRecordInsterted(list_element_dto[i].ID);
// GetRowsForEachTable(list_element_dto[j], _dto_connector, j);
}
}
else
{
default_from_dt = CheckLastRecordInsterted(list_element_dto[i].ID);
//GetRowsForEachTable(list_element_dto[j], _dto_connector, j);
}
Console.WriteLine("No." + i + " " + list_element_dto[i].ID + " " + default_from_dt + " -- " + default_to_dt);
//End sec
//Third Get Raw Data;
IList <RawDataDTO> list_RawDataDTO = new List <RawDataDTO>();
list_RawDataDTO = GetRawData(list_element_dto[i], default_from_dt, default_to_dt, _dto_connector, _dbcontext);
//End Get Raw Data
Console.WriteLine("Total Records " + list_RawDataDTO.Count());
//Save DataMirgrationLog
tblDatawareHouseMigrationLog tbldatamigrationlog = SaveDataMigrationLog(list_element_dto[i], default_to_dt);
//End
if (list_RawDataDTO.Count > 0)
{
//Get Convert Raw data in to Point_Mesaure_Fact_DTO
IList <Point_Measure_Fact> point_measure_fact_list_dto = Convert_Raw_Data_To_Point_Measure_Fact_DTO(list_element_dto[i], list_RawDataDTO);
//End
//Saving in to the Datawarehouse table Point_Measure_Fact
Final_Insert_In_To_DatawareHouse_Table(point_measure_fact_list_dto);
//End
//Update DataMirgrationLog
if (point_measure_fact_list_dto.Count > 0)
{
UpdateDataMigrationLog(tbldatamigrationlog, point_measure_fact_list_dto.Count(), point_measure_fact_list_dto.LastOrDefault().Timestamp_From);
}
//End
}
//Aggregation
//Task aggregationtask = GetAggregation(list_element_dto[i]);
//EndAggregation
Console.WriteLine("Missing Data " + list_element_dto[i].Source_Element_Name_History);
try
{
//Get Raw missing data if any thing accedently during the process than we need to get the missing data
IList <RawDataDTO> list_Mising_RawDataDTO = GetRawMissingData(list_element_dto[i], _dto_connector);
Console.WriteLine("Get Missing Data " + list_Mising_RawDataDTO.Count);
if (list_Mising_RawDataDTO.Count > 0)
{
//Get Convert Raw data in to Point_Mesaure_Fact_DTO
IList <Point_Measure_Fact> missing_point_measure_fact_list_dto = Convert_Raw_Data_To_Point_Measure_Fact_DTO(list_element_dto[i], list_Mising_RawDataDTO);
//End
//Saving in to the Datawarehouse table Point_Measure_Fact
Final_Insert_In_To_DatawareHouse_Table(missing_point_measure_fact_list_dto);
//End
}
//End End of Raw missing data saving
}
catch (Exception ex)
{
Console.WriteLine("Error in Missing Data " + ex.Message);
}
Console.WriteLine("Generate Missing Data ");
try
{
IList <RawDataDTO> list_Genrated_Mising_RawDataDTO = GenerateMissingData(list_element_dto[i]);
//Get Convert Raw data in to Point_Mesaure_Fact_DTO
IList <Point_Measure_Fact> genrated_missing_point_measure_fact_list_dto = Convert_Raw_Data_To_Point_Measure_Fact_DTO(list_element_dto[i], list_Genrated_Mising_RawDataDTO);
//End
//Saving in to the Datawarehouse table Point_Measure_Fact
Final_Insert_In_To_DatawareHouse_Table(genrated_missing_point_measure_fact_list_dto);
//End
}
catch (Exception ex)
{
Helper.WriteToFile(ex.Message);
}
try
{
//Console.WriteLine("Deleting Data " + list_element_dto[i].Source_Element_Name_History);
//Deleting Any Duplication
Delete_Duplicate(list_element_dto[i]);
//End
}
catch (Exception ex)
{
Console.WriteLine("Error in Delete duplicate Data " + ex.Message);
}
try
{
//Check interpolation
Console.WriteLine("Interpolation");
bool Is_Read_For_Aggregation = Interpolation.InterPolateData(default_from_dt, default_to_dt, list_element_dto[i]);
Console.WriteLine("End Interpolation");
//End Interpolation
if (Is_Read_For_Aggregation)
{
Console.WriteLine("Aggregate Data Migration ");
IAggregation_Service agr_service = new Aggregation_Service();
agr_service.Calculate_and_Save_Aggregation_WareHouse_By_ElementID(list_element_dto[i].ID);
Console.WriteLine("End Aggregate Data Migration ");
}
}
catch (Exception ex)
{
Console.WriteLine("Error in Aggregation Data " + ex.Message);
}
// aggregationtask.Wait();
}
catch (Exception ex)
{
Console.WriteLine("Exception " + ex.Message);
}
});
taskArray[i].Wait();
}
Console.WriteLine("End Min " + DateTime.Now.Subtract(starttime).TotalMinutes);
Console.WriteLine("End Sec " + DateTime.Now.Subtract(starttime).TotalSeconds);
Helper.WriteToFile("Finished Start Time " + starttime + ", End Time " + System.DateTime.Now + " -- " + " Total Min " + DateTime.Now.Subtract(starttime).TotalMinutes);
}
catch (Exception ex)
{
Console.WriteLine("Exception in mian " + ex.Message);
}
//Console.ReadLine();
}
private async static void GetRowsForEachTable(ElementDTO element, ConnectorDTO _dto_connector, int index)
{
try
{
string information_of_element = element.ID + "--" + element.Source_Element_Name_History + " Connection " + _dto_connector.DatabaseName;
InnonAnalyticsEngineEntities _dbContext2 = new InnonAnalyticsEngineEntities();
_dbContext2.Database.CommandTimeout = 300;
//Console.WriteLine("From Date " + default_from_dt);
//Console.WriteLine("To Date " + default_to_dt);
IRawDataRepository _rawDataRepository = new RawDataRepository();
// Console.ReadLine();
//IList<RawDataDTO> rawdata =
Point_Measure_Fact_Service point_measure_fact_service;
tblDatawareHouseMigrationLog data_migration_log = new tblDatawareHouseMigrationLog();
await Task.Run(() =>
{
IList <RawDataDTO> list_RawDataDTO = new List <RawDataDTO>();
try
{
Console.WriteLine("Start For Table " + element.ID + "--" + element.Source_Element_Name_History + " -- From dt " + default_from_dt + " -- To date " + default_to_dt);
list_RawDataDTO = _rawDataRepository.GetRowData(element.Source_Element_Name_History, Convert.ToDateTime(default_from_dt.ToString("yyyy-MM-dd HH:mm:ss.fff")), Convert.ToDateTime(default_to_dt.ToString("yyyy-MM-dd HH:mm:ss.fff")), _dto_connector, _dbContext2);
}
catch (Exception ex)
{
Helper.WriteToFile(" [ " + System.DateTime.Now + " ] First Step fetching the bulk data from error " + ex.Message + " -- " + information_of_element);
}
return(list_RawDataDTO);
})
.ContinueWith((k) =>
{
if (k.Result.Count > 0)
{
try
{
data_migration_log = _dbContext2.tblDatawareHouseMigrationLogs.Add(
new tblDatawareHouseMigrationLog
{
Element_ID = element.ID,
Last_Run_Start = System.DateTime.Now,
Total_Record_Fetch = 0,
Timestamp_From = default_from_dt,
});
_dbContext2.SaveChangesAsync();
}
catch (Exception ex)
{
Helper.WriteToFile(" [ " + System.DateTime.Now + " ] Sec Step saving in to the tblDatawareHouseMigrationLogs data from error " + ex.Message + " -- " + information_of_element);
}
}
return(k.Result);
})
.ContinueWith((x) =>
{
IList <Point_Measure_Fact> point_measure_fact_list_dto = new List <Point_Measure_Fact>();
try
{
// x is last continue result (GetRowData returns the IList<RawData>)
//Save Final insert in to the database InnonAnalyticsWarehouse table Point_Mesaure_Fact
Console.WriteLine("Get Rows for Table " + element.Source_Element_Name_History + " - " + x.Result.Count(), EventLogEntryType.Information);
point_measure_fact_service = new Point_Measure_Fact_Service();
point_measure_fact_service.List_Point_Measure_Fact_Service(x.Result, element);
point_measure_fact_list_dto = point_measure_fact_service.List_Point_Measure_Fact_Service(x.Result, element);
FinalInsert(point_measure_fact_list_dto);
}
catch (Exception ex)
{
Helper.WriteToFile(" [ " + System.DateTime.Now + " ] Third Step final saving the data in to the point measure facts from error " + ex.Message + " -- " + information_of_element);
}
return(point_measure_fact_list_dto);
})
.ContinueWith((y) =>
{
// y is last continue result
//update DatawareHouseMigrationLog table for the next run
if (y.Result.Count > 0)
{
data_migration_log.Last_Run_End = System.DateTime.Now;
data_migration_log.Total_Record_Fetch = y.Result.Count;
data_migration_log.Timestamp_To = Convert.ToDateTime(y.Result.LastOrDefault().Timestamp_To);
_dbContext2.SaveChangesAsync();
}
return(y.Result);
}).ContinueWith((z) =>
{
IList <RawDataDTO> rawdata = new List <RawDataDTO>();
try
{
//Checking the missing data
DatawarehouseConnectionContext ctx = new DatawarehouseConnectionContext();
ctx.Database.CommandTimeout = 300;
rawdata = ctx.Database.SqlQuery <RawDataDTO>("EXEC GetRawMissingData '" + _dto_connector.ServerOrIP + "', '" +
_dto_connector.ServerUserName + "' , '" + _dto_connector.ServerPassword + "', '" + _dto_connector.DatabaseName + "' , '" + element.Source_Element_Name_History + "' ,'" + Convert.ToDateTime(default_to_dt.AddYears(-1).ToShortDateString() + " 00:00:00").ToString("yyyy-MM-dd HH:mm:ss.fff") + "','" + System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + "'," + element.ID).ToList();
ctx.Database.Connection.Close();
}
catch (Exception ex)
{
Helper.WriteToFile(" [ " + System.DateTime.Now + " ] Fourth getting missing data from error " + ex.Message + " -- " + information_of_element);
}
return(rawdata);
}).ContinueWith((t) =>
{
//Saving the missing data
IList <RawDataDTO> missingrawdata = new List <RawDataDTO>();
missingrawdata = t.Result;
try
{
Console.WriteLine("Missing " + element.Source_Element_Name_History + "- Total:-" + missingrawdata.Count());
point_measure_fact_service = new Point_Measure_Fact_Service();
point_measure_fact_service.List_Point_Measure_Fact_Service(missingrawdata, element);
IList <Point_Measure_Fact> point_measure_fact_list_dto = point_measure_fact_service.List_Point_Measure_Fact_Service(missingrawdata, element);
FinalInsert(point_measure_fact_list_dto);
}
catch (Exception ex)
{
Helper.WriteToFile(" [ " + System.DateTime.Now + " ] Fifth saving missing data from error " + ex.Message + " -- " + information_of_element);
}
}).ContinueWith((r) =>
{
Task.Factory.StartNew((x) =>
{
Helper.WriteToFile(" [ " + System.DateTime.Now + " ] Deleting for " + +element.ID + "--" + element.Source_Element_Name_History);
Console.WriteLine(index + " delete duplicate data " + element.ID + "--" + element.Source_Element_Name_History);
DatawarehouseConnectionContext ctx_delete_duplicate = new DatawarehouseConnectionContext();
ctx_delete_duplicate.Database.CommandTimeout = 300;
ctx_delete_duplicate.Database.ExecuteSqlCommand("EXEC Delete_Duplicate_Data " + element.ID);
ctx_delete_duplicate.Database.Connection.Close();
Console.WriteLine(index + " Finished duplicate data delete ");
}, TaskCreationOptions.DenyChildAttach);
});
//this.EventLog.WriteEntry("Get Rows for Table " + element.Source_Element_Name_History + " - " + rawdata.Count(), EventLogEntryType.Information);
}
catch (Exception ex)
{
string innerexp = (ex.InnerException != null) ? ex.InnerException.Message: "";
Helper.WriteToFile("Error while getting the GetRowsForEachTable with table " + element.ID + "--" + element.Source_Element_Name_History + " Connection " + _dto_connector.DatabaseName + " - Error" + ex.Message + " - Inner exception " + innerexp);
}
}
/// <summary>
/// Reads connectors.
/// </summary>
/// <param name="process">The process.</param>
/// <param name="sr">The reader.</param>
private static void ReadConnectors(ProcessEditDto process, SafeDataReader sr)
{
sr.NextResult();
int? stateId = null;
StateDto stateDto = null;
while (sr.Read())
{
var connectorDto = new ConnectorDTO
{
StateId = sr.GetInt32(0),
ConnectsToStateGuid = sr.GetGuid(1),
ConnectsFromStateGuid = sr.GetGuid(2)
};
if (stateId != connectorDto.StateId)
{
stateId = connectorDto.StateId;
stateDto = process.States.First(s => s.Id == stateId);
}
stateDto.Connectors.Add(connectorDto);
}
ReadConnectorsSecurityConfigurations(process, sr);
}
public ActionResult DataConnection_Insert([DataSourceRequest] DataSourceRequest request, ConnectorDTO _dtoConnector)
{
try
{
if (_dtoConnector != null && ModelState.IsValid)
{
_dtoConnector.SessionId = Session.SessionID;
objConnectorRepository = new ConnectorRepository(_dtoConnector);
objConnectorRepository.SaveConnection();
}
return(Json(new[] { _dtoConnector }.ToDataSourceResult(request, ModelState), JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
return(Content(ex.Message + ex.InnerException.Message));
}
}
public static WorkflowDocument LoadDatabase(Database db, string workflowID, string USER_ACCOUNT)
{
WorkflowButtonList buttonList = new WorkflowButtonList();
WorkflowLineHeaderList lineHeaderList = new WorkflowLineHeaderList();
ButtonDAO daoButton = new ButtonDAO();
LineHeaderDAO daoLineHeader = new LineHeaderDAO();
LineDetailDAO daoLineDetail = new LineDetailDAO();
ConnectorDAO daoConnector = new ConnectorDAO();
#region " Load Buttons "
//== Generate all Button (not binding event click)
// Event ButtonClick will bind when assign document to viewer.
List <ButtonDTO> listButtons = daoButton.FindButton(db, workflowID, USER_ACCOUNT, SystemMaintenance.DataDefine.AUTO_ARRANGE_ICON, SystemMaintenance.DataDefine.ICON_PER_ROW);
for (int i = 0; i < listButtons.Count; i++)
{
ButtonDTO dto = listButtons[i];
WorkflowButton button = new WorkflowButton(dto);
button.Dock = DockStyle.Fill;
button.Anchor = AnchorStyles.None;
button.Name = String.Format("{0}.{1}.{2}", dto.WF_ID, dto.ROW_INDEX, dto.COL_INDEX);
//button.Click += new EventHandler(buttonClick);
button.Location = new Point(0, 0);
if (dto.FLG_VIEW == 1)
{
button.Visible = true;
}
else
{
button.Visible = false;
}
// add to collection
buttonList.Add(button);
}
#endregion
//ถ้าเปิดให้ auto arrange icon จะไม่มี work flow line
if (SystemMaintenance.DataDefine.AUTO_ARRANGE_ICON != true)
{
#region " Load Lines "
List <LineHeaderDTO> listLineHeader = daoLineHeader.GetLineHeaders(db, workflowID);
for (int i = 0; i < listLineHeader.Count; i++)
{
LineHeaderDTO lineHeaderDTO = listLineHeader[i];
List <LineDetailDTO> listLineDetail = daoLineDetail.GetLineDetails(db, workflowID, lineHeaderDTO.ID);
List <ConnectorDTO> listConnector = daoConnector.GetConnectors(db, workflowID, lineHeaderDTO.ID);
// Create Model Header
WorkflowLineHeader wf_header = new WorkflowLineHeader(null, lineHeaderDTO.ID, lineHeaderDTO.ZINDEX);
// Loop for Create inner Model LineDetail.
for (int iLine = 0; iLine < listLineDetail.Count; iLine++)
{
LineDetailDTO lineDetailDTO = listLineDetail[iLine];
WorkflowLineDetail wf_detail = new WorkflowLineDetail(wf_header
,
new Cell(null, lineDetailDTO.FROM_ROW,
lineDetailDTO.FROM_COL)
,
new Cell(null, lineDetailDTO.TO_ROW,
lineDetailDTO.TO_COL)
, (WorkflowLineStatus)lineDetailDTO.STATUS);
wf_header.Lines.Add(wf_detail);
}
// Loop for Create inner Model LineConnector.
for (int iConnector = 0; iConnector < listConnector.Count; iConnector++)
{
ConnectorDTO connectorDTO = listConnector[iConnector];
WorkflowLineConnector wf_connector = new WorkflowLineConnector(wf_header
,
new Cell(null, connectorDTO.ROW_INDEX,
connectorDTO.COL_INDEX)
,
(WorkflowConnectorType)
connectorDTO.STATUS);
wf_header.Connectors.Add(wf_connector);
}
lineHeaderList.Add(wf_header);
}
#endregion
}
WorkflowDocument document = new WorkflowDocument(workflowID, buttonList, lineHeaderList);
return(document);
}
/// <summary>
/// Deletes state link.
/// </summary>
/// <param name="dto">The DTO object.</param>
/// <exception cref="System.ArgumentNullException">The input DTO is null.</exception>
public void DeleteStateLink(ConnectorDTO dto)
{
if (dto == null) throw new ArgumentNullException(string.Format(CultureInfo.InvariantCulture, Resources.NullArguementException, "dto"));
const string CommandText =
@"
DELETE FROM StateLinks
WHERE StateOutGuid = @StateOutGuid AND StateInGuid = @StateInGuid
";
using (var ctx = ConnectionManager<SqlConnection>.GetManager(Database.VeyronMeta, false))
{
var cn = ctx.Connection;
using (var paramsUpdate = new SqlCommand(CommandText, cn))
{
paramsUpdate.Parameters.AddWithValue("@StateOutGuid", dto.ConnectsFromStateGuid);
paramsUpdate.Parameters.AddWithValue("@StateInGuid", dto.ConnectsToStateGuid);
paramsUpdate.ExecuteNonQuery();
}
}
}
/// <summary>
/// Updates state link.
/// </summary>
/// <param name="dto">The DTO object.</param>
/// <exception cref="System.ArgumentNullException"></exception>
/// <exception cref="System.Data.DBConcurrencyException">Indicates stale data</exception>
/// <exception cref="System.ArgumentException">The input DTO is null.</exception>
public void UpdateStateLink(ConnectorDTO dto)
{
if (dto == null) throw new ArgumentNullException(string.Format(CultureInfo.InvariantCulture, Resources.NullArguementException, "dto"));
const string CommandText =
@"
IF ( SELECT COUNT(*)
FROM [StateLinks]
WHERE StateOutGuid = @StateOutGuid
AND StateInGuid = @StateInGuid
) = 0
BEGIN
INSERT INTO StateLinks
( StateOutGuid ,
StateInGuid ,
LastModifiedOn
)
VALUES ( @StateOutGuid ,
@StateInGuid ,
GETDATE()
)
END
ELSE
BEGIN
UPDATE StateLinks
SET LastModifiedOn = GETDATE()
WHERE StateOutGuid = @StateOutGuid
AND StateInGuid = @StateInGuid
END
";
using (var ctx = ConnectionManager<SqlConnection>.GetManager(Database.VeyronMeta, false))
{
var cn = ctx.Connection;
using (var paramsUpdate = new SqlCommand(CommandText, cn))
{
paramsUpdate.Parameters.AddWithValue("@StateOutGuid", dto.ConnectsFromStateGuid);
paramsUpdate.Parameters.AddWithValue("@StateInGuid", dto.ConnectsToStateGuid);
if (paramsUpdate.ExecuteNonQuery() == 0)
{
throw new DBConcurrencyException(Resources.StaleDataException);
}
}
}
}
