public async void ExportBacpac()
{
var result = GetLiveAutoCompleteTestObjects();
SqlTestDb testdb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxExportTest");
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
Directory.CreateDirectory(folderPath);
try
{
var exportParams = new ExportParams
{
DatabaseName = testdb.DatabaseName,
PackageFilePath = Path.Combine(folderPath, string.Format("{0}.bacpac", testdb.DatabaseName))
};
DacFxService service = new DacFxService();
ExportOperation operation = new ExportOperation(exportParams, result.ConnectionInfo);
service.PerformOperation(operation, TaskExecutionMode.Execute);
VerifyAndCleanup(exportParams.PackageFilePath);
}
finally
{
testdb.Cleanup();
}
}
public static void ProcessExport(HttpContext context)
{
IList <string> columnFields;
IDataExportProvider provider;
string extension;
string portal = context.Request["portal"];
string columns = context.Request["columns"];
//获取导出提供者
switch (context.Request["exportFormat"] ?? "excel")
{
default:
case "excel":
provider = new LocaledExcelExportProvider();
extension = "xls";
break;
case "csv":
provider = new CsvExportProvider();
extension = "csv";
break;
case "txt":
provider = new TextExportProvider();
extension = "txt";
break;
}
//获取列名
// Regex reg = new Regex("^export_fields\\[\\d+\\]$", RegexOptions.IgnoreCase);
columnFields = new List <string>();
// foreach (string key in context.Request.QueryString.Keys)
// {
// if (reg.IsMatch(key))
// {
// columnFields.Add(context.Request.QueryString[key]);
// }
// }
IDataExportPortal _portal = ExportItemManager.GetPortal(context.Request.QueryString["portal"]);
if (_portal == null)
{
throw new ArgumentNullException("_portal");
}
ExportParams parameter = DataExportDirector.GetExportParams(context.Request["params"], columnFields.ToArray());
byte[] bytes = DataExportDirector.Export(_portal, parameter, provider);
context.Response.BinaryWrite(bytes);
context.Response.ContentType = "application/octet-stream";
context.Response.AppendHeader("Content-Disposition", String.Format("attachment;filename=\"{0:yyyyMMdd-hhssfff}.{1}\"",
DateTime.Now,
extension));
}
private async Task <Mock <RequestContext <DacFxResult> > > SendAndValidateExportRequest()
{
var result = GetLiveAutoCompleteTestObjects();
var requestContext = new Mock <RequestContext <DacFxResult> >();
requestContext.Setup(x => x.SendResult(It.IsAny <DacFxResult>())).Returns(Task.FromResult(new object()));
SqlTestDb testdb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxExportTest");
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
Directory.CreateDirectory(folderPath);
var exportParams = new ExportParams
{
DatabaseName = testdb.DatabaseName,
PackageFilePath = Path.Combine(folderPath, string.Format("{0}.bacpac", testdb.DatabaseName))
};
DacFxService service = new DacFxService();
ExportOperation operation = new ExportOperation(exportParams, result.ConnectionInfo);
service.PerformOperation(operation);
// cleanup
VerifyAndCleanup(exportParams.PackageFilePath);
testdb.Cleanup();
return(requestContext);
}
/// <summary>
/// Экспортирует сущности по определенным параметрам.
/// </summary>
/// <param name="token">Токен безопасности. </param>
/// <param name="exportParams">Параметры экспорта.</param>
/// <returns>Результат.</returns>
public byte[] Export(SecurityToken token, ExportParams exportParams)
{
_logger.InfoFormat("Старт экспортирования типа {0} с {1} по {2}", exportParams.Kind.KindID,
exportParams.BeginDate, exportParams.EndDate);
byte[] content;
if (exportParams.Kind == null)
{
return(new byte[0]);
} //if
using (var stream = new MemoryStream())
{
switch (exportParams.Kind.KindID)
{
case 1: //ExportKindSet.OnlyOrders.KindID:
ExportOnlyOrders(token, exportParams, stream);
break;
}
var position = (int)stream.Position;
stream.Seek(0, SeekOrigin.Begin);
content = new byte[position];
stream.Read(content, 0, position);
} //using
return(content);
}
/// <summary>
/// Конструктор
/// </summary>
public ExportDestination(DataSource dataSource, ExportParams exportParams)
{
if (dataSource == null)
{
throw new ArgumentNullException("dataSource");
}
if (exportParams == null)
{
throw new ArgumentNullException("exportParams");
}
this.DataSource = dataSource;
this.ExportParams = exportParams;
}
public async Task<ActionResult<ExportParams>> GetExportedReport([FromBody] ExportParams exportParams)
{
if (string.IsNullOrWhiteSpace(exportParams.PageName))
{
return BadRequest(Constant.MissingPageName);
}
else if (string.IsNullOrWhiteSpace(exportParams.FileFormat))
{
return BadRequest(Constant.MissingFileFormat);
}
try
{
// Get username and role of user
var userInfo = JwtAuthHelper.GetUsernameAndRole(User.Identity as ClaimsIdentity);
// Generated exported file
var exportedFile = await exportService.GetExportedFile(exportParams.PageName, exportParams.FileFormat, exportParams.PageState, userInfo.username, userInfo.role);
return Ok(File(exportedFile.MemoryStream.ToArray(), exportedFile.MimeType, exportedFile.FileName));
}
catch (MsalServiceException ex)
{
logger.LogError(ex, ex.Message);
return StatusCode(ex.StatusCode, ex.Message);
}
catch (MsalClientException ex)
{
logger.LogError(ex, ex.Message);
if (Int32.TryParse(ex.ErrorCode, out int errorCode))
{
return StatusCode(errorCode, ex.Message);
}
else
{
return StatusCode(403, ex.Message);
}
}
catch (HttpOperationException ex)
{
logger.LogError(ex, ex.Message);
JObject error = ErrorHelper.ExtractPowerBiErrorInfo(ex);
return StatusCode((int)ex.Response.StatusCode, Convert.ToString(error, cultureInfo));
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
return StatusCode((int)HttpStatusCode.InternalServerError);
}
}
public static byte[] Export(IDataExportPortal portal, ExportParams parameters, IDataExportProvider provider)
{
int totalCount;
IDictionary<string, String> dict = null;
//获取参数的索引及名称
if (parameters != null && parameters.ExportFields != null)
{
dict = portal.GetExportFieldAndName(parameters.ExportFields);
}
return
provider.Export(
portal.GetShemalAndData(parameters == null ? null : parameters.Parameters, out totalCount), dict);
}
private async Task <Mock <RequestContext <DacFxResult> > > SendAndValidateImportRequest()
{
// first export a bacpac
var result = GetLiveAutoCompleteTestObjects();
var exportRequestContext = new Mock <RequestContext <DacFxResult> >();
exportRequestContext.Setup(x => x.SendResult(It.IsAny <DacFxResult>())).Returns(Task.FromResult(new object()));
SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxImportTest");
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
Directory.CreateDirectory(folderPath);
var exportParams = new ExportParams
{
DatabaseName = sourceDb.DatabaseName,
PackageFilePath = Path.Combine(folderPath, string.Format("{0}.bacpac", sourceDb.DatabaseName))
};
SqlConnection sqlConn = ConnectionService.OpenSqlConnection(result.ConnectionInfo, "Import");
DacFxService service = new DacFxService();
ExportOperation exportOperation = new ExportOperation(exportParams, sqlConn);
service.PerformOperation(exportOperation);
// import the created bacpac
var importRequestContext = new Mock <RequestContext <DacFxResult> >();
importRequestContext.Setup(x => x.SendResult(It.IsAny <DacFxResult>())).Returns(Task.FromResult(new object()));
var importParams = new ImportParams
{
PackageFilePath = exportParams.PackageFilePath,
DatabaseName = string.Concat(sourceDb.DatabaseName, "-imported")
};
ImportOperation importOperation = new ImportOperation(importParams, sqlConn);
service.PerformOperation(importOperation);
SqlTestDb targetDb = SqlTestDb.CreateFromExisting(importParams.DatabaseName);
// cleanup
VerifyAndCleanup(exportParams.PackageFilePath);
sourceDb.Cleanup();
targetDb.Cleanup();
return(importRequestContext);
}
internal static DataTable LoadAttendanceClock(ExportParams exporrParams)
{
DataTable result = new DataTable();
string query =
"SELECT Id, TransactionCode, TerminalId, BaseDataId, UserPrimaryCode, " +
"ClockDate, ClockTime, TransactionDateTime, TempleteId, MatchingScore, LastUpdated, ClockStatus " +
string.Format(" FROM eid_attendance_log {0}", exporrParams.AllData ? "" :
string.Format(" WHERE ClockDate>= '{0}' AND ClockDate <= '{1}'", exporrParams.StartDate, exporrParams.EndDate));
MySqlDataAdapter Adapter = new MySqlDataAdapter(query, myConn);
Adapter.Fill(result);
return(result);
}
public async void ImportBacpac()
{
// first export a bacpac
var result = GetLiveAutoCompleteTestObjects();
SqlTestDb sourceDb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxImportTest");
SqlTestDb targetDb = null;
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
Directory.CreateDirectory(folderPath);
try
{
var exportParams = new ExportParams
{
DatabaseName = sourceDb.DatabaseName,
PackageFilePath = Path.Combine(folderPath, string.Format("{0}.bacpac", sourceDb.DatabaseName))
};
DacFxService service = new DacFxService();
ExportOperation exportOperation = new ExportOperation(exportParams, result.ConnectionInfo);
service.PerformOperation(exportOperation, TaskExecutionMode.Execute);
// import the created bacpac
var importParams = new ImportParams
{
PackageFilePath = exportParams.PackageFilePath,
DatabaseName = string.Concat(sourceDb.DatabaseName, "-imported")
};
ImportOperation importOperation = new ImportOperation(importParams, result.ConnectionInfo);
service.PerformOperation(importOperation, TaskExecutionMode.Execute);
targetDb = SqlTestDb.CreateFromExisting(importParams.DatabaseName);
VerifyAndCleanup(exportParams.PackageFilePath);
}
finally
{
sourceDb.Cleanup();
if (targetDb != null)
{
targetDb.Cleanup();
}
}
}
private void ExportScripts()
{
ExportParams exportParams = new ExportParams();
exportParams.UseMultipleFiles = true; // for now this always must be true
exportParams.ScriptDataAsSql = chkDataSql.Checked;
exportParams.ScriptDataAsXml = chkDataXml.Checked;
exportParams.ScriptTableSchema = chkSchema.Checked;
exportParams.ScriptTableConstraints = chkConstraints.Checked;
exportParams.ScriptTableIndexes = chkIndex.Checked;
if (exportParams.ScriptDataAsSql || exportParams.ScriptDataAsXml)
{
foreach (string table in lstTable.SelectedItems)
{
exportParams.TablesToScriptData.Add(table);
}
}
foreach (string sproc in lstSproc.SelectedItems)
{
exportParams.SprocsToScript.Add(sproc);
}
foreach (string table in lstTable.SelectedItems)
{
exportParams.TablesToScript.Add(table);
}
foreach (string view in lstView.SelectedItems)
{
exportParams.ViewsToScript.Add(view);
}
try
{
exportSession.Export(txtExportRootDir.Text, exportParams);
}
catch (SqlExporterException ex)
{
ShowError(ex.Message);
}
}
private void ExportButton_OnClick(object sender, RoutedEventArgs e)
{
try
{
var saveFileDialog = new SaveFileDialog
{
FileName = "export.xlsx",
Filter = "Excel Worksheets|*.xlsx"
};
if (saveFileDialog.ShowDialog() == true)
{
var exportParams = new ExportParams(
new YearAndMonth(model.SelectedFromYear, model.SelectedFromMonth),
model.CloneRowsForMultipleCopies,
model.MergeFilePath,
saveFileDialog.FileName);
mergeAndExport(exportParams).Match(
Exception: (error) =>
{
MessageBox.Show(
this,
$"{Properties.Resources.ExportDataSourceError} ({error.Message})",
Properties.Resources.Error,
MessageBoxButton.OK,
MessageBoxImage.Error);
},
Success: _ =>
{
MessageBox.Show(
this,
Properties.Resources.ExportDataSourceSuccess,
Properties.Resources.Information,
MessageBoxButton.OK,
MessageBoxImage.Information);
Close();
});
}
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
/// <summary>
/// Handles request to export a bacpac
/// </summary>
/// <returns></returns>
public async Task HandleExportRequest(ExportParams parameters, RequestContext <DacFxResult> requestContext)
{
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
ExportOperation operation = new ExportOperation(parameters, connInfo);
ExecuteOperation(operation, parameters, SR.ExportBacpacTaskName, requestContext);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
private void buttonExport_Click(object sender, EventArgs e)
{
MessageNotifyer("Please wait while the attendance log is exporting...");
if (folderBrowserExport.ShowDialog() == DialogResult.OK)
{
ExportParams exportParams = new ExportParams
{
ExportDir = folderBrowserExport.SelectedPath,
AllData = checkBoxAllData.Checked,
StartDate = dateTimeStart.Value.ToString("yyyy-MM-dd"),
EndDate = dateTimeEnd.Value.ToString("yyyy-MM-dd")
};
//Disable UI Controls
EnableUIControls(false);
exportBgWorker.RunWorkerAsync(exportParams);
}
}
private async Task <Mock <RequestContext <DacFxResult> > > ValidateExportCancellation()
{
var result = GetLiveAutoCompleteTestObjects();
var requestContext = new Mock <RequestContext <DacFxResult> >();
requestContext.Setup(x => x.SendResult(It.IsAny <DacFxResult>())).Returns(Task.FromResult(new object()));
SqlTestDb testdb = await SqlTestDb.CreateNewAsync(TestServerType.OnPrem, false, null, null, "DacFxExportTest");
string folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "DacFxTest");
Directory.CreateDirectory(folderPath);
var exportParams = new ExportParams
{
DatabaseName = testdb.DatabaseName,
PackageFilePath = Path.Combine(folderPath, string.Format("{0}.bacpac", testdb.DatabaseName))
};
SqlConnection sqlConn = ConnectionService.OpenSqlConnection(result.ConnectionInfo, "Export");
DacFxService service = new DacFxService();
ExportOperation operation = new ExportOperation(exportParams, sqlConn);
// set cancellation token to cancel
operation.Cancel();
OperationCanceledException expectedException = null;
try
{
service.PerformOperation(operation);
}
catch (OperationCanceledException canceledException)
{
expectedException = canceledException;
}
Assert.NotNull(expectedException);
// cleanup
testdb.Cleanup();
return(requestContext);
}
private void exportBgWorker_DoWork(object sender, DoWorkEventArgs e)
{
ExportParams exportParams = (ExportParams)e.Argument;
//Load Attendance Logs
DataTable result = DataServices.LoadAttendanceClock(exportParams);
Double bgWorkerProgress = 0.0;
List <AttendanceLog> attendanceLogs = new List <AttendanceLog>();
foreach (DataRow row in result.Rows)
{
AttendanceLog obj = new AttendanceLog
{
Id = (Int32)row["Id"],
BaseDataId = Convert.ToString(row["BaseDataId"]),
ClockDate = Convert.ToString(row["ClockDate"]),
ClockStatus = Convert.ToInt32(row["ClockStatus"]),
ClockTime = Convert.ToString(row["ClockTime"]),
LastUpdated = Convert.ToString(row["LastUpdated"]),
MatchingScore = Convert.ToInt32(row["MatchingScore"]),
TempleteId = Convert.ToInt32(row["TempleteId"]),
TerminalId = Convert.ToString(row["TerminalId"]),
TransactionCode = Convert.ToString(row["TransactionCode"]),
TransactionDateTime = Convert.ToString(row["TransactionDateTime"]),
UserPrimaryCode = Convert.ToString(row["UserPrimaryCode"])
};
attendanceLogs.Add(obj);
bgWorkerProgress = bgWorkerProgress += 1;
var PercentageProgress = bgWorkerProgress / result.Rows.Count;
var PercentageComplete = PercentageProgress * 100;
exportBgWorker.ReportProgress(Convert.ToInt32(PercentageComplete), null);
}
//Write Attendance Logs To file
string fileAppendage = exportParams.AllData ? "_All_" : exportParams.StartDate + "_to_" + exportParams.EndDate;
string fileName = exportParams.ExportDir + "\\Attendance_Log_Export_" + fileAppendage + DateTime.Now.ToString("yyyyMMddhhmmsss") + ".expt";
JsonSerialization.WriteToJsonFile <List <AttendanceLog> >(fileName, attendanceLogs);
e.Result = attendanceLogs.Count + " Records Exported Succesfully to " + fileName;
}
/// <summary>
/// Производит процесс экпортирования только заказов.
/// </summary>
/// <param name="token">Токен безопасности.</param>
/// <param name="exportParams">Параметры экспортирования.</param>
/// <param name="stream"></param>
private void ExportOnlyOrders(SecurityToken token, ExportParams exportParams, MemoryStream stream)
{
var items = RemontinkaServer.Instance.EntitiesFacade.GetRepairOrders(token, exportParams.BeginDate,
exportParams.EndDate);
var writer = new StreamWriter(stream, Encoding.UTF8);
foreach (var repairOrder in items)
{
writer.WriteLine("{0};{1};{2};{3};{4};{5};{6};{7};{8};{9};{10};{11};{12};{13};{14};{15};{16};{17};{18};{19};{20};{21}",
NormilizeCsvString(repairOrder.Number),
NormilizeCsvString(GetBranch(repairOrder.BranchID, repairOrder.BranchID).Title),
NormilizeCsvString(Utils.DateTimeToStringWithTime(repairOrder.EventDate)),
NormilizeCsvString(repairOrder.ClientFullName),
NormilizeCsvString(repairOrder.ClientAddress),
NormilizeCsvString(repairOrder.ClientPhone),
NormilizeCsvString(repairOrder.DeviceTitle),
NormilizeCsvString(repairOrder.DeviceModel),
NormilizeCsvString(repairOrder.DeviceTrademark),
NormilizeCsvString(repairOrder.Defect),
NormilizeCsvString(repairOrder.DeviceAppearance),
NormilizeCsvString(repairOrder.DeviceSN),
NormilizeCsvString(repairOrder.Notes),
NormilizeCsvString(Utils.DecimalToString(repairOrder.PrePayment)),
NormilizeCsvString(Utils.DecimalToString(repairOrder.GuidePrice)),
NormilizeCsvString(Utils.DateTimeToString(repairOrder.DateOfBeReady)),
NormilizeCsvString(repairOrder.WarrantyTo == null?string.Empty:Utils.DateTimeToString(repairOrder.WarrantyTo.Value)),
NormilizeCsvString(GetUser(repairOrder.ManagerID, repairOrder.UserDomainID).LoginName),
NormilizeCsvString(GetUser(repairOrder.EngineerID, repairOrder.UserDomainID).LoginName),
NormilizeCsvString(repairOrder.IssueDate == null ? string.Empty : Utils.DateTimeToString(repairOrder.IssueDate.Value)),
NormilizeCsvString(GetUser(repairOrder.IssuerID, repairOrder.UserDomainID).LoginName),
NormilizeCsvString(repairOrder.WarrantyTo == null ? string.Empty : Utils.DateTimeToString(repairOrder.WarrantyTo.Value))
);
} //foreach
writer.Flush();
}
public static string GetExportData(HttpContext context)
{
IDataExportPortal portal = ExportItemManager.GetPortal(context.Request.QueryString["portal"]);
ExportParams parameter = DataExportDirector.GetExportParams(
context.Request["params"], null);
int pageIndex, pageSize;
if (context.Request["page"] != null)
{
int.TryParse(context.Request["page"], out pageIndex);
parameter.Parameters.Add("pageIndex", pageIndex);
}
if (context.Request["rows"] != null)
{
int.TryParse(context.Request["rows"], out pageSize);
parameter.Parameters.Add("pageSize", pageSize);
}
int totalCount;
DataTable dt = portal.GetShemalAndData(parameter.Parameters, out totalCount);
return(JsonConvert.SerializeObject(new { total = totalCount, rows = dt }));
}
private void btnSave_Click(object sender, EventArgs e)
{
DisableControls();
bool error = false;
try
{
using (StreamWriter writer = new StreamWriter(txtFile.Text))
{
ExportOption exportOption;
MatchExporter exporter;
if (rButtonMatchesOnly.Checked)
{
exportOption = ExportOption.MatchesOnly;
}
else if (rButtonGroupsOnly.Checked)
{
exportOption = ExportOption.GroupsOnly;
}
else
{
exportOption = ExportOption.Both;
}
ExportParams exportParams = new ExportParams()
{
Pattern = pattern, MatchList = matchList, ExportOption = exportOption
};
if (saveFileDialog1.FilterIndex == 1)
{
exporter = new CsvMatchExporter(exportParams);
}
else
{
exporter = new XmlMatchExporter(exportParams);
}
exporter.Export(writer);
}
}
catch (IOException)
{
error = true;
MessageBox.Show("Could not open the file.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
catch
{
error = true;
MessageBox.Show("There was an error saving the file.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
EnableControls();
if (!error)
{
MessageBox.Show("Export completed", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
Close();
}
}
public ExportOperation(ExportParams parameters, SqlConnection sqlConnection) : base(sqlConnection)
{
Validate.IsNotNull("parameters", parameters);
this.Parameters = parameters;
}
public ExportOperation(ExportParams parameters, ConnectionInfo connInfo) : base(connInfo)
{
Validate.IsNotNull("parameters", parameters);
this.Parameters = parameters;
}
public DataTable GetQueryView(string sqlItemName, ExportParams exportParams, int pageSize, int pageIndex)
{
return(_commonDataQuery.GetQuery(sqlItemName, exportParams, pageSize, pageIndex));
}
/// <summary>
/// Download module configuration
/// </summary>
public bool Load(out string errMsg)
{
SetToDefault();
try {
var xmlDoc = new XmlDocument();
xmlDoc.Load(FileName);
// loading export destinations
var expDestsNode = xmlDoc.DocumentElement.SelectSingleNode("ExportDestinations");
if (expDestsNode != null)
{
var expDestNodeList = expDestsNode.SelectNodes("ExportDestination");
foreach (XmlElement expDestElem in expDestNodeList)
{
// loading data source
DataSource dataSource = null;
var dataSourceNode = expDestElem.SelectSingleNode("DataSource");
if (dataSourceNode != null)
{
// getting data source type
DBTypes dbType;
if (!Enum.TryParse <DBTypes>(dataSourceNode.GetChildAsString("DBType"), out dbType))
{
dbType = DBTypes.Undefined;
}
// create data source
switch (dbType)
{
case DBTypes.MSSQL:
dataSource = new SqlDataSource();
break;
case DBTypes.Oracle:
dataSource = new OraDataSource();
break;
case DBTypes.PostgreSQL:
dataSource = new PgSqlDataSource();
break;
case DBTypes.MySQL:
dataSource = new MySqlDataSource();
break;
case DBTypes.OLEDB:
dataSource = new OleDbDataSource();
break;
default:
dataSource = null;
break;
}
if (dataSource != null)
{
dataSource.Server = dataSourceNode.GetChildAsString("Server");
dataSource.Database = dataSourceNode.GetChildAsString("Database");
dataSource.User = dataSourceNode.GetChildAsString("User");
dataSource.Password = dataSourceNode.GetChildAsString("Password");
dataSource.ConnectionString = dataSourceNode.GetChildAsString("ConnectionString");
if (string.IsNullOrEmpty(dataSource.ConnectionString))
{
dataSource.ConnectionString = dataSource.BuildConnectionString();
}
}
}
// load export options
ExportParams exportParams = null;
var exportParamsNode = expDestElem.SelectSingleNode("ExportParams");
if (dataSource != null && exportParamsNode != null)
{
exportParams = new ExportParams {
ExportCurDataQuery = exportParamsNode.GetChildAsString("ExportCurDataQuery")
};
exportParams.ExportCurData = !string.IsNullOrEmpty(exportParams.ExportCurDataQuery) &&
exportParamsNode.GetChildAsBool("ExportCurData");
exportParams.ExportArcDataQuery = exportParamsNode.GetChildAsString("ExportArcDataQuery");
exportParams.ExportArcData = !string.IsNullOrEmpty(exportParams.ExportArcDataQuery) &&
exportParamsNode.GetChildAsBool("ExportArcData");
exportParams.ExportEventQuery = exportParamsNode.GetChildAsString("ExportEventQuery");
exportParams.ExportEvents = !string.IsNullOrEmpty(exportParams.ExportEventQuery) &&
exportParamsNode.GetChildAsBool("ExportEvents");
}
// creating export destination
if (dataSource != null && exportParams != null)
{
var expDest = new ExportDestination(dataSource, exportParams);
ExportDestinations.Add(expDest);
}
}
// sort export destinations
ExportDestinations.Sort();
}
// loading control channel numbers for manual export
var manExpNode = xmlDoc.DocumentElement.SelectSingleNode("ManualExport");
if (manExpNode != null)
{
CurDataCtrlCnlNum = manExpNode.GetChildAsInt("CurDataCtrlCnlNum");
ArcDataCtrlCnlNum = manExpNode.GetChildAsInt("ArcDataCtrlCnlNum");
EventsCtrlCnlNum = manExpNode.GetChildAsInt("EventsCtrlCnlNum");
}
errMsg = "";
return(true);
} catch (FileNotFoundException ex) {
errMsg = ModPhrases.LoadModSettingsError + ": " + ex.Message +
Environment.NewLine + ModPhrases.ConfigureModule;
return(false);
} catch (Exception ex) {
errMsg = ModPhrases.LoadModSettingsError + ": " + ex.Message;
return(false);
}
}
/// <summary>
/// Constructor
/// </summary>
public ExportDestination(DataSource dataSource, ExportParams exportParams)
{
this.DataSource = dataSource ?? throw new ArgumentNullException(nameof(dataSource));
this.ExportParams = exportParams ?? throw new ArgumentNullException(nameof(exportParams));
}
/// <summary>
/// Загрузить конфигурацию модуля
/// </summary>
public bool Load(out string errMsg)
{
SetToDefault();
try
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(FileName);
// загрузка назначений экспорта
XmlNode expDestsNode = xmlDoc.DocumentElement.SelectSingleNode("ExportDestinations");
if (expDestsNode != null)
{
XmlNodeList expDestNodeList = expDestsNode.SelectNodes("ExportDestination");
foreach (XmlElement expDestElem in expDestNodeList)
{
// загрузка источника данных
DataSource dataSource = null;
if (expDestElem.SelectSingleNode("DataSource") is XmlNode dataSourceNode)
{
// получение типа источника данных
if (!Enum.TryParse(dataSourceNode.GetChildAsString("DBType"), out DBType dbType))
{
dbType = DBType.Undefined;
}
// создание источника данных
switch (dbType)
{
case DBType.MSSQL:
dataSource = new SqlDataSource();
break;
case DBType.Oracle:
dataSource = new OraDataSource();
break;
case DBType.PostgreSQL:
dataSource = new PgSqlDataSource();
break;
case DBType.MySQL:
dataSource = new MySqlDataSource();
break;
case DBType.OLEDB:
dataSource = new OleDbDataSource();
break;
default:
dataSource = null;
break;
}
if (dataSource != null)
{
dataSource.Server = dataSourceNode.GetChildAsString("Server");
dataSource.Database = dataSourceNode.GetChildAsString("Database");
dataSource.User = dataSourceNode.GetChildAsString("User");
dataSource.Password = ScadaUtils.Decrypt(dataSourceNode.GetChildAsString("Password"));
dataSource.ConnectionString = dataSourceNode.GetChildAsString("ConnectionString");
if (string.IsNullOrEmpty(dataSource.ConnectionString))
{
dataSource.ConnectionString = dataSource.BuildConnectionString();
}
}
}
if (dataSource != null &&
expDestElem.SelectSingleNode("ExportParams") is XmlNode exportParamsNode)
{
// загрузка параметров экспорта
ExportParams exportParams = new ExportParams();
exportParams.LoadFromXml(exportParamsNode);
// создание назначения экспорта
ExportDestination expDest = new ExportDestination(dataSource, exportParams);
ExportDestinations.Add(expDest);
}
}
// сортировка назначений экспорта
ExportDestinations.Sort();
}
// загрузка номеров каналов управления для экспорта в ручном режиме
if (xmlDoc.DocumentElement.SelectSingleNode("ManualExport") is XmlNode manExpNode)
{
CurDataCtrlCnlNum = manExpNode.GetChildAsInt("CurDataCtrlCnlNum");
ArcDataCtrlCnlNum = manExpNode.GetChildAsInt("ArcDataCtrlCnlNum");
EventsCtrlCnlNum = manExpNode.GetChildAsInt("EventsCtrlCnlNum");
}
errMsg = "";
return(true);
}
catch (FileNotFoundException ex)
{
errMsg = ModPhrases.LoadModSettingsError + ": " + ex.Message +
Environment.NewLine + ModPhrases.ConfigureModule;
return(false);
}
catch (Exception ex)
{
errMsg = ModPhrases.LoadModSettingsError + ": " + ex.Message;
return(false);
}
}
/// <summary>
/// Сохранить конфигурацию модуля
/// </summary>
public bool Save(out string errMsg)
{
try
{
XmlDocument xmlDoc = new XmlDocument();
XmlDeclaration xmlDecl = xmlDoc.CreateXmlDeclaration("1.0", "utf-8", null);
xmlDoc.AppendChild(xmlDecl);
XmlElement rootElem = xmlDoc.CreateElement("ModDBExport");
xmlDoc.AppendChild(rootElem);
// сохранение назначений экспорта
XmlElement expDestsElem = xmlDoc.CreateElement("ExportDestinations");
rootElem.AppendChild(expDestsElem);
foreach (ExportDestination expDest in ExportDestinations)
{
XmlElement expDestElem = xmlDoc.CreateElement("ExportDestination");
expDestsElem.AppendChild(expDestElem);
// сохранение источника данных
DataSource dataSource = expDest.DataSource;
XmlElement dataSourceElem = xmlDoc.CreateElement("DataSource");
dataSourceElem.AppendElem("DBType", dataSource.DBType);
dataSourceElem.AppendElem("Server", dataSource.Server);
dataSourceElem.AppendElem("Database", dataSource.Database);
dataSourceElem.AppendElem("User", dataSource.User);
dataSourceElem.AppendElem("Password", dataSource.Password);
string connStr = dataSource.ConnectionString;
string bldConnStr = dataSource.BuildConnectionString();
dataSourceElem.AppendElem("ConnectionString",
!string.IsNullOrEmpty(bldConnStr) && bldConnStr == connStr ? "" : connStr);
expDestElem.AppendChild(dataSourceElem);
// сохранение параметров экспорта
ExportParams exportParams = expDest.ExportParams;
XmlElement exportParamsElem = xmlDoc.CreateElement("ExportParams");
exportParamsElem.AppendElem("ExportCurData", exportParams.ExportCurData);
exportParamsElem.AppendElem("ExportCurDataQuery", exportParams.ExportCurDataQuery);
exportParamsElem.AppendElem("ExportArcData", exportParams.ExportArcData);
exportParamsElem.AppendElem("ExportArcDataQuery", exportParams.ExportArcDataQuery);
exportParamsElem.AppendElem("ExportEvents", exportParams.ExportEvents);
exportParamsElem.AppendElem("ExportEventQuery", exportParams.ExportEventQuery);
expDestElem.AppendChild(exportParamsElem);
}
// сохранение номеров каналов управления для экспорта в ручном режиме
XmlElement manExpElem = xmlDoc.CreateElement("ManualExport");
rootElem.AppendChild(manExpElem);
manExpElem.AppendElem("CurDataCtrlCnlNum", CurDataCtrlCnlNum);
manExpElem.AppendElem("ArcDataCtrlCnlNum", ArcDataCtrlCnlNum);
manExpElem.AppendElem("EventsCtrlCnlNum", EventsCtrlCnlNum);
xmlDoc.Save(FileName);
errMsg = "";
return(true);
}
catch (Exception ex)
{
errMsg = ModPhrases.SaveModSettingsError + ": " + ex.Message;
return(false);
}
}
