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);
}
