public static async void AddToHistoricDataBase(string filePath, string atmId)//TODO: fix
{
var listTemp = await File.ReadAllLinesAsync(filePath);
var list = listTemp.ToList();
var toAdd = await db.Atms.FirstOrDefaultAsync(x => x.TID == atmId);
var listToAdd = new List <HistoricData>();
for (int i = 1; i < list.Count; i++)
{
var info = list[i].Split(',');
HistoricData hd = new HistoricData()
{
TID = info[0],
EventDate = Convert.ToDateTime(info[1], System.Globalization.CultureInfo.GetCultureInfo("hi-IN").DateTimeFormat),
PreviousPeriodID = int.Parse(info[2]),
PreviousLoad = Convert.ToDateTime(info[3], System.Globalization.CultureInfo.GetCultureInfo("hi-IN").DateTimeFormat),
PreviousDeposit = int.Parse(info[4]),
PreviousWithdraw = int.Parse(info[5]),
PreviousTransactionCount = int.Parse(info[6])
};
listToAdd.Add(hd);
}
toAdd.HD.AddRange(listToAdd);
await db.SaveChangesAsync();
}
public List <HistoricData> GetHistoricData(DateTime fromHere, int months = 6)
{
var testDate = fromHere;
var result = new List <HistoricData>();
for (var month = 0; month < months; month++)
{
var currentData = new HistoricData();
currentData.time = testDate;
result.Add(currentData);
foreach (var kvp in data)
{
if ((kvp.Key.Year == testDate.Year) && (kvp.Key.Month == testDate.Month))
{
currentData.data.Add(kvp.Value);
}
}
currentData.data.Sort();
testDate = testDate.AddMonths(-1);
}
return(result);
}
/// <summary>
/// Update all HistoricData information
/// </summary>
/// <remarks>This method updates all data information except protected fields that shouldn't be modified</remarks>
/// <param name="old">Old HistoricData information to be updated</param>
/// <param name="nou">New HistoricData information</param>
private void Update(HistoricData old, HistoricData nou)
{
var updated = db.HistoricData.Attach(old);
updated.Entity.Iddevice = nou.Iddevice;
updated.Entity.HistDataValue = nou.HistDataValue;
updated.Entity.IddataType = nou.IddataType;
updated.Entity.HistDataToDevice = nou.HistDataToDevice;
updated.Entity.HistDataAck = nou.HistDataAck;
updated.Entity.HistDataAux = nou.HistDataAux;
}
public IActionResult Put(int id, [FromBody] HistoricData nou)
{
logger.Info($"PUT Update data with id={id}");
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != nou.IdhistoricData)
{
return(BadRequest(new JObject {
["ID from body different from URL parameter"] = nou.IdhistoricData
}));
}
var data = db.HistoricData.Find(id);
if (data == null)
{
return(NotFound(new JObject {
["Data not found by id:"] = nou.Iddevice
}));
}
Update(data, nou);
try {
db.SaveChanges();
} catch (DbUpdateConcurrencyException ex) {
logger.Warn(ex, ex.Message);
if (!DataExists(id))
{
return(NotFound(new JObject {
["Data not found"] = "Data could have been deleted"
}));
}
return(BadRequest(nou));
} catch (Exception ex) {
logger.Trace(ex);
logger.Error(ex.Message);
return(BadRequest(nou));
}
return(NoContent());
}
public async Task <IActionResult> Index()
{
var folder = await _foldersProvider.GetActiveFolder();
SystemUser user = null;
if (HttpContext.User.Identity.IsAuthenticated)
{
user = await _usersProvider.GetUser(HttpContext.User.GetUserId());
folder = user.SelectedFolder;
}
var platforms = new string[] { "osx", "win7", "win", "linux" };
var runs = folder.Runs;
var model = new DashboardDataModel
{
FailedTests = new List <FailedTestPerPlatform>(),
Users = await _usersProvider.GetAllUsers()
};
foreach (var platform in platforms)
{
model.LatestStats.Add(await _runsProvider.GetLatestRunForEnvironment(platform, folder.Id));
}
foreach (var run in runs.GroupBy(p => p.Environment).OrderBy(p => p.Key))
{
var runner = run.OrderByDescending(p => p.ReportTime).FirstOrDefault();
model.LatestResults.Add(runner);
var allTestsInfo = await _runsProvider.GetAllTestsInfo();
foreach (var test in runner.FailedTests)
{
var testInfo = allTestsInfo.FirstOrDefault(p => p.TestName == test + ".py");
var failedTest = new FailedTestPerPlatform
{
LinuxRunId = runs.Where(p => p.Environment == "linux").OrderByDescending(p => p.ReportTime).FirstOrDefault()?.Id,
OsxRunId = runs.Where(p => p.Environment == "osx").OrderByDescending(p => p.ReportTime).FirstOrDefault()?.Id,
Win10RunId = runs.Where(p => p.Environment == "win").OrderByDescending(p => p.ReportTime).FirstOrDefault()?.Id,
Win7RunId = runs.Where(p => p.Environment == "win7").OrderByDescending(p => p.ReportTime).FirstOrDefault()?.Id,
TestId = runs.OrderByDescending(p => p.ReportTime).Where(p => p.Tests != null).SelectMany(z => z.Tests).FirstOrDefault(q => q.Name == test)?.Id,
Test = test,
Author = testInfo?.AuthorLogin,
Suit = testInfo?.SuiteName,
CurrentUser = user,
Linux = runs.OrderByDescending(p => p.ReportTime).FirstOrDefault(p => p.Environment == "linux")?.FailedTests.ToList().Exists(p => p == test),
Windows7 = runs.OrderByDescending(p => p.ReportTime).FirstOrDefault(p => p.Environment == "win7")?.FailedTests.ToList().Exists(p => p == test),
Osx = runs.OrderByDescending(p => p.ReportTime).FirstOrDefault(p => p.Environment == "osx")?.FailedTests.ToList().Exists(p => p == test),
Windows10 = runs.OrderByDescending(p => p.ReportTime).FirstOrDefault(p => p.Environment == "win")?.FailedTests.ToList().Exists(p => p == test)
};
model.FailedTests.Add(failedTest);
}
}
model.FailedTests = model.FailedTests.Distinct().ToList();
//Historic data
var groupedEnvironment = runs.GroupBy(p => p.Environment);
model.HistoricData = new List <HistoricData>();
foreach (var grouping in groupedEnvironment)
{
var newHistoricData = new HistoricData {
Platform = grouping.Key
};
var groupedDate = grouping.GroupBy(p => p.ReportTime.Date).OrderBy(p => p.Key);
newHistoricData.HistoricDataItems = new List <HistoricDataItems>();
foreach (var dt in groupedDate)
{
var item = dt.OrderByDescending(p => p.Total).FirstOrDefault();
if (item != null)
{
newHistoricData.HistoricDataItems.Add(new HistoricDataItems
{
DateLabel = dt.Key.ToShortDateString(),
Blocked = item.Blocked,
Failed = item.Failed,
Passed = item.Passed,
Skipped = item.Skipped,
Total = item.Total
});
}
}
model.HistoricData.Add(newHistoricData);
}
return(View(model));
}
public IActionResult Post([FromBody] HistoricData nou)
{
logger.Info("POST Insert new Data");
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var device = db.Devices.Find(nou.Iddevice);
if (device == null)
{
return(BadRequest(new JObject {
["Device not found"] = nou.Iddevice
}));
}
if (!device.DeviceEnabled)
{
return(BadRequest(new JObject {
["Device not enabled"] = nou.Iddevice
}));
}
if (!db.AuxDataType.Any(dev => nou.IddataType == dev.IdauxDataType))
{
return(BadRequest(new JObject {
["Data type not found"] = nou.IddataType
}));
}
var lastData = db.HistoricData.LastOrDefault();
if (lastData == default(HistoricData))
{
nou.IdhistoricData = 1;
}
else
{
nou.IdhistoricData = lastData.IdhistoricData + 1;
}
nou.HistDataDate = DateTime.Now;
db.HistoricData.Add(nou);
try {
db.SaveChanges();
} catch (DbUpdateException ex) {
logger.Warn(ex, ex.Message);
return(DataExists(nou.IdhistoricData) ? StatusCode((int)HttpStatusCode.Conflict, new JObject {
["Data exists already"] = nou.IdhistoricData
}) : BadRequest(nou));
} catch (Exception ex) {
logger.Trace(ex);
logger.Error(ex.Message);
return(BadRequest(nou));
}
if (!device.DeviceConnected) //nou HistoricData inserit correctament en aquest punt
{
ConnectDevice(device); //update nomes DeviceConnected del dispositiu
}
logger.Info("Data added correctly");
var ok = new JObject(new JProperty("Inserted data", JObject.FromObject(nou)),
new JProperty("Interval", device.DeviceInterval));
return(Created($"/api/historicdata/{nou.IdhistoricData}", ok));
}
