public IActionResult List([FromBody] DateRangeDto listParameters) { try { if (listParameters == null || !ModelState.IsValid) { return(BadRequest("Invalid State")); } var basicTransactions = _basicTransactionService.Between(listParameters.Start, listParameters.End); var recurringTransactions = _recurringTransactionService.Between(listParameters.Start, listParameters.End); return(Ok(new TransactionListDto { Transactions = basicTransactions .Concat(recurringTransactions) .OrderByDescending(t => t.Date) .Select(t => new TransactionDto(t)) .ToList() })); } catch (Exception) { return(BadRequest("Error while creating")); } }
public IActionResult List([FromBody] DateRangeDto listParameters) { try { if (listParameters == null || !ModelState.IsValid) { return(BadRequest("Invalid State")); } var basic = _basicIncomeService.Between(listParameters.Start, listParameters.End); var recurring = _recurringIncomeService.Between(listParameters.Start, listParameters.End); return(Ok(new IncomeListDto { Incomes = basic .Concat(recurring) .OrderByDescending(i => i.Date) .Select(t => new IncomeDto(t)) .ToList() })); } catch (Exception) { return(BadRequest("Error while listing incomes")); } }
public FixedParticipantDto(Participant source, DateRangeDto fixedAssignmentDates) { Id = source.Id; Name = source.Name; AssignmentDates = fixedAssignmentDates ?? throw new ArgumentNullException(nameof(fixedAssignmentDates)); }
public IActionResult Create([FromBody] DateRangeDto dateRange) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _dateRangeService.Add(dateRange); return(CreatedAtAction(nameof(Get), new { id = dateRange.Id }, dateRange)); }
public MasterPlanDto(MasterPlan source) { Id = source.Id; Name = source.Name; FixedDates = new DateRangeDto(source.FixedDates); Participants = source .Participants .Select(x => new ParticipantDto(x)) .ToList(); }
public StatisticsDto GetStatistics(string id, DateRangeDto dataRange) { var expendirues = _expenditureRepository.GetExpendituresOfUserFromRange(id, dataRange.From, dataRange.To); var statisticsDto = new StatisticsDto { ExpidituresCount = expendirues.Count, SumOfExpenditures = expendirues.Sum(x => x.Amount), MostExpensiveExpenditures = _mapper.Map <List <ExpenditureDto> >(expendirues.OrderByDescending(x => x.Amount).Take(NUMBER_OF_MOST_EXPENSIVE_EXPENDITURES).ToList()) }; return(statisticsDto); }
public IHttpActionResult GetFixedParticipants(long id) { var masterPlan = GetMasterPlan(id); var fixedDates = new DateRangeDto(masterPlan.FixedDates); //var builder = new FixedParticipantBuilder(masterPlan); var participantsDto = masterPlan .FixedParticipants //.Select(builder.Build); .Select(x => new FixedParticipantDto(x, fixedDates)); return(Ok(participantsDto)); }
public IList <SimpleData> GetChartData(string userId, DateRangeDto dataRange) { var experditures = _expenditureRepository.GetExpendituresOfUserFromRange(userId, dataRange.From, dataRange.To); var data = experditures.GroupBy(x => x.Category) .Select(x => new SimpleData { Color = x.Key.ChartColor, Label = x.Key.Name, Value = x.Sum(y => (double)y.Amount) }); return(data.ToList()); }
public void GetAll_Success_ReturnEntities() { // Arrange var repository = new ReceiptRepository(); var dateRangeDto = new DateRangeDto { StartDate = DateTime.Now.AddDays(-100), EndDate = DateTime.Now }; var result = repository.GetAll(dateRangeDto); // Assert Assert.IsInstanceOf <IEnumerable <Receipt> >(result); }
public IActionResult GetIntersected([FromBody] DateRangeDto dateRange) { if (!ModelState.IsValid) { return(BadRequest()); } else { var datesIntersect = _dateRangeService .FindBy(d => d.IsIntersectedRange(dateRange)); if (datesIntersect != null) { return(Ok(datesIntersect)); } return(NotFound()); } }
public async void RequestSessionAsync_Returns_New_SessionRequestDto() { var studioId = Guid.NewGuid(); var room = Room.Create(studioId, "Room"); var userId = Guid.NewGuid(); var startTime = DateTime.Now; var endTime = startTime.AddHours(2); var requestedTime = DateRange.Create(startTime, endTime); var entity = room.RequestSession(userId, requestedTime, null, _sessionScheduleValidator.Object); var requestedTimeDto = new DateRangeDto { Start = startTime, End = endTime }; _roomRepository .Setup(r => r.GetAsync(It.IsAny <Guid>())) .Returns(Task.FromResult(room)); _roomRepository .Setup(r => r.RequestSessionAsync(It.IsAny <SessionRequest>())) .Returns(Task.FromResult(entity)); _sessionScheduleValidator .Setup(v => v.ValidateAsync(It.IsAny <Guid>(), It.IsAny <Guid?>(), It.IsAny <DateRange>())) .Returns(Task.FromResult(SessionScheduleValidatorResult.Success)); var dto = new SessionRequestDto { RoomId = room.Id, RequestingUserId = userId, RequestedTime = new DateRangeDto { Start = startTime, End = endTime } }; var result = await _roomService.RequestSessionAsync(dto); Assert.NotNull(result); Assert.Equal(entity.Id, result.Id); Assert.Equal(entity.RoomId, result.RoomId); Assert.Equal(entity.RoomFunctionId, result.RoomFunctionId); Assert.Equal(entity.RequestingUserId, result.RequestingUserId); Assert.Equal(entity.RequestedStartTime, result.RequestedTime.Start); Assert.Equal(entity.RequestedEndTime, result.RequestedTime.End); }
public IEnumerable <Receipt> GetAll(DateRangeDto dateRange) { using (var ctx = new AppDbContext()) { var query = ctx.Receipts.AsQueryable(); if (dateRange != null) { dateRange.EndDate.AddDays(1); query = query.Where(rc => dateRange.StartDate <= rc.CreationTime && rc.CreationTime <= dateRange.EndDate); } return(query .Include(rc => rc.Order) .Include(rc => rc.Order.Provider) .Include(rc => rc.CreationUser) .ToList()); } }
public async Task <IActionResult> RequestSession(Guid id, [FromBody] DateRangeDto requestedTime) { var room = await _roomService.GetAsync(id); if (room == null) { return(NotFound()); } var model = new SessionRequestDto { RoomId = room.Id, RequestingUserId = UserId.Value, RequestedTime = requestedTime }; model.RequestedTime?.ConvertToUtc(UserTimeZone.Name); var request = await _roomService.RequestSessionAsync(model); return(Ok(request)); }
public void GetIntersected(DateTime dateStart, DateTime dateEnd) { DateRangeDto dto = new DateRangeDto { DateStart = dateStart, DateEnd = dateEnd }; if (dto.DateStart < dto.DateEnd) { // Send the request HttpWebRequest httpRequest = (HttpWebRequest)WebRequest .Create($"http://localhost:62679/api/daterange/getintersected"); httpRequest.Method = "POST"; var data = JsonConvert .SerializeObject(dto); byte[] byteArray = Encoding.UTF8.GetBytes(data); httpRequest.ContentType = "application/json"; httpRequest.ContentLength = byteArray.Length; Stream dataStream = httpRequest.GetRequestStream(); dataStream.Write(byteArray, 0, byteArray.Length); dataStream.Close(); // Get the response WebResponse response = httpRequest.GetResponse(); Console.WriteLine($"Status code: {((HttpWebResponse)response).StatusDescription}"); dataStream = response.GetResponseStream(); StreamReader reader = new StreamReader(dataStream); string responseFromServer = reader.ReadToEnd(); var servicedata = JsonConvert.DeserializeObject <IEnumerable <DateRangeDto> >(responseFromServer); foreach (var item in servicedata) { Console.WriteLine($"{item.DateStart.ToShortDateString()} - {item.DateEnd.ToShortDateString()}"); } reader.Close(); dataStream.Close(); response.Close(); } }
public void GetOrdersWithFilter_Success_ReturnEntities() { // Arrange var repository = new OrderRepository(); var status = new List <OrderStatus>() { OrderStatus.WaitForSent, OrderStatus.Sent, OrderStatus.Done }; var range = new DateRangeDto { StartDate = DateTime.Now.AddDays(-10), EndDate = DateTime.Now }; // Act var result = repository.GetOrdersWithFilter(status, 10, range); // Assert Assert.IsInstanceOf <IEnumerable <Order> >(result); }
public FixedParticipantBuilder(MasterPlan masterPlan) { fixedRange = new DateRangeDto(masterPlan.FixedDates); }
public async Task <List <Debt> > FindByQuery(string debtorId, DateRangeDto rangeDto) { return(await _dbSet .Where(x => x.DebtorId == debtorId && x.CreationDate.Date >= rangeDto.BeginDate.Date && x.CreationDate.Date <= rangeDto.EndDate.Date) .ToListAsync()); }
public ActionResult GetStatistics(DateRangeDto dataRange) { var statistics = _expenditureService.GetStatistics(User.Identity.GetUserId(), dataRange); return(PartialView("_StatisticsPartial", statistics)); }
public ActionResult Index(DateRangeDto dataRange) { return(RedirectToAction("Index", new { to = dataRange.To, from = dataRange.From })); }
public async Task <ActionResult <IEnumerable <PowerUsageSampleDto> > > GetPowerUsageSamples([FromBody] DateRangeDto dateRange) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } string mac = dateRange.Mac; Plug plug = await _context.Plugs.Include(p => p.Samples).SingleOrDefaultAsync(p => p.Mac == mac); if (plug == null) { return(NotFound(Error.PlugDoesNotExist)); } if (UserOwnershipValidator.IsNotValidated(_currentUsername, plug, _context)) { return(Unauthorized(Error.UnauthorizedOwner)); } return(Ok(_mapper.Map <List <PowerUsageSampleDto> >(plug.Samples .Where(s => s.SampleDate >= dateRange.EarlierDate && s.SampleDate <= dateRange.LaterDate) .OrderBy(s => s.SampleDate)))); }
public static void ConvertToUtc(this DateRangeDto target, string sourceTimeZoneId) { target.Start = DateTimeConverter.ConvertToUtc(target.Start, sourceTimeZoneId); target.End = DateTimeConverter.ConvertToUtc(target.End, sourceTimeZoneId); }
public static void ConvertFromUtc(this DateRangeDto target, string destinationTimeZoneId) { target.Start = DateTimeConverter.ConvertFromUtc(target.Start, destinationTimeZoneId); target.End = DateTimeConverter.ConvertFromUtc(target.End, destinationTimeZoneId); }
public IEnumerable <ReceiptForListDto> GetAllReceipts(DateRangeDto dateRange) { var receipt = _receipRepository.GetAll(dateRange); return(Mapper.Map <IEnumerable <ReceiptForListDto> >(receipt)); }
public static bool IsIntersectedRange(this DateRangeDto range, DateRangeDto other) { return(range.DateStart <= other.DateEnd && range.DateEnd >= other.DateStart); }
private ExpendituresDto CreateExpendituresDto(IList <Expenditure> listOfExpenditures, DateRangeDto calculatedDateRange) { return(new ExpendituresDto { Expenditures = _mapper.Map <List <ExpenditureDto> >(listOfExpenditures), From = calculatedDateRange.From, To = calculatedDateRange.To }); }
public IEnumerable <Order> GetOrdersWithFilter(List <OrderStatus> status, int limit, DateRangeDto dateRange) { using (var ctx = new AppDbContext()) { var query = ctx.Orders.AsQueryable(); if (dateRange != null) { query = query.Where(o => dateRange.StartDate <= o.CreationTime && o.CreationTime <= dateRange.EndDate); } if (status != null) { query = query.Where(o => status.Contains((OrderStatus)o.Status)); } query = query.Take(limit); query = query.Include(o => o.CreationUser).Include(o => o.Provider); var orders = query.ToList(); return(orders); } }
public async Task <SessionDto> RescheduleSessionAsync(Guid roomId, Guid sessionId, DateRangeDto newSchedule) { var room = await _roomRepository.GetAsync(roomId); var entity = room.Sessions.Single(s => s.Id == sessionId); var schedule = newSchedule == null ? null : DateRange.Create(newSchedule.Start, newSchedule.End); var model = room.RescheduleSession(entity, schedule, _sessionScheduleValidator); var updatedEntity = await _roomRepository.RescheduleSessionAsync(model.Id, model.Schedule); var result = _mapper.Map <SessionDto>(updatedEntity); return(result); }
public IEnumerable <OrderForListDto> GetOrders(List <OrderStatus> filter, DateRangeDto dateRange) { var orders = _orderRepository.GetOrdersWithFilter(filter, 10, dateRange); return(Mapper.Map <IEnumerable <OrderForListDto> >(orders)); }
public MasterPlanPopUpDto(MasterPlan source) { Id = source.Id; Name = source.Name; FixedDates = new DateRangeDto(source.FixedDates); }
public static bool IsValidRange(this DateRangeDto range) { return(range.DateStart < range.DateEnd); }