private void AddLabel(bool addLabelToPolir = true)
{
// Adds a new label to table.
int counter = LabelTable.Count;
LabelRow row = new LabelRow()
{
Name = "m" + counter,
Index = counter
};
LabelTable.Add(row);
// Adds label mi to if in the stack.
OutputRow outputRow = stack.Pop();
if (outputRow.RelatedLabels == null)
{
outputRow.RelatedLabels = new List <string>();
}
outputRow.RelatedLabels.Add(row.Name);
stack.Push(outputRow);
// Adds label mi to POLIR if addLabelToPolir == true
if (addLabelToPolir == true)
{
AddToPolir(row.Name);
}
}
// Dones one iteration.
public void DoStep()
{
currentLexem = (OutputRow)OutputTable[index];
switch (MakeCompare(stack.Peek(), inputChain[0]))
{
case CompareSymbol.Less: IfLess(); break;
case CompareSymbol.Bigger: IfBigger(); break;
case CompareSymbol.Equal: IfEqual(); break;
}
stepCount++;
}
async public void WriteData()
{
await Task.Run(() =>
{
ResultList.Sort();
try
{
DateTime dtCurr = DateTime.Now;
string strflOutput = strTemp + "\\" + Guid.NewGuid() + ".csv";
//MessageBox.Show(strflOutput);
System.IO.StreamWriter swFL = new System.IO.StreamWriter(strflOutput);
swFL.WriteLine("ASCII");
swFL.WriteLine(",");
swFL.WriteLine("Administrator,1,Server Local,10,0");
foreach (FastLoadData OutputRow in ResultList)
{
swFL.WriteLine(OutputRow.GetExportString());
}
System.Threading.Thread.Sleep(1);
swFL.Flush();
swFL.Close();
ResultList.Clear();
ResultList.TrimExcess();
string fileName = System.IO.Path.GetFileName(strflOutput);
string destFile = System.IO.Path.Combine(strFL, fileName);
try
{
System.IO.File.Move(strflOutput, destFile);
}
catch (Exception exCopy)
{
logger.Error("Error while copying file {0}: {1} ", fileName, exCopy.Message);
}
}
catch (Exception ex)
{
logger.Error("Error while writing: {0}", ex.Message);
}
});
}
// Compares to terms.
private CompareSymbol MakeCompare(string first, string second)
{
Identify(ref first);
int rowIndex = 0;
for (int i = 0; i < CompareTable.Rows.Count; i++)
{
if (CompareTable.Rows[i].HeaderCell.Value.ToString() == first)
{
rowIndex = i;
break;
}
}
Identify(ref second);
int columnIndex = 0;
for (int i = 0; i < CompareTable.ColumnCount; i++)
{
if (CompareTable.Columns[i].HeaderCell.Value.ToString() == second)
{
columnIndex = i;
break;
}
}
string symbol = CompareTable[columnIndex, rowIndex].Value.ToString();
if (symbol == "<")
{
return(CompareSymbol.Less);
}
if (symbol == ">")
{
return(CompareSymbol.Bigger);
}
if (symbol == "=")
{
return(CompareSymbol.Equal);
}
currentLexem = OutputTable[index];
throw new SyntaxException("Порушено структуру програми. Помилковий елемент \"" +
currentLexem.Name + "\", рядок " + currentLexem.Line);
}
// This is the custom mapping. We now separate it into a method, so that we can use it both in training and in loading. public static void IncomeMapping(InputRow input, OutputRow output) => output.Label = input.Income > 50000;
public List <OutputRow> Convert(ExelSheet sheet, string[] conversionDataLimiter = null,
Action <int> progressAction = null,
Action <Exception, int> additionalErrorAction = null,
Func <bool> isCanceled = null)
{
Guid logSession = Helpers.Old.Log.SessionStart("ExelConvertionRule.Convert()");
var result = new List <OutputRow>();
try
{
if (sheet.MainHeader != null)
{
var initialRow = 0;
var headers = sheet.SheetHeaders.Headers;
var subheaders = sheet.SheetHeaders.Subheaders;
initialRow = sheet.Rows.IndexOf(sheet.MainHeader) + sheet.MainHeaderRowCount;
int excludeRow = 0;
bool hasError = false;
int logPart = 0;
var exceptions = new List <Exception>();
for (var i = initialRow; i < sheet.Rows.Count; i++)
{
if (isCanceled != null && isCanceled())
{
break;
}
var outputRow = new OutputRow();
try
{
exceptions.Clear();
hasError = false;
if (progressAction != null)
{
progressAction((int)(((decimal)i / (decimal)sheet.Rows.Count) * 100m));
}
logPart = 1;
if (headers.Any(h => h.RowNumber == i) || subheaders.Any(h => h.RowNumber == i))
{
continue;
}
outputRow.OriginalIndex = sheet.Rows[i].Index;
outputRow.OriginalSheet = sheet.Name;
logPart++;
foreach (var convertionData in (conversionDataLimiter == null ? ConvertionData : ConvertionData.Where(i2 => conversionDataLimiter.Contains(i2.PropertyId))))
{
var cellResultContent = string.Empty;
int subLogPart = 1;
try
{
var propertyOld = typeof(OutputRow).GetProperty("Original" + convertionData.PropertyId);
if (propertyOld != null)
{
string oldValue = null;
subLogPart++;
var blocks = convertionData.Blocks.Blocks.FirstOrDefault();
if (blocks != null)
{
subLogPart++;
var startFunc = blocks.UsedFunctions.FirstOrDefault();
if (startFunc != null)
{
subLogPart++;
if (startFunc.Function.SelectedParameter == FunctionParameters.CellName)
{
subLogPart++;
var header = sheet.Rows[sheet.Rows.IndexOf(sheet.MainHeader)].HeaderCells.Select(c => c.Value).ToList();
var columnNumber = header.IndexOf(header.Where(s => s.Trim().ToLower() == startFunc.Function.ColumnName.Trim().ToLower()).FirstOrDefault());
if (columnNumber >= 0 && sheet.Rows.ElementAt(i).Cells.Count > columnNumber)
{
oldValue = sheet.Rows.ElementAt(i).Cells.ElementAt(columnNumber).Value;
}
}
else if (startFunc.Function.SelectedParameter == FunctionParameters.CellNumber)
{
subLogPart++;
if (sheet.Rows.ElementAt(i).Cells.Count > startFunc.Function.ColumnNumber)
{
oldValue = sheet.Rows.ElementAt(i).Cells.ElementAt(startFunc.Function.ColumnNumber).Value;
}
}
}
}
if (oldValue != null)
{
propertyOld.SetValue(outputRow, oldValue.Trim(), null);
}
}
try
{
cellResultContent = convertionData.Blocks.Run(sheet, i, convertionData);
//if (cellResultContent != null)
//{
// cellResultContent = cellResultContent.Trim();
//}
}
catch (Exception ex)
{
throw new Exception(string.Format("Сетка '{0}'. Ошибка для правил столбца '{1}' ('{2}')", sheet.Name, convertionData.FieldName, convertionData.PropertyId), ex);
}
var property = typeof(OutputRow).GetProperty(convertionData.PropertyId);
if (property != null)
{
property.SetValue(outputRow, cellResultContent, null);
}
}
catch (Exception ex)
{
hasError = true;
if (additionalErrorAction != null)
{
Helpers.Old.Log.Add(logSession, ex);
exceptions.Add(ex);
}
else
{
throw new Exception(string.Format("exception on update field '{0}' at sub step '{1}';", convertionData.PropertyId, subLogPart), ex);
}
}
}
logPart++;
if (!string.IsNullOrWhiteSpace(outputRow.Region) && outputRow.Region.Contains('(') && outputRow.Region.Contains(')'))
{
//outputRow.Region = outputRow.Region.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault();
outputRow.Region = outputRow.Region.Substring(0, outputRow.Region.LastIndexOf("(") - 1).Trim();
}
logPart++;
if (!string.IsNullOrWhiteSpace(outputRow.Size) && outputRow.Size.Contains('(') && outputRow.Size.Contains(')'))
{
//outputRow.Size = outputRow.Size.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault();
outputRow.Size = outputRow.Size.Substring(0, outputRow.Size.LastIndexOf("(") - 1).Trim();
}
logPart++;
if (!string.IsNullOrWhiteSpace(outputRow?.Code?.Trim()) || (hasError && additionalErrorAction != null))
{
if (additionalErrorAction != null)
{
foreach (var ex in exceptions)
{
additionalErrorAction(ex, i - initialRow - excludeRow);
}
exceptions.Clear();
}
result.Add(outputRow);
}
else
{
excludeRow++;
}
}
catch (Exception ex)
{
if (additionalErrorAction != null)
{
Helpers.Old.Log.Add(logSession, ex);
if (!result.Contains(outputRow))
{
result.Add(outputRow);
}
additionalErrorAction(ex, i - initialRow - excludeRow);
}
else
{
throw new Exception(string.Format("exception at row line: '{0}', log part: '{1}';", i, logPart), ex);
}
}
}
}
else
{
Log.Add(string.Format("sheet '{0}' has not header!", sheet.Name));
}
}
catch (Exception ex)
{
Helpers.Old.Log.Add(logSession, ex);
}
finally
{
RemoveRepeatingId(result);
Helpers.Old.Log.SessionEnd(logSession);
}
return(result);
}
private bool ReadGENX()
{
XmlNodeList nameList = xmlReadDoc.GetElementsByTagName("UpdateVersion");
foreach (XmlNode xn in nameList)
{
string version = xn.Attributes["Version"].Value;
//Console.WriteLine(version);
XmlNodeList childNode = xn.ChildNodes;
foreach (XmlNode xnc in childNode)
{
if (xnc.Name == "Topics")
{
XmlNodeList xnl = xmlReadDoc.GetElementsByTagName("FeatureClass");
foreach (XmlNode x1 in xnl)
{
string fClassName = x1.Attributes["Name"].Value;
string fClassOperation = x1.Attributes["Operation"].Value;
string fClassCaption = String.Empty;
if (x1["Caption"] != null)
{
fClassCaption = x1["Caption"].InnerXml;
}
OutputRow outputRowForCopy = new OutputRow(version);
outputRowForCopy.SetFeatureClass(fClassOperation, fClassName, fClassCaption);
if (x1["Attributes"] == null) continue;
foreach (XmlNode x2 in x1["Attributes"])
{
string attributName = x2.Attributes["Name"].Value;
string attributOperation = x2.Attributes["Operation"].Value;
string attributCatption = String.Empty;
if (x2["Caption"] != null)
{
attributCatption = x2["Caption"].InnerXml;
}
OutputRow outPutRow = (OutputRow)outputRowForCopy.Clone();
outPutRow.SetAttribut(attributOperation, attributName, attributCatption);
convertControler.AddFeatureClassRow(outPutRow);
}
}
}
else if (xnc.Name == "DomainTables")
{
foreach (XmlNode xnd in xnc)
{
string domainClassName = xnd.Attributes["Name"].Value;
string domainClassOperation = xnd.Attributes["Operation"].Value;
string domainClassDescription = String.Empty;
if (xnd["Caption"] != null)
{
domainClassDescription = xnd["Caption"].InnerXml;
}
OutputRow outputRowForCopy = new OutputRow(version);
outputRowForCopy.SetDomainClass(domainClassOperation, domainClassName, domainClassDescription);
foreach (XmlNode xne in xnd.ChildNodes)
{
if (xne.Name != "DomainEntries") continue;
foreach (XmlNode xna in xne.ChildNodes)
{
string id = xna.Attributes["Id"].Value;
string value = String.Empty;
if (xna["Value"] != null)
{
value = xna["Value"].InnerXml;
}
string operation = xna.Attributes["Operation"].Value;
string active = xna.Attributes["Active"].Value;
OutputRow domainRow = (OutputRow)outputRowForCopy.Clone();
domainRow.SetDomainEntry(operation, value, id, active);
convertControler.AddFeatureClassRow(domainRow);
}
}
}
}
}
}
return true;
}
public void AddFeatureClassRow(OutputRow listEntry)
{
OutputRows.Add(listEntry);
}
