public ActionResult Create([Bind(Include = "Id,ParseDate,ParserType,Original,Firmname,Description,Statistic,Price,SearchedArtikul,Url")] ParsedData parsedData)
{
if (ModelState.IsValid)
{
db.ParsedDatas.Add(parsedData);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(parsedData));
}
public void NotClassifiedBuildMessageType()
{
var span = Utils.CreateSpan("-1");
var match = Regex.Match(span.GetText(), "(?<Type>.*)");
var data = ParsedData.Create <BuildFileRelatedMessageData>(match, span.Span);
var dataProcessor = new BuildFileRelatedMessageDataProcessor();
var result = dataProcessor.ProcessData(span, data);
result.Should().BeEmpty();
}
private void AppendActivity(IFieldDataResultsAppender appender, ParsedData parsedData,
FieldVisitInfo visitInfo, ILog logger)
{
var visitInterval = new DateTimeInterval(visitInfo.StartDate, visitInfo.EndDate);
var dischargeActivity = new ActivityMapper(parsedData, visitInterval)
.GetDischargeActivity();
logger.Info($"Got discharge activity for {visitInfo.StartDate:s}@{visitInfo.LocationInfo.LocationIdentifier}.");
appender.AddDischargeActivity(visitInfo, dischargeActivity);
}
/// <summary>
/// 여러 설정 값을 XML 형식으로 저장/불러오기 하는 클래스를 생성합니다.
/// </summary>
/// <param name="xmlType">다룰 데이터의 XML 타입.</param>
public XmlParser(EXmlType xmlType)
{
this.XmlType = xmlType;
switch (xmlType)
{
case EXmlType.MitsubishiPLCData:
m_XmlSerializer = new XmlSerializer(typeof(MitsubishiPLCData));
ParsedData = new MitsubishiPLCData();
break;
}
}
public void NotClassifiedTraceEventType()
{
var span = Utils.CreateSpan("-1");
var match = Regex.Match(span.GetText(), "(?<Type>.*)");
var data = ParsedData.Create <DebugTraceMessageData>(match, span.Span);
var dataProcessor = new DebugTraceMessageDataProcessor();
var result = dataProcessor.ProcessData(span, data);
Assert.IsFalse(result.Any());
}
public async Task SendAsync(ParsedData parsedData)
{
var keyValues = parsedData.KeyValues;
_logger.LogInformation($"{Measurement}, {parsedData.DateTime}, {keyValues.Count()}");
// var point = PointData.Measurement(Measurement);
// if (parsedData.DateTime.HasValue)
// point = point.Timestamp(parsedData.DateTime.Value, WritePrecision.Ms);
// if (!string.IsNullOrEmpty(parsedData.DevEUI))
// point = point.Tag("DevEUI", parsedData.DevEUI);
// foreach (var keyValue in parsedData.KeyValues)
// {
// if (keyValue.Value is int valInt)
// point = point.Field(keyValue.Key, (long)valInt);
// else if (keyValue.Value is long valLong)
// point = point.Field(keyValue.Key, valLong);
// else if (keyValue.Value is ulong valUlong)
// point = point.Field(keyValue.Key, valUlong);
// else if (keyValue.Value is double valDouble)
// point = point.Field(keyValue.Key, valDouble);
// else if (keyValue.Value is float valFloat)
// point = point.Field(keyValue.Key, valFloat);
// else if (keyValue.Value is decimal valDecimal)
// point = point.Field(keyValue.Key, valDecimal);
// else if (keyValue.Value is bool valBool)
// point = point.Field(keyValue.Key, valBool);
// else if (keyValue.Value is string valString)
// point = point.Field(keyValue.Key, valString);
// }
// WriteApi.WritePoint(point);
// return Task.CompletedTask;
var info = new DynamicInfluxRow();
if (parsedData.DateTime.HasValue)
{
info.Timestamp = parsedData.DateTime.Value;
}
if (!string.IsNullOrEmpty(parsedData.DevEUI))
{
info.Tags.Add("DevEUI", parsedData.DevEUI);
}
foreach (var keyValue in parsedData.KeyValues)
{
info.Fields.Add(keyValue.Key, keyValue.Value);
}
_logger.LogInformation($"Tags: {string.Join(", ", info.Tags.Select(s => $"{s.Key}={s.Value}"))}");
_logger.LogInformation($"Fields: {string.Join(", ", info.Fields.Select(s => $"{s.Key}={s.Value}"))}");
await InfluxClient.WriteAsync(Database, Measurement, new DynamicInfluxRow[] { info });
}
public void Test_errors_double_conversion()
{
var input = "1+2.1.1";
ParsedData parsedData = Parser.ConvertStringToData(input);
CalcResult actual = Calculator.Calculate(parsedData);
CalcResult expected = new CalcResult(Single.NaN, ErrorMessages.double_conversion);
Assert.AreEqual(expected, actual);
}
public void Test_errors_math_operators_absent()
{
var input = "123";
ParsedData parsedData = Parser.ConvertStringToData(input);
CalcResult actual = Calculator.Calculate(parsedData);
CalcResult expected = new CalcResult(Single.NaN, ErrorMessages.mathOp_absent);
Assert.AreEqual(expected, actual);
}
public void Test_empty_string()
{
var input = "";
ParsedData parsedData = Parser.ConvertStringToData(input);
CalcResult actual = Calculator.Calculate(parsedData);
CalcResult expected = new CalcResult(Single.NaN, ErrorMessages.empty_input);
Assert.AreEqual(expected, actual);
}
public void Test_multiplication()
{
var input = "1+2+3*3+5*6";
ParsedData parsedData = Parser.ConvertStringToData(input);
CalcResult actual = Calculator.Calculate(parsedData);
CalcResult expected = new CalcResult(42, "");
Assert.AreEqual(expected, actual);
}
public void Test_errors_division_to_zero()
{
var input = "1/0";
ParsedData parsedData = Parser.ConvertStringToData(input);
CalcResult actual = Calculator.Calculate(parsedData);
CalcResult expected = new CalcResult(Single.NaN, ErrorMessages.division_to_zero);
Assert.AreEqual(expected, actual);
}
protected void ButtonCalc_Click(object sender, EventArgs e)
{
TextBoxResult.Text = "";
string math_sequence = GetMathSequence();
ParsedData parsedData = Parser.ConvertStringToData(math_sequence);
CalcResult calcResult = Calculator.Calculate(parsedData);
PublicResult(calcResult);
}
/// <summary>
/// Create object to display the dependency grouping from the parsed code data
/// </summary>
/// <returns></returns>
public DependencyGroup BuildDependencyGroup(ParsedData data)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
var result = new DependencyGroup
{
name = "",
datemodified = DateTime.UtcNow.ToString("s") + "Z",
children = new List <Children>()
};
var blackList = new List <string> {
"jersey", "jackson", "versioncheck", "web", "metrics", "audit", "configuration", "grok", "gettingstarted", "utilities", "timeranges",
"rules", "bootstrap", "buffers", "bindings", "savedsearches", "shared", "log4j"
};
foreach (var t in data.packageNames)
{
result.children.Add(new Children
{
name = t.Trim(),
size = null,
datemodified = RandomDateTime(),
children = new List <Children>()
});
}
foreach (var child in result.children)
{
var matching = data.connectorsArray.Where(x => x[0].ToLower() == child.name.ToLower());
foreach (var match in matching)
{
if (blackList.Contains(match[1].ToLower()))
{
continue;
}
child.children.Add(new Children
{
children = null,
datemodified = RandomDateTime(),
name = match[1],
size = 1
});
}
}
return(result);
}
public void Test_four_elements_add()
{
var input = "1+2+3+4";
ParsedData parsedData = Parser.ConvertStringToData(input);
CalcResult actual = Calculator.Calculate(parsedData);
CalcResult expected = new CalcResult(10, "");
Assert.AreEqual(expected, actual);
}
public void Test_errors_parentheses()
{
var input = "1+3*(2+5";
ParsedData parsedData = Parser.ConvertStringToData(input);
CalcResult actual = Calculator.Calculate(parsedData);
CalcResult expected = new CalcResult(Single.NaN, ErrorMessages.parentheses);
Assert.AreEqual(expected, actual);
}
public void Test_parentheses()
{
var input = "1+2*(3+4/(1+1))+5*(6*7-36)";
ParsedData parsedData = Parser.ConvertStringToData(input);
CalcResult actual = Calculator.Calculate(parsedData);
CalcResult expected = new CalcResult(41, "");
Assert.AreEqual(expected, actual);
}
public void Test_decimal_division()
{
var input = "1.2+2,4+3/4";
ParsedData parsedData = Parser.ConvertStringToData(input);
CalcResult actual = Calculator.Calculate(parsedData);
CalcResult expected = new CalcResult(4.35, "");
Assert.AreEqual(expected, actual);
}
public ActionResult DeleteConfirmed(IEnumerable <int> selectedDatas, string OrderId)
{
if (selectedDatas != null) //Если выбрана хотя бы одна строка для удаления
{
foreach (var id in selectedDatas)
{
ParsedData parsedData = db.ParsedDatas.Find(id);
db.ParsedDatas.Remove(parsedData);
}
db.SaveChanges();
}
return(RedirectToAction("Index", new { OrderId = OrderId }));
}
private void WriteFile()
{
using (var write = new StreamWriter(_newFilePath, true, Encoding.UTF8))
{
write.Write(ParsedData.ToString());
}
ParsedData.Clear();
ParsedData = new StringBuilder();
GC.Collect();
GC.WaitForPendingFinalizers();
}
public void TestMethod8()
{
ParsedData currencyPair = new ParsedData();
currencyPair.CurencyFrom = "eur";
currencyPair.CurencyTo = "ABC";
currencyPair.AmountFrom = 5m;
Exchange exchange = new Exchange();
Assert.ThrowsException <Exception>(
() => exchange.CalculateAmount(currencyPair)
);
}
public void TestMethod5()
{
string text = "EUR/DKK 1";
ParsedData parsedData = Utility.Console.ParseData(text);
ParsedData currencyPair = new ParsedData();
currencyPair.CurencyFrom = "EUR";
currencyPair.CurencyTo = "DKK";
currencyPair.AmountFrom = 1m;
bool isEqual = ObjectsValuesAreEqual(currencyPair, parsedData);
Assert.IsTrue(isEqual);
}
public void SeleniumParse()
{
IWebDriver driver = new ChromeDriver(AppDomain.CurrentDomain.BaseDirectory);
driver.Navigate().GoToUrl(_pageUrl);
var elements = driver.FindElements(By.CssSelector("div[data-name|='dashboard-champ-content']"));
var count = 0;
for (int i = 0; i < elements.Count; i++)
{
var liga = new Liga();
IWebElement item = elements[i];
var ligaItem = item.FindElement(By.CssSelector($"div>div.c-events__name>a"));
liga.Id = ligaItem != null?ligaItem.GetAttribute("data-ligaid") : string.Empty;
liga.Title = ligaItem != null?ligaItem.GetAttribute("title") : string.Empty;
liga.Matches = item.FindElements(By.CssSelector($"div.c-events__item.c-events__item_col")).Select(c =>
{
var teamNamesSelector = "div.c-events-scoreboard div.c-events-scoreboard__item a.c-events__name div.c-events__team";
var teamNames = c.FindElements(By.CssSelector(teamNamesSelector)).Select(h => h.Text);
var matchUrlAttributeSelector = "a.c-events__name";
var url = c.FindElements(By.CssSelector(matchUrlAttributeSelector)).Select(h => h.GetAttribute("href")).FirstOrDefault();
var score = c.FindElements(By.CssSelector("span.c-events-scoreboard__cell.c-events-scoreboard__cell--all")).Select(h => int.Parse(h.Text)).ToArray();
var rates = c.FindElements(By.CssSelector("div.c-bets a")).Select(k => k.Text).Take(3).ToArray();
var time = c.FindElements(By.CssSelector("div.c-events__time span")).Select(k => k.Text).FirstOrDefault();
return(new Match
{
Id = ++count,
FirstTeam = new Team {
TeamName = teamNames.ElementAtOrDefault(0)
},
SecondTeam = new Team {
TeamName = teamNames.ElementAtOrDefault(1)
},
Url = url,
LigaId = liga.Id,
Score = score,
RateData = rates.Length == 3 ? new RateData {
FirstTeamWinRate = rates[0], SecondTeamWinRate = rates[2], DrawRate = rates[1]
} : null,
MatchTime = time
});
}).ToList();
ParsedData.Add(liga);
}
}
private string DecryptText(ParsedData parsedData, Pixel firstCoordinates, ImageInfo imageInfo)
{
StringBuilder stringBuilder = new StringBuilder(parsedData.LengthOfText);
Pixel previousCoordinates = firstCoordinates;
for (int i = 0; i < parsedData.LengthOfText; i++)
{
previousCoordinates = GetNextCoordinates(previousCoordinates, imageInfo);
stringBuilder.Append(FindSymbolInHashes(parsedData, previousCoordinates));
}
return(stringBuilder.ToString());
}
// GET: ParsedDatas/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ParsedData parsedData = db.ParsedDatas.Find(id);
if (parsedData == null)
{
return(HttpNotFound());
}
return(View(parsedData));
}
private void CreateBackup(ParsedData parsedData)
{
_dataFile = parsedData.DataFile;
if (File.Exists(_dataFile + ".dat"))
{
var exception = new DataFileAlreadyExistsException(_dataFile + ".dat");
BackupLogger.GetInstance().Error(exception.Message);
throw exception;
}
File.Create(_dataFile + ".dat").Close();
_backupSystem = parsedData.BackupSystem;
_backupSystem.CreateRestore(new RestoreFactory(RestoreType.Full));
}
protected static void ExportJsonInformation(TextWriter stream, ParsedData data)
{
using var writer = new JsonTextWriter(stream);
var serializer = new JsonSerializer
{
Formatting = Formatting.Indented,
ContractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
},
};
serializer.Serialize(writer, data);
}
public void TestMissedFieldsModel()
{
ModelMapper <MissedFieldsModel> mapper = new ModelMapper <MissedFieldsModel>();
MissedFieldsModel model = new MissedFieldsModel()
{
Id = "1",
Name = null
};
ParsedData data = ParseService.Parse(testLine);
MissedFieldsModel result = mapper.Map(data);
result.Should().BeEquivalentTo(model);
}
private static ParsedData SeparateCurrencies(string data)
{
Regex regex = new Regex(@"[A-z]{3}");
string[] currencies = regex.Matches(data)
.OfType <Match>()
.Select(m => m.Groups[0].Value)
.ToArray();
ParsedData parsedData = new ParsedData();
parsedData.CurencyFrom = currencies[0].ToUpper();
parsedData.CurencyTo = currencies[1].ToUpper();
return(parsedData);
}
public void TestNormalModel()
{
ModelMapper <TestModel> mapper = new ModelMapper <TestModel>();
TestModel model = new TestModel
{
Id = "1",
Name = "TestMessage"
};
ParsedData data = ParseService.Parse(testLine);
TestModel result = mapper.Map(data);
result.Should().BeEquivalentTo(model);
}
public void ExportParsedData(ParsedData data, string outputPath, bool excludeHeader)
{
if (data is null)
{
throw new ArgumentNullException(nameof(data));
}
using var writer = new StreamWriter(outputPath, false, new UTF8Encoding(false));
if (!excludeHeader)
{
var text = string.Format(CultureInfo.InvariantCulture, "{0} ({1})", data.Version.SemVer, DateTime.Now.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture));
writer.WriteLine(text);
WriteUnderline(writer, text.Length, '=');
}
var breakingNotes = data.ReleaseNotes.Notes.Where(n => n.Key == "BREAKING CHANGE" || n.Key == "BREAKING CHANGES");
if (data.ReleaseNotes.BreakingChanges.Count > 0)
{
writer.WriteLine();
const string header = "BREAKING CHANGES";
writer.WriteLine(header);
WriteUnderline(writer, header.Length);
foreach (var breakingChange in data.ReleaseNotes.BreakingChanges)
{
writer.WriteLine(breakingChange);
}
if (breakingNotes.Any())
{
writer.WriteLine();
}
}
foreach (var notePain in breakingNotes)
{
AddNoteLines(writer, notePain, data.ReleaseNotes.BreakingChanges.Count == 0);
}
foreach (var notePair in data.ReleaseNotes.Notes.Except(breakingNotes))
{
AddNoteLines(writer, notePair, true);
}
writer.Flush();
this.console.WriteInfoLine(":check_mark: Exported [teal]Plain Text Release Notes[/] to '[teal]{0}[/]'", outputPath);
}
public void NotParsed()
{
var parser = new StubIParser<ParsedData>();
parser.TryParseSnapshotSpanT0Out = delegate(SnapshotSpan s, out ParsedData r) {
r = new ParsedData();
return false;
};
var processor = new StubIParsedDataProcessor<ParsedData>();
processor.ProcessDataSnapshotSpanT0 = (s, d) => new List<ProcessedParsedData> {
new ProcessedParsedData(s, "TestClassification")
};
var classifier = Utils.CreateParserBasedClassifier(parser, processor);
var span = Utils.CreateSpan("");
var classificationSpans = classifier.GetClassificationSpans(span);
Assert.AreEqual(0, classificationSpans.Count);
}
public Parser()
{
scanner = new Scanner();
parsedData = new ParsedData();
}
Contribution AddPayPalContribution(ParsedData parsed) {
try {
if ((parsed.Status != "Completed" && parsed.Status != "Cleared") || parsed.Gross <= 0) return null; // not a contribution!
double netEur;
double grossEur;
if (parsed.Currency == "EUR") {
netEur = parsed.Net;
grossEur = parsed.Gross;
}
else {
netEur = ConvertToEuros(parsed.Currency, parsed.Net);
grossEur = ConvertToEuros(parsed.Currency, parsed.Gross);
}
int? accountID, jarID;
TryParseItemCode(parsed.ItemCode, out accountID, out jarID);
Contribution contrib;
using (var db = new ZkDataContext()) {
Account acc = null;
ContributionJar jar;
if (jarID == null) jar = db.ContributionJars.FirstOrDefault(x => x.IsDefault);
else jar = db.ContributionJars.FirstOrDefault(x => x.ContributionJarID == jarID);
if (accountID != null) acc = db.Accounts.Find(accountID.Value);
if (!string.IsNullOrEmpty(parsed.TransactionID) && db.Contributions.Any(x => x.PayPalTransactionID == parsed.TransactionID)) return null; // contribution already exists
var isSpring = !parsed.ItemCode.StartsWith("ZK") || jar.IsDefault;
contrib = new Contribution()
{
AccountByAccountID = acc,
Name = parsed.Name,
Euros = grossEur,
KudosValue = (int)Math.Round(grossEur*GlobalConst.EurosToKudos),
OriginalAmount = parsed.Gross,
OriginalCurrency = parsed.Currency,
PayPalTransactionID = parsed.TransactionID,
ItemCode = parsed.ItemCode,
Time = parsed.Time,
EurosNet = netEur,
ItemName = parsed.ItemName,
Email = parsed.Email,
RedeemCode = Guid.NewGuid().ToString(),
IsSpringContribution = isSpring,
ContributionJar = jar
};
db.Contributions.Add(contrib);
db.SaveChanges();
if (acc != null) acc.Kudos = acc.KudosGained - acc.KudosSpent;
db.SaveChanges();
// technically not needed to sent when account is known, but perhaps its nice to get a confirmation like that
SendEmail(contrib);
NewContribution(contrib);
}
return contrib;
} catch (Exception ex) {
Trace.TraceError("Error processing payment: {0}", ex);
Error(ex.ToString());
return null;
}
}