public List <Holiday> GetHolidays(bool getFlexibleHolidaysOnly, DateRangeDTO dateRange)
{
var holidays = DataWarehouse.DataWarehouse.Holidays
.Where(x => x.Date.Date >= dateRange.StartDate.Date);
if (dateRange.EndDate != null)
{
holidays = holidays.Where(x => x.Date.Date <= dateRange.EndDate?.Date);
}
else
{
holidays = holidays.Where(x => x.Date.Date == dateRange.StartDate.Date);
}
if (getFlexibleHolidaysOnly)
{
holidays = holidays
.Where(x => x.HolidayType == HolidayType.Flexible)
.ToList();
}
else
{
holidays = holidays.ToList();
}
return((List <Holiday>)holidays);
}
public async Task <ApiResponse <int> > GetTotalServiceCost(DateRangeDTO dateRange)
{
ApiResponse <int> result = new ApiResponse <int>();
try
{
//complete order object
var CO = await unitOfWork.CompleteOrdersManager.GetAsync(A => A.OrderDateTime.Value.Date <= dateRange.EndDate.Date && A.OrderDateTime.Value.Date >= dateRange.StartDate.Date);
if (CO != null)
{
int total = 0;
var COList = CO.ToList();
for (int i = 0; i < CO.Count(); i++)
{
total += (int)COList[i].OrderTotalAmount;
}
result.Data = total;
result.Succeeded = true;
return(result);
}
else
{
result.Succeeded = false;
result.Errors.Add("Could not Find Any Complete order");
return(result);
}
}
catch (Exception ex)
{
result.Succeeded = false;
result.Errors.Add(ex.Message);
return(result);
}
}
public async Task HolidayIntent(IDialogContext context, LuisResult result)
{
var hasUsername = context.UserData.ContainsKey(usernameKey);
if (!hasUsername)
{
await context.PostAsync("First tell me your name first \U0001F61C");
await context.Forward(new GreetingDialog(true), SetUsername, result, CancellationToken.None);
}
else
{
if (result.AlteredQuery != null)
{
await context.PostAsync($"Searching for {result.AlteredQuery} \U0001F609");
}
var hasFlexibleEntity = await TryFind(result, flexibleEntity);
DateTime startTime;
DateTime?endTime;
var hasDate = TryGetDateRange(result, true, out startTime, out endTime);
var dateRange = new DateRangeDTO(startTime, endTime);
if (hasFlexibleEntity)
{
await context.Forward(new FlexibleHolidayDialog(dateRange, holidayService), AfterFlexibleHolidayIntent, result, CancellationToken.None);
}
else
{
await context.Forward(new HolidayDialog(dateRange, holidayService), AfterHolidayIntent, result, CancellationToken.None);
}
}
}
public async Task <ApiResponse <int> > GetNumberOfSignedInBarbers(DateRangeDTO dateRange)
{
ApiResponse <int> result = new ApiResponse <int>();
try
{
var CO = await unitOfWork.BarberLoginsManager.GetSignedInbarbers(dateRange);
if (CO != 0)
{
result.Data = CO;
result.Succeeded = true;
return(result);
}
else
{
result.Succeeded = false;
result.Errors.Add("Error finding barber logins !");
return(result);
}
}
catch (Exception ex)
{
result.Succeeded = false;
result.Errors.Add(ex.Message);
return(result);
}
}
public async Task <List <LeaveRequest> > GetLeaveAsync(string username, DateRangeDTO dateRange)
{
var tableManager = new AzureTableManager(userLeavesTable);
string leaveDateQuery;
if (dateRange.EndDate == null)
{
leaveDateQuery = TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, username),
TableOperators.And,
TableQuery.GenerateFilterConditionForDate("Date", QueryComparisons.Equal, dateRange.StartDate)
);
}
else
{
leaveDateQuery = TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, username),
TableOperators.And,
TableQuery.CombineFilters(
TableQuery.GenerateFilterConditionForDate("Date", QueryComparisons.GreaterThanOrEqual, dateRange.StartDate),
TableOperators.And,
TableQuery.GenerateFilterConditionForDate("Date", QueryComparisons.LessThanOrEqual, (DateTime)dateRange.EndDate))
);
}
var leaveEntities = await tableManager.RetrieveEntity <LeaveEntity>(leaveDateQuery);
var leaveRequests = Mapper.MapLeaveEntityToLeaveRequest(leaveEntities);
return(leaveRequests);
}
public ShowRequestDialog(DateRangeDTO dateRange, ShowRequest showRequest)
{
this._dateRange = dateRange;
this._showRequest = showRequest;
this.leaveService = new LeaveService();
this.flexibleHolidayService = new FlexibleHolidayService();
}
/// per given date
///
public async Task <ApiResponse <int> > GetTotalNumberCustomer(DateRangeDTO dateRange)
{
ApiResponse <int> result = new ApiResponse <int>();
try
{
//complete order object
var CO = await unitOfWork.CompleteOrdersManager.GetAsync(A => A.OrderDateTime.Value.Date <= dateRange.EndDate.Date && A.OrderDateTime.Value.Date >= dateRange.StartDate.Date);
var lol = dateRange.EndDate.Date;
List <CompleteOrder> completeOrdersList = CO.ToList();
if (CO != null)
{
result.Data = CO.Count();
result.Succeeded = true;
return(result);
}
else
{
result.Succeeded = false;
result.Errors.Add("Could not Find Any Complete order");
return(result);
}
}
catch (Exception ex)
{
result.Succeeded = false;
result.Errors.Add(ex.Message);
return(result);
}
}
public async Task <List <Holiday> > GetOptedInHolidays(string username, DateRangeDTO dateRange)
{
var tableManager = new AzureTableManager(userFlexibleHolidaysTable);
string optInHolidayDateQuery;
if (dateRange.EndDate == null)
{
optInHolidayDateQuery = TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, username),
TableOperators.And,
TableQuery.GenerateFilterConditionForDate("Date", QueryComparisons.Equal, dateRange.StartDate)
);
}
else
{
optInHolidayDateQuery = TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, username),
TableOperators.And,
TableQuery.CombineFilters(
TableQuery.GenerateFilterConditionForDate("Date", QueryComparisons.GreaterThanOrEqual, dateRange.StartDate),
TableOperators.And,
TableQuery.GenerateFilterConditionForDate("Date", QueryComparisons.LessThanOrEqual, (DateTime)dateRange.EndDate))
);
}
var holidayEntities = await tableManager.RetrieveEntity <FlexibleHolidayEntity>(optInHolidayDateQuery);
var holidayList = Mapper.MapHolidayEntityToHoliday(holidayEntities);
return(holidayList);
}
public async Task ApplyLeaveIntent(IDialogContext context, LuisResult result)
{
var hasUsername = context.UserData.ContainsKey(usernameKey);
if (!hasUsername)
{
await context.PostAsync("First tell me your name \U0001F61C");
await context.Forward(new GreetingDialog(true), SetUsername, result, CancellationToken.None);
}
else
{
if (result.AlteredQuery != null)
{
await context.PostAsync($"Searching for {result.AlteredQuery} \U0001F609");
}
var hasFlexibleEntity = await TryFind(result, flexibleEntity);
DateTime startTime;
DateTime?endTime;
var hasDate = TryGetDateRange(result, false, out startTime, out endTime);
var dateRange = new DateRangeDTO(startTime, endTime);
if (hasFlexibleEntity)
{
await context.PostAsync("It seems like you want to take a flexible holiday");
await context.Forward(new FlexibleHolidayDialog(dateRange, holidayService), AfterFlexibleHolidayIntent, result, CancellationToken.None);
}
else
{
List <EntityRecommendation> entities = new List <EntityRecommendation>();
var hasReasonEntity = await TryFind(result, reasonEntity);
if (hasReasonEntity)
{
entities.Add(GetEntity(result, reasonEntity));
}
if (hasDate)
{
entities.Add(new EntityRecommendation {
Type = "StartDate", Entity = startTime.ToString()
});
if (endTime != null)
{
entities.Add(new EntityRecommendation {
Type = "EndDate", Entity = endTime.ToString()
});
}
}
context.Call(new ApplyLeaveDialog(entities), AfterApplyLeaveRequest);
}
}
}
public async Task <IActionResult> GetAll(DateTime dateStart, DateTime dateEnd)
{
var dateRange = new DateRangeDTO {
DateEnd = dateEnd,
DateStart = dateStart
};
var res = await this._invoiceService.InvoiceBuyGetAllToList(dateRange);
return(Ok(res));
}
public static DateRangeDTO DateRangeFixedHours(DateRangeDTO dateRange)
{
var s = dateRange.DateStart;
var e = dateRange.DateEnd;
return(new DateRangeDTO
{
DateStart = new DateTime(s.Year, s.Month, s.Day, 0, 0, 0).ToUniversalTime(),
DateEnd = new DateTime(e.Year, e.Month, e.Day, 23, 59, 59).ToUniversalTime()
});
}
public async Task <int> GetSignedInbarbers(DateRangeDTO dateRange)
{
return(await Task.Run(() =>
{
int Result = 0;
Result = context.BarberLogins.Where(A => A.LoginDateTime.Value.Date <= dateRange.EndDate.Date && A.LoginDateTime.Value.Date >= dateRange.StartDate.Date).Count();
return Result;
}));
}
public async Task ShowRequestIntent(IDialogContext context, LuisResult result)
{
var hasUsername = context.UserData.ContainsKey(usernameKey);
if (!hasUsername)
{
await context.PostAsync("First tell me your name \U0001F61C");
await context.Forward(new GreetingDialog(true), SetUsername, result, CancellationToken.None);
}
else
{
if (result.AlteredQuery != null)
{
await context.PostAsync($"Searching for {result.AlteredQuery} \U0001F609");
}
var hasFlexibleEntity = await TryFind(result, flexibleEntity);
var hasLeaveEntity = await TryFind(result, "Leave");
DateTime startTime;
DateTime?endTime;
var hasDate = TryGetDateRange(result, true, out startTime, out endTime);
var dateRange = new DateRangeDTO(startTime, endTime);
if (hasFlexibleEntity && hasLeaveEntity)
{
await context.PostAsync("It seems like you want to view your Opted In flexible holidays and your leaves also");
await context.Forward(new ShowRequestDialog(dateRange, ShowRequest.All), AfterShowRequestIntent, result, CancellationToken.None);
}
else if (hasFlexibleEntity)
{
await context.PostAsync("It seems like you want to view your Opted In flexible holidays only");
await context.Forward(new ShowRequestDialog(dateRange, ShowRequest.Flexible), AfterShowRequestIntent, result, CancellationToken.None);
}
else if (hasLeaveEntity)
{
await context.PostAsync("It seems like you want to view your leaves only");
await context.Forward(new ShowRequestDialog(dateRange, ShowRequest.Leave), AfterShowRequestIntent, result, CancellationToken.None);
}
else
{
await context.PostAsync("It seems like you want to view your submitted requests");
await context.Forward(new ShowRequestDialog(dateRange, ShowRequest.All), AfterShowRequestIntent, result, CancellationToken.None);
}
}
}
public async Task <IActionResult> GetAll(DateTime dateStart, DateTime dateEnd)
{
var dateRange = new DateRangeDTO
{
DateEnd = dateEnd,
DateStart = dateStart
};
var dateRangeFixedHours = shared.DateHelp.DateHelpful.DateRangeFixedHours(dateRange);
var res = await this._invoiceService.InvoiceSellGetAllToList(dateRangeFixedHours);
return(Ok(res));
}
public async Task <GenericResponseDTO <List <TimeEntry> > > GetInDateRange(DateRangeDTO data)
{
var currentUserId = authHelper.GetCurrentUserId(User);
// Set times to beginning and end of days
data.StartDate = new DateTime(data.StartDate.Year, data.StartDate.Month, data.StartDate.Day, 0, 0, 0);
data.EndDate = new DateTime(data.EndDate.Year, data.EndDate.Month, data.EndDate.Day, 23, 59, 59);
var entries = await database.TimeEntries
.AsNoTracking()
.Where(x => x.User.Id == currentUserId && x.Day >= data.StartDate && x.Day <= data.EndDate)
.ToListAsync();
return(new GenericResponseDTO <List <TimeEntry> >()
{
Data = entries,
Success = true
});
}
// POST: api/DateRages
public IHttpActionResult Post([FromBody] DateRangeDTO value)
{
IHttpActionResult response;
LogDTO log = new LogDTO()
{
Date = DateTime.Now,
Request = Request.RequestUri.PathAndQuery,
RequestMethod = "POST"
};
try
{
if (value.Id == 0)
{
var data = dateRangeDTOService.Add(value);
response = Created("database", value);
log.ResponseDataCount = 1;
log.ResponseStatus = (int)HttpStatusCode.Created;
}
else
{
dateRangeDTOService.Update(value);
response = Ok(value);
log.ResponseStatus = (int)HttpStatusCode.OK;
}
dateRangeDTOService.Save();
}
catch (Exception ex)
{
response = BadRequest(ex.Message);
log.ResponseStatus = (int)HttpStatusCode.BadRequest;
}
logDTOService.Add(log);
logDTOService.Save();
return(response);
}
public async Task <ValidatorDTO> LeaveValidator(string username, LeaveRequest leaveRequest)
{
// Checking if the leave apply date is an opted in flexible holiday.
var dateRangeDTO = new DateRangeDTO(leaveRequest.StartDate, leaveRequest.EndDate);
var optedInHolidays = await flexibleHolidayService.GetOptedInHolidays(username, dateRangeDTO);
if (optedInHolidays.Any())
{
return(new ValidatorDTO
{
IsValid = false,
Message = $"You have opted in for a flexible holiday on {optedInHolidays.First().Date.ToString("dd/MM/yyyy")}"
});
}
// No day in between the LeaveDateRange can be a Public Holiday
var publicHoliday = await PublicHolidayValidator(leaveRequest);
return(publicHoliday);
}
public async Task <ApiResponse <float> > GetAverageOfWaitingTime(DateRangeDTO dateRange)
{
ApiResponse <float> result = new ApiResponse <float>();
try
{
//complete order object
var CO = await unitOfWork.CompleteOrdersManager.GetAsync(A => A.OrderDateTime.Value.Date <= dateRange.EndDate.Date && A.OrderDateTime.Value.Date >= dateRange.StartDate.Date);
if (CO != null)
{
var COList = CO.ToList();
float total = 0;
for (int i = 0; i < CO.Count(); i++)
{
total += (float)COList[i].CustomerWaitingTimeInMinutes;
}
total = total / COList.Count();
result.Data = total;
result.Succeeded = true;
return(result);
}
else
{
result.Succeeded = false;
result.Errors.Add("Could not find any complete orders");
return(result);
}
}
catch (Exception ex)
{
result.Succeeded = false;
result.Errors.Add(ex.Message);
return(result);
}
}
public async Task <IActionResult> GetJpk(DateTime dateStart, DateTime dateEnd, int celZlozenia)
{
var dateRange = new DateRangeDTO
{
DateEnd = dateEnd,
DateStart = dateStart
};
var res = await this._invoiceService.GetJpk(dateRange);
//ContentResult result = new ContentResult();
//result.ContentType = "application/xml";
//result.Content = res.ConvertToStringBuilder().ToString();
//result.StatusCode = 200;
//return result;
return(File(new System.Text.UTF8Encoding().GetBytes(res.ConvertToStringBuilder().ToString()), "text/csv", "export.csv"));
//return Ok(res);
}
public IHttpActionResult Get(DateTime from, DateTime to)
{
IHttpActionResult response;
DateRangeDTO value = new DateRangeDTO {
From = from, To = to
};
LogDTO log = new LogDTO()
{
Date = DateTime.Now,
Request = Request.RequestUri.PathAndQuery,
RequestMethod = "GET"
};
try
{
var ranges = dateRangeDTOService
.GetAll()
.Where(range => value.From <= range.To && value.To >= range.To);
log.ResponseStatus = (int)HttpStatusCode.OK;
log.ResponseDataCount = ranges.Count();
response = Ok(ranges);
}
catch (Exception ex)
{
log.ResponseStatus = (int)HttpStatusCode.BadRequest;
response = BadRequest(ex.Message);
}
logDTOService.Add(log);
logDTOService.Save();
return(response);
}
public async Task <IActionResult> GetNumberOfSignedInBarbers(DateRangeDTO dateRange)
{
return(await GetResponseHandler(async() => await service.GetNumberOfSignedInBarbers(dateRange)));
}
public FlexibleHolidayDialog(DateRangeDTO dateRange, HolidayService holidayService)
{
this._dateRange = dateRange;
_holidayService = holidayService;
}
public async Task <IActionResult> GetAverageOfWaitingTime(DateRangeDTO dateRange)
{
return(await GetResponseHandler(async() => await service.GetAverageOfWaitingTime(dateRange)));
}
public async Task <IActionResult> Index(DateRangeDTO dateRangeDto)
{
DateRange dateRange = new DateRange(dateRangeDto.From, dateRangeDto.To);
PushSubscription pushSubscription = new PushSubscription()
{
Endpoint = Request.Form["PushEndpoint"], P256DH = Request.Form["PushP256DH"], Auth = Request.Form["PushAuth"]
};
PushPayload pushPayload = new PushPayload();
var reports = await _drugService.GetDrugConsuption(dateRange);
if (reports == null)
{
pushPayload.Title = "Unsuccess";
pushPayload.Message = "Comunication error!";
_pushNotificationService.SendNotification(pushSubscription, pushPayload);
return(RedirectToAction("Index"));
}
if (reports.Count == 0)
{
pushPayload.Title = "Unsuccess";
pushPayload.Message = "Nothing found in given data range!";
_pushNotificationService.SendNotification(pushSubscription, pushPayload);
return(RedirectToAction("Index"));
}
var json = JsonConvert.SerializeObject(reports, Formatting.Indented);
var reportFileName = $"{dateRange.From:yyyy-MM-dd}-to-{dateRange.To:yyyy-MM-dd}-report.json";
var reportFilePath = "Resources";
try
{
System.IO.File.WriteAllText(Path.Combine(reportFilePath, reportFileName), json);
}
catch (Exception dnfe)
{
Console.WriteLine(dnfe);
pushPayload.Title = "Unsuccess";
pushPayload.Message = "Error occured while creating report file!";
_pushNotificationService.SendNotification(pushSubscription, pushPayload);
return(RedirectToAction("Index"));
}
var pharmacySystems = await _pharmacySystemService.GetAll();
foreach (var ps in pharmacySystems)
{
if (_adapterContext.SetPharmacySystemAdapter(ps) == null)
{
continue;
}
if (_adapterContext.PharmacySystemAdapter.SendDrugConsumptionReport(reportFilePath, reportFileName))
{
pushPayload.Title = "Success";
pushPayload.Message = "Report successfully created and uploaded to " + ps.Name + "!";
}
else
{
pushPayload.Title = "Unsuccess";
pushPayload.Message = "Report upload to " + ps.Name + " unsuccessfull!";
}
_pushNotificationService.SendNotification(pushSubscription, pushPayload);
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> GetTotalNumberCustomer(DateRangeDTO dateRange)
{
return(await GetResponseHandler(async() => await service.GetTotalNumberCustomer(dateRange)));
}
