411 lines
13 KiB
C#
411 lines
13 KiB
C#
using Common;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using TBF.Rig.Generic;
|
|
using TBF.Rig.Output.DataStorage.UniDataStorageWriter.Interfaces;
|
|
using TBF.Rig.Output.DataStorage.UniDataStorageWriter.Writers;
|
|
|
|
namespace TBF.Rig.Output.DataStorage.UniDataStorageWriter.UI
|
|
{
|
|
/// <summary>
|
|
/// UI configuration control for UniDataStorageWriter.
|
|
/// Insert format: Column_Value
|
|
/// Update format: WhereName_WhereValue_SetName_SetValue
|
|
/// </summary>
|
|
public partial class WriterCfgCtrl : Configs.ConfigCtrlUtils, IComponentCfgCtrl
|
|
{
|
|
private readonly List<string> batchWriteLines = new List<string>();
|
|
|
|
public bool ShowMore { get { return false; } }
|
|
|
|
private WriterCfg config;
|
|
|
|
public IComponentCfg Config
|
|
{
|
|
get { return config as IComponentCfg; }
|
|
set
|
|
{
|
|
config = value as WriterCfg;
|
|
Redraw();
|
|
}
|
|
}
|
|
|
|
public WriterCfgCtrl()
|
|
{
|
|
InitializeComponent();
|
|
|
|
connectToDataSourceButton.Click += testByDataSourceButton_Click;
|
|
writeDataByParamAndTemplateButton.Click += writeDataByParamAndTemplateButton_Click;
|
|
buttonAddParam.Click += buttonAddParam_Click;
|
|
buttonRemoveParam.Click += buttonRemoveParam_Click;
|
|
writeModeComboBox.SelectedIndexChanged += writeModeComboBox_SelectedIndexChanged;
|
|
}
|
|
|
|
private void WriterCfgCtrl_Load(object sender, EventArgs e)
|
|
{
|
|
writeModeComboBox.Items.Clear();
|
|
writeModeComboBox.Items.Add(WriteMode.Insert.ToString());
|
|
writeModeComboBox.Items.Add(WriteMode.Update.ToString());
|
|
|
|
if (writeModeComboBox.Items.Count > 0)
|
|
writeModeComboBox.SelectedIndex = 0;
|
|
|
|
UpdateInputHint();
|
|
|
|
if (config != null)
|
|
Redraw();
|
|
}
|
|
|
|
public void Closing()
|
|
{
|
|
}
|
|
|
|
private void Redraw()
|
|
{
|
|
if (config == null)
|
|
return;
|
|
|
|
classNameLabel.Text = config.Factory.ClassName;
|
|
nameTextBox.Text = config.Name;
|
|
dataSourceTextBox.Text = config.DataSource;
|
|
writeTemplateTextBox.Text = config.QueryTemplate;
|
|
|
|
dataStorageTypeComboBox.Items.Clear();
|
|
|
|
ICollection<string> values = config.ParamValues(0);
|
|
if (values != null)
|
|
{
|
|
foreach (string item in values)
|
|
dataStorageTypeComboBox.Items.Add(item);
|
|
}
|
|
|
|
dataStorageTypeComboBox.Text = config.DataStorageType;
|
|
RefreshWriteParamsListBox();
|
|
}
|
|
|
|
public void Unlock()
|
|
{
|
|
nameTextBox.Enabled = true;
|
|
dataStorageTypeComboBox.Enabled = true;
|
|
dataSourceTextBox.Enabled = true;
|
|
writeTemplateTextBox.Enabled = true;
|
|
|
|
sourceTestResultTextBox.Enabled = true;
|
|
sourceTestResultTextBox.ReadOnly = true;
|
|
|
|
writeTestResultTextBox.Enabled = true;
|
|
writeTestResultTextBox.ReadOnly = true;
|
|
|
|
writeParamValueTextBox.Enabled = true;
|
|
listBoxWriteParams.Enabled = true;
|
|
buttonAddParam.Enabled = true;
|
|
buttonRemoveParam.Enabled = true;
|
|
|
|
writeModeComboBox.Enabled = true;
|
|
targetNameTextBox.Enabled = true;
|
|
}
|
|
|
|
public CfgUpdateFlags VerifyCfg(ref string message)
|
|
{
|
|
return CfgUpdateFlags.None;
|
|
}
|
|
|
|
public CfgUpdateFlags UpdateCfg()
|
|
{
|
|
CfgUpdateFlags flags = CfgUpdateFlags.None;
|
|
|
|
if (config == null)
|
|
return CfgUpdateFlags.Error;
|
|
|
|
if (config.Name != nameTextBox.Text)
|
|
{
|
|
config.Name = nameTextBox.Text;
|
|
flags |= (CfgUpdateFlags.AnyChange | CfgUpdateFlags.RestartRqrd);
|
|
}
|
|
|
|
flags |= UpdateDifferent(ref config.DataStorageType, dataStorageTypeComboBox.Text, CfgUpdateFlags.AnyChange | CfgUpdateFlags.RestartRqrd);
|
|
flags |= UpdateDifferent(ref config.DataSource, dataSourceTextBox.Text, CfgUpdateFlags.AnyChange | CfgUpdateFlags.RestartRqrd);
|
|
flags |= UpdateDifferent(ref config.QueryTemplate, writeTemplateTextBox.Text, CfgUpdateFlags.AnyChange | CfgUpdateFlags.RestartRqrd);
|
|
|
|
return flags;
|
|
}
|
|
|
|
private WriterCfg BuildTemporaryConfigFromUi()
|
|
{
|
|
WriterCfg tmpCfg = new WriterCfg(
|
|
string.IsNullOrWhiteSpace(nameTextBox.Text) ? "UniDataStorageWriter" : nameTextBox.Text,
|
|
config != null ? config.Factory : new Factory());
|
|
|
|
tmpCfg.DataStorageType = (dataStorageTypeComboBox.Text ?? string.Empty).Trim();
|
|
tmpCfg.DataSource = dataSourceTextBox.Text;
|
|
tmpCfg.QueryTemplate = writeTemplateTextBox.Text;
|
|
|
|
return tmpCfg;
|
|
}
|
|
|
|
private IDataStorageWriter CreateWriter(WriterCfg cfg)
|
|
{
|
|
switch ((cfg.DataStorageType ?? string.Empty).Trim())
|
|
{
|
|
case StorageTypes.RestApi:
|
|
return new RestApiWriter(cfg);
|
|
|
|
case StorageTypes.RemoteDatabase:
|
|
case StorageTypes.LocalDatabase:
|
|
return new DatabaseWriter(cfg);
|
|
|
|
case StorageTypes.RemoteJson:
|
|
case StorageTypes.LocalJson:
|
|
return new JsonWriter(cfg);
|
|
|
|
case StorageTypes.RemoteCsv:
|
|
case StorageTypes.LocalCsv:
|
|
return new CsvWriter(cfg);
|
|
|
|
default:
|
|
throw new NotSupportedException(
|
|
string.Format("Unsupported DataStorageType: '{0}'", cfg.DataStorageType));
|
|
}
|
|
}
|
|
|
|
private void testByDataSourceButton_Click(object sender, EventArgs e)
|
|
{
|
|
sourceTestResultTextBox.Clear();
|
|
|
|
try
|
|
{
|
|
WriterCfg cfg = BuildTemporaryConfigFromUi();
|
|
IDataStorageWriter writer = CreateWriter(cfg);
|
|
WriterDiagnosticResult result = writer.TestSource(true);
|
|
|
|
sourceTestResultTextBox.Text =
|
|
BuildDiagnosticHeader(cfg, "Source test") +
|
|
result.ToDisplayDiag();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
sourceTestResultTextBox.Text = BuildExceptionText("Data source test failed", ex);
|
|
}
|
|
}
|
|
|
|
private void writeDataByParamAndTemplateButton_Click(object sender, EventArgs e)
|
|
{
|
|
writeTestResultTextBox.Clear();
|
|
|
|
try
|
|
{
|
|
if (batchWriteLines.Count == 0)
|
|
throw new InvalidOperationException("At least one batch test item must be provided.");
|
|
|
|
WriterCfg cfg = BuildTemporaryConfigFromUi();
|
|
IDataStorageWriter writer = CreateWriter(cfg);
|
|
DataWriteRequest request = BuildWriteRequest();
|
|
|
|
WriterDiagnosticResult result = writer.WriteData(request);
|
|
|
|
writeTestResultTextBox.Text =
|
|
BuildDiagnosticHeader(cfg, "Write test") +
|
|
(result != null ? result.ToDisplayDiag() : "<null>");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
writeTestResultTextBox.Text = BuildExceptionText("WriteData test failed", ex);
|
|
}
|
|
}
|
|
|
|
private DataWriteRequest BuildWriteRequest()
|
|
{
|
|
DataWriteRequest request = new DataWriteRequest();
|
|
request.TargetName = (targetNameTextBox.Text ?? string.Empty).Trim();
|
|
|
|
WriteMode mode;
|
|
if (!Enum.TryParse(writeModeComboBox.Text, true, out mode))
|
|
mode = WriteMode.Insert;
|
|
|
|
request.Mode = mode;
|
|
|
|
foreach (string line in batchWriteLines)
|
|
{
|
|
if (mode == WriteMode.Insert)
|
|
{
|
|
request.InsertItems.Add(ParseInsertItem(line));
|
|
}
|
|
else if (mode == WriteMode.Update)
|
|
{
|
|
request.UpdateItems.Add(ParseUpdateItem(line));
|
|
}
|
|
}
|
|
|
|
return request;
|
|
}
|
|
|
|
private InsertWriteItem ParseInsertItem(string text)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(text))
|
|
throw new InvalidOperationException("Insert item is empty.");
|
|
|
|
string[] parts = text.Split(';');
|
|
|
|
if (parts.Length != 2)
|
|
throw new InvalidOperationException("Insert format must be: Column;Value");
|
|
|
|
return new InsertWriteItem
|
|
{
|
|
ColumnName = parts[0].Trim(),
|
|
Value = parts[1].Trim()
|
|
};
|
|
}
|
|
|
|
private UpdateWriteItem ParseUpdateItem(string text)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(text))
|
|
throw new InvalidOperationException("Update item is empty.");
|
|
|
|
string[] parts = text.Split(';');
|
|
|
|
if (parts.Length != 4)
|
|
throw new InvalidOperationException("Update format must be: WhereName;WhereValue;SetName;SetValue");
|
|
|
|
return new UpdateWriteItem
|
|
{
|
|
WhereParameterName = parts[0].Trim(),
|
|
WhereValue = parts[1].Trim(),
|
|
SetParameterName = parts[2].Trim(),
|
|
SetValue = parts[3].Trim()
|
|
};
|
|
}
|
|
|
|
private void buttonAddParam_Click(object sender, EventArgs e)
|
|
{
|
|
string text = writeParamValueTextBox.Text == null
|
|
? string.Empty
|
|
: writeParamValueTextBox.Text.Trim();
|
|
|
|
if (string.IsNullOrWhiteSpace(text))
|
|
return;
|
|
|
|
WriteMode mode;
|
|
if (!Enum.TryParse(writeModeComboBox.Text, true, out mode))
|
|
mode = WriteMode.Insert;
|
|
|
|
if (mode == WriteMode.Insert)
|
|
ParseInsertItem(text);
|
|
else if (mode == WriteMode.Update)
|
|
ParseUpdateItem(text);
|
|
|
|
batchWriteLines.Add(text);
|
|
writeParamValueTextBox.Clear();
|
|
RefreshWriteParamsListBox();
|
|
}
|
|
|
|
private void buttonRemoveParam_Click(object sender, EventArgs e)
|
|
{
|
|
int index = listBoxWriteParams.SelectedIndex;
|
|
|
|
if (index < 0 || index >= batchWriteLines.Count)
|
|
return;
|
|
|
|
batchWriteLines.RemoveAt(index);
|
|
RefreshWriteParamsListBox();
|
|
}
|
|
|
|
private void RefreshWriteParamsListBox()
|
|
{
|
|
listBoxWriteParams.Items.Clear();
|
|
|
|
for (int i = 0; i < batchWriteLines.Count; i++)
|
|
{
|
|
listBoxWriteParams.Items.Add(string.Format("{0}. {1}", i + 1, batchWriteLines[i]));
|
|
}
|
|
}
|
|
|
|
private void writeModeComboBox_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
UpdateInputHint();
|
|
}
|
|
|
|
private void UpdateInputHint()
|
|
{
|
|
if (writeModeComboBox.Text == WriteMode.Insert.ToString())
|
|
{
|
|
labelParamValue.Text = "Insert: Column;Value";
|
|
writeParamValueTextBox.Text = "Column;Value";
|
|
}
|
|
else
|
|
{
|
|
labelParamValue.Text = "Update: WhereName;WhereValue;SetName;SetValue";
|
|
writeParamValueTextBox.Text = "WhereName;WhereValue;SetName;SetValue";
|
|
}
|
|
}
|
|
|
|
private string BuildDiagnosticHeader(WriterCfg cfg, string testName)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.AppendLine("=== " + testName + " ===");
|
|
sb.AppendLine("Storage type: " + StorageTypeToDisplayName(cfg.DataStorageType));
|
|
sb.AppendLine("Data source: " + Safe(cfg.DataSource));
|
|
sb.AppendLine("Write mode: " + Safe(writeModeComboBox.Text));
|
|
sb.AppendLine("Target name: " + Safe(targetNameTextBox.Text));
|
|
sb.AppendLine("Query template: " + Safe(cfg.QueryTemplate));
|
|
sb.AppendLine();
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
private string BuildExceptionText(string title, Exception ex)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.AppendLine(title + ":");
|
|
sb.AppendLine(ex.Message);
|
|
|
|
Exception inner = ex.InnerException;
|
|
while (inner != null)
|
|
{
|
|
sb.AppendLine();
|
|
sb.AppendLine("Inner exception:");
|
|
sb.AppendLine(inner.Message);
|
|
inner = inner.InnerException;
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
private string Safe(string text)
|
|
{
|
|
return string.IsNullOrWhiteSpace(text) ? "<empty>" : text;
|
|
}
|
|
|
|
private string StorageTypeToDisplayName(string storageType)
|
|
{
|
|
switch ((storageType ?? string.Empty).Trim())
|
|
{
|
|
case StorageTypes.RestApi:
|
|
return "REST API";
|
|
|
|
case StorageTypes.RemoteDatabase:
|
|
return "Remote database";
|
|
|
|
case StorageTypes.RemoteJson:
|
|
return "Remote JSON";
|
|
|
|
case StorageTypes.RemoteCsv:
|
|
return "Remote CSV";
|
|
|
|
case StorageTypes.LocalDatabase:
|
|
return "Local database";
|
|
|
|
case StorageTypes.LocalJson:
|
|
return "Local JSON";
|
|
|
|
case StorageTypes.LocalCsv:
|
|
return "Local CSV";
|
|
|
|
default:
|
|
return Safe(storageType);
|
|
}
|
|
}
|
|
}
|
|
} |