public void AddParent(DataPointDto parent) { base.X = parent.X; base.Y = parent.Y; base.AssignedClassification = parent.AssignedClassification; base.Id = parent.Id; }
protected override async Task OnInitializedAsync() { int.TryParse(QuestId, out var questId); int.TryParse(DataPointId, out var dataPointId); DataPoint = await DataPointDataService.GetDataPointForQuest(questId, dataPointId); }
public static List <DataPointDto> CreateDataPointDtos(ModbusUnit modbusUnit) { List <DataPointDto> dataDataPointDtos = new List <DataPointDto>(); var modbusUnitNumber = modbusUnit.Number; var modulesDic = modbusUnit.ModulesDic; foreach (var module in modulesDic) { var moduleNumber = module.Key; var dpOfmodules = module.Value.DataPoints; foreach (var dpOfm in dpOfmodules) { DataPointDto dataPointDto = ConverFrom(dpOfm); dataPointDto.ModuleNumber = moduleNumber; dataPointDto.ModuleName = module.Value.Name; dataPointDto.ModbusUnitNumber = modbusUnitNumber; dataPointDto.ModbusUnitName = modbusUnit.Connector.IpAddress.ToString() + ":" + modbusUnit.Connector.Port.ToString(); dataDataPointDtos.Add(dataPointDto); } } return(dataDataPointDtos); }
public DataPointLine(DataPointDto dataPoint1, DataPointDto dataPoint2, float offset) { X1 = dataPoint1.X + offset; Y1 = dataPoint1.Y + offset; X2 = dataPoint2.X + offset; Y2 = dataPoint2.Y + offset; }
public DataPointDto Read() { if (Position != BinaryFileDao.UnknownOffset) { Reader.BaseStream.Seek(Position, SeekOrigin.Begin); } else { // Save the position of the state information Position = Reader.BaseStream.Position; } DataPointDto dto = new DataPointDto(); dto.Dao = this; dto.Empty = Reader.ReadBoolean(); if (this.timestampDao == null) { this.timestampDao = new BinaryFileDateTimeDao(this); } dto.Timestamp = this.timestampDao.Read(); dto.Value = Reader.ReadDouble(); return(dto); }
public async Task CreateNewDataPoint(DataPointDto dataPointDto) { var dataPoint = new DataPoint(dataPointDto); await Add(dataPoint).ConfigureAwait(true); await SaveChanges(); }
public IGenericDto ToDto() { var dataPointDto = new DataPointDto(); dataPointDto.Id = this.Id; dataPointDto.X = this.X; dataPointDto.Y = this.Y; dataPointDto.AssignedClassification = this.AssignedClassification; return(dataPointDto); }
public void Push(DataPointDto newDataPointDto) { if (this.startIndex == -1) { Debug.Assert(this.endIndex == -1); Debug.Assert(this.currentSize == 0); // Empty case this.startIndex = this.endIndex = 0; this.currentSize++; } else if (this.currentSize < this.maxSize) { Debug.Assert(this.startIndex == 0); // Not full yet case, still filling up prior to wrapping around this.endIndex++; this.currentSize++; } else { Debug.Assert(this.startIndex != this.endIndex); Debug.Assert(this.currentSize == this.maxSize); // "Full" case, may require wrap around this.startIndex++; this.endIndex++; // Check for wrap around of either start or end if (this.endIndex == this.maxSize) { this.endIndex = 0; } else if (this.startIndex == this.maxSize) { this.startIndex = 0; } } Debug.Assert(GetAt(this.endIndex) != null); BinaryFileDataPointDao dataPointDao = GetAt(this.endIndex); // The data point DAO must know where it is on disk from when it was either created or read Debug.Assert(dataPointDao.Position != BinaryFileDao.UnknownOffset); dataPointDao.Write(newDataPointDto); newDataPointDto.Dao = (IDataPointDao)dataPointDao; // Write the updated archive state back to disk WriteState(); }
public static DataPointDto ConverFrom(DataPoint dataPoint) { DataPointDto dpDto = new DataPointDto(); dpDto.Number = dataPoint.Number; dpDto.Name = dataPoint.Name; dpDto.DeviceAddress = dataPoint.DeviceAddress; dpDto.StartRegisterAddress = dataPoint.StartRegisterAddress; dpDto.DataPointDataType = dataPoint.DataPointDataType; dpDto.DataPointType = dataPoint.DataPointType; dpDto.Description = dataPoint.Description; dpDto.RealTimeValue = dataPoint.RealTimeValue; dpDto.ValueToSet = dataPoint.ValueToSet; return(dpDto); }
private void ReadDataPoints() { ReadState(); BinaryFileDataPointDao[] unorderedDataPointDao = new BinaryFileDataPointDao[this.dto.MaxDataPoints]; DataPointDto[] unorderedDataPointDto = new DataPointDto[this.dto.MaxDataPoints]; // Read the whole array of data points into unordered list for (int i = 0; i < this.dto.MaxDataPoints; i++) { BinaryFileDataPointDao newDataPointDao = new BinaryFileDataPointDao(archiveDao); DataPointDto newDataPointDto = newDataPointDao.Read(); newDataPointDto.Dao = (IDataPointDao)newDataPointDao; unorderedDataPointDao[i] = newDataPointDao; unorderedDataPointDto[i] = newDataPointDto; } if (this.startIndex != UnknownIndex) { // Read from the first data point to the end of the array for (int i = this.startIndex; i < this.dto.MaxDataPoints; i++) { this.dataPoints.Add(unorderedDataPointDao[i]); if (unorderedDataPointDto[i].Empty != true) { this.dto.Add(unorderedDataPointDto[i]); } } // Read from the beginning of the array to the end of the wrap around for (int i = 0; i < this.startIndex; i++) { this.dataPoints.Add(unorderedDataPointDao[i]); if (unorderedDataPointDto[i].Empty != true) { this.dto.Add(unorderedDataPointDto[i]); } } } else { for (int i = 0; i < this.dto.MaxDataPoints; i++) { this.dataPoints.Add(unorderedDataPointDao[i]); } } }
private void CreateEmptyDataPoints(DataPointCircularQueueDto dto) { Debug.Assert(dto.MaxDataPoints >= dto.DataPoints.Length); // Write out the balance of empty data points for (int i = 0; i < dto.MaxDataPoints; i++) { DataPointDto emptyDataPointDto = new DataPointDto(); emptyDataPointDto.Empty = true; emptyDataPointDto.Timestamp = DateTime.Now; emptyDataPointDto.Value = Double.NaN; BinaryFileDataPointDao dataPointDao = new BinaryFileDataPointDao(this.archiveDao); dataPointDao.Write(emptyDataPointDto); this.dataPoints.Add(dataPointDao); } }
public static DataPointDto ConvertToDataPointInfoView(this DataPointViewModel dataPointViewModel) { DataPointDto dpDto = new DataPointDto(); dpDto.Id = dataPointViewModel.Id; dpDto.Number = dataPointViewModel.Number; dpDto.Name = dataPointViewModel.Name; dpDto.DeviceAddress = dataPointViewModel.DeviceAddress; dpDto.StartRegisterAddress = dataPointViewModel.StartRegisterAddress; dpDto.DataPointDataType = dataPointViewModel.DataPointDataType; dpDto.DataPointType = dataPointViewModel.DataPointType; dpDto.RealTimeValue = dataPointViewModel.RealTimeValue; dpDto.ValueToSet = dataPointViewModel.ValueToSet; dpDto.ModuleNumber = dataPointViewModel.ModuleNumber; dpDto.ModuleName = dataPointViewModel.ModuleName; dpDto.ModbusUnitNumber = dataPointViewModel.ModbusUnitNumber; return(dpDto); }
public static DataPointViewModel ConvertToDataPointViewModel(this DataPointDto dataPointDto) { DataPointViewModel dpVm = new DataPointViewModel(); dpVm.Id = dataPointDto.Id; dpVm.Number = dataPointDto.Number; dpVm.Name = dataPointDto.Name; dpVm.DeviceAddress = dataPointDto.DeviceAddress; dpVm.StartRegisterAddress = dataPointDto.StartRegisterAddress; dpVm.DataPointDataType = dataPointDto.DataPointDataType; dpVm.DataPointType = dataPointDto.DataPointType; dpVm.RealTimeValue = dataPointDto.RealTimeValue; dpVm.ValueToSet = dataPointDto.ValueToSet; dpVm.ModuleNumber = dataPointDto.ModuleNumber; dpVm.ModuleName = dataPointDto.ModuleName; dpVm.ModbusUnitNumber = dataPointDto.ModbusUnitNumber; dpVm.ModbusUnitName = dataPointDto.ModbusUnitName; return(dpVm); }
public void Write(DataPointDto dto) { if (Position == BinaryFileDao.UnknownOffset) { Writer.Seek(0, SeekOrigin.End); // Record where the data point has been written Position = Writer.BaseStream.Position; } else { // Go to the location of the datum in the file Writer.BaseStream.Seek((int)Position, SeekOrigin.Begin); } Writer.Write(dto.Empty); if (this.timestampDao == null) { this.timestampDao = new BinaryFileDateTimeDao(this); } this.timestampDao.Create(dto.Timestamp); Writer.Write(dto.Value); }
public static List <DataPointDto> ReadFromFileDto() { if (!File.Exists(_path)) { File.Create(_path); } try { var dataPoints = new List <DataPointDto>(); string[] lines = File.ReadAllLines(_path); foreach (var line in lines) { DataPointDto pointDto = new DataPointDto(); string[] numbers = line.Split(' '); if (numbers.Count() > 1) { pointDto.X = float.Parse(numbers[0]); pointDto.Y = float.Parse(numbers[1]); if (numbers.Count() > 2 && numbers[2] != "") { pointDto.AssignedClassification = Int32.Parse(numbers[2]); } dataPoints.Add(pointDto); } } return(dataPoints); } catch { throw new Exception("Invalid data"); } }
public void Create(DataPointDto dto) { Write(dto); }
public DataPoint(DataPointDto dataPointDto) { FromDto(dataPointDto); }
public async Task <Result> Handle(Query request, CancellationToken cancellationToken) { var budgetCategoryIdsQuery = _accessControlService.GetAccessibleBudgetCategoryIds(request.BudgetId, request.BudgetCategoryType); if (request.BudgetCategoryIds != null && request.BudgetCategoryIds.Any()) { budgetCategoryIdsQuery = budgetCategoryIdsQuery.Where(x => request.BudgetCategoryIds.Any(s => s == x)); } var budgetCurrency = _readDb.Budgets.First(x => x.BudgetId == request.BudgetId).Currency; var budgetCategoryIds = budgetCategoryIdsQuery.ToList(); var budgetCategories = _readDb.BudgetCategories.Where(x => budgetCategoryIds.Contains(x.BudgetCategoryId)).ToList(); var query = _readDb.Transactions.Where(x => budgetCategoryIds.Contains(x.BudgetCategoryId)); query = query.Where(x => x.TransactionDate >= request.TransactionDateStart.Date && x.TransactionDate <= request.TransactionDateEnd.Date); var transactions = await query.ToListAsync(cancellationToken); if (!transactions.Any()) { return(new Result()); } var timelinePeriod = new DateRange(request.TransactionDateStart, request.TransactionDateEnd); var periods = request.GroupingStep switch { eGroupingStep.Day => timelinePeriod.Start.EachDayTo(timelinePeriod.End), eGroupingStep.Year => timelinePeriod.Start.EachYearTo(timelinePeriod.End), eGroupingStep.Month => timelinePeriod.Start.EachMonthTo(timelinePeriod.End), eGroupingStep.Quarter => timelinePeriod.Start.EachQuarterTo(timelinePeriod.End), eGroupingStep.Week => timelinePeriod.Start.EachWeekTo(timelinePeriod.End, CultureInfo.CurrentCulture.DateTimeFormat.FirstDayOfWeek), _ => throw new ArgumentOutOfRangeException() }; var dateRanges = transactions.GroupBy(x => periods.FirstOrDefault(s => s.Contains(x.TransactionDate))) .Select(periodGroup => { var period = periodGroup.Key; var categoryDataPoints = budgetCategories.Select(category => { var categoryId = category.BudgetCategoryId; var categoryAmount = periodGroup.Where(s => s.BudgetCategoryId == categoryId) .Select(s => s.Amount + s.SubTransactions.Select(t => t.Amount).Aggregate(new MoneyAmount(budgetCurrency.CurrencyCode, 0), (a, b) => a + b)) .Aggregate(new MoneyAmount(budgetCurrency.CurrencyCode, 0), (a, b) => a + b); return(new BudgetCategoryDataPointDto() { DateRange = period, BudgetCategoryId = categoryId, Key = period.ToString(), AmountTotal = categoryAmount }); }) .ToList(); var totalAmount = categoryDataPoints.Select(x => x.AmountTotal) .Aggregate(new MoneyAmount(budgetCurrency.CurrencyCode, 0), (a, b) => a + b); return(new DateRangeData() { DateRange = period, Key = period.ToString(), BudgetCategories = categoryDataPoints, Total = new DataPointDto() { DateRange = period, Key = period.ToString(), AmountTotal = totalAmount } }); }) .OrderByDescending(x => x.DateRange.Start) .ToList(); if (dateRanges.Count > 1) { for (var i = 0; i < dateRanges.Count - 1; i++) { var current = dateRanges[i]; var previous = dateRanges[i + 1]; foreach (var budgetCategoryDataPoint in current.BudgetCategories) { var previousBudgetCategoryDataPoint = previous.BudgetCategories.FirstOrDefault(x => x.BudgetCategoryId == budgetCategoryDataPoint.BudgetCategoryId); if (previousBudgetCategoryDataPoint == null) { continue; ; } budgetCategoryDataPoint.AmountTotalChange = previousBudgetCategoryDataPoint.AmountTotal.Amount > 0 ? (budgetCategoryDataPoint.AmountTotal.Amount - previousBudgetCategoryDataPoint.AmountTotal.Amount) / previousBudgetCategoryDataPoint.AmountTotal.Amount : (decimal?)null; budgetCategoryDataPoint.AmountPerDayChange = previousBudgetCategoryDataPoint.AmountPerDay.Amount > 0 ? (budgetCategoryDataPoint.AmountPerDay.Amount - previousBudgetCategoryDataPoint.AmountPerDay.Amount) / previousBudgetCategoryDataPoint.AmountPerDay.Amount : (decimal?)null; budgetCategoryDataPoint.AmountPerWeekChange = previousBudgetCategoryDataPoint.AmountPerWeek.Amount > 0 ? (budgetCategoryDataPoint.AmountPerWeek.Amount - previousBudgetCategoryDataPoint.AmountPerWeek.Amount) / previousBudgetCategoryDataPoint.AmountPerWeek.Amount : (decimal?)null; budgetCategoryDataPoint.AmountPerMonthChange = previousBudgetCategoryDataPoint.AmountPerMonth.Amount > 0 ? (budgetCategoryDataPoint.AmountPerMonth.Amount - previousBudgetCategoryDataPoint.AmountPerMonth.Amount) / previousBudgetCategoryDataPoint.AmountPerMonth.Amount : (decimal?)null; } current.Total.AmountTotalChange = previous.Total.AmountTotal.Amount > 0 ? (current.Total.AmountTotal.Amount - previous.Total.AmountTotal.Amount) / previous.Total.AmountTotal.Amount : (decimal?)null; current.Total.AmountPerDayChange = previous.Total.AmountTotal.Amount > 0 ? (current.Total.AmountPerDay.Amount - previous.Total.AmountPerDay.Amount) / previous.Total.AmountPerDay.Amount : (decimal?)null; current.Total.AmountPerWeekChange = previous.Total.AmountTotal.Amount > 0 ? (current.Total.AmountPerWeek.Amount - previous.Total.AmountPerWeek.Amount) / previous.Total.AmountPerWeek.Amount : (decimal?)null; current.Total.AmountPerMonthChange = previous.Total.AmountTotal.Amount > 0 ? (current.Total.AmountPerMonth.Amount - previous.Total.AmountPerMonth.Amount) / previous.Total.AmountPerMonth.Amount : (decimal?)null; } } var budgetCategoryTotals = dateRanges.SelectMany(x => x.BudgetCategories) .GroupBy(x => x.BudgetCategoryId) .Select(x => new BudgetCategoryDataPointDto() { Key = timelinePeriod.ToString(), DateRange = timelinePeriod, BudgetCategoryId = x.Key, AmountTotal = x.Select(s => s.AmountTotal) .Aggregate(new MoneyAmount(budgetCurrency.CurrencyCode, 0), (a, b) => a + b) }) .ToList(); var total = new DataPointDto() { DateRange = timelinePeriod, Key = timelinePeriod.ToString(), AmountTotal = budgetCategoryTotals.Select(x => x.AmountTotal) .Aggregate(new MoneyAmount(budgetCurrency.CurrencyCode, 0), (a, b) => a + b) }; return(new Result() { Data = new ResponseDto() { DateRanges = dateRanges, BudgetCategoryTotals = budgetCategoryTotals, Total = total } }); } }
public ColoredDataPoint(DataPointDto parent) { AddParent(parent); }