protected async Task <bool> HolidaysAlreadyExist(string countryIsoCode, int year)
{
DateTime startDate = new DateTime(year, 01, 01);
DateTime endDate = new DateTime(year, 12, 31);
return((await HolidayRepository.GetCountAsync(h => h.CountryCode == countryIsoCode && h.HolidayDate >= startDate && h.HolidayDate <= endDate)) > 0);
}
public RendezVousController()
{
SlotRepository = new TimeSlotRepository();
ContactRepository = new Repository<Contact>();
DateRepository = new DateRepository();
HolidayRepository = new HolidayRepository();
}
public IEnumerable <Holiday> GetHolidays()
{
using (var holidayRepo = new HolidayRepository())
{
return(holidayRepo.GetAll());
}
}
private async Task<bool> MustBeValidateAsync(string countryIsoCode, int year)
{
DateTime startDate = new DateTime(year, 01, 01);
DateTime endDate = new DateTime(year, 12, 31);
return (await HolidayRepository.GetCountAsync(h => h.CountryCode == countryIsoCode && h.HolidayDate >= startDate && h.HolidayDate <= endDate)) > 0;
}
public async Task<CommandResult> AddAsync(Holiday holiday)
{
CommandResult commandResult;
Stopwatch watch = Stopwatch.StartNew();
try
{
if (!await CanAddAsync(holiday, true))
{
commandResult = CommandResult.BadRequest("Registro não pode ser salvo, existem erros.");
}
else
{
holiday = await HolidayRepository.AddAsync(holiday);
commandResult = await CommitAsync(_commandName, holiday.Action);
if (commandResult.Success)
{
commandResult.Data = holiday;
}
}
}
catch (Exception ex)
{
commandResult = CommandResult.InternalServerError($"Ocorreu um erro ao salvar.");
}
watch.Stop();
commandResult.ElapsedTime = watch.ElapsedMilliseconds;
return commandResult;
}
public AgendaController()
{
DateRepository = new DateRepository();
HolidayRepository = new HolidayRepository();
TimeSlotRepository = new TimeSlotRepository();
ContactRepository = new ContactRepository();
}
public IHttpActionResult DeleteHoliday(HolidayModel holiday)
{
long result;
result = HolidayRepository.DeleteHoliday(holiday.HolidayDate);
return(Ok(result));
}
private async Task <IEnumerable <Holiday> > GetHolidaysByMonthAsync(string countryIsoCode, int year, int month)
{
if (!await HolidaysAlreadyExist(countryIsoCode, year))
{
await CreateHoliday(countryIsoCode, year);
}
return(await HolidayRepository.GetHolidaysByMonthAsync(countryIsoCode, year, month));
}
private async Task <IEnumerable <Holiday> > GetHolidaysByDateAsync(string countryIsoCode, DateTime holidayDate)
{
if (!await HolidaysAlreadyExist(countryIsoCode, holidayDate.Year))
{
await CreateHoliday(countryIsoCode, holidayDate.Year);
}
return(await HolidayRepository.GetHolidaysByDateAsync(countryIsoCode, holidayDate));
}
public JsonResult Holiday(int?draw, int?start, int?length, List <Dictionary <string, string> > order, List <Dictionary <string, string> > columns)
{
var search = Request["search[value]"];
var dir = order[0]["dir"].ToLower();
var column = columns[int.Parse(order[0]["column"])]["data"];
var dataTableData = new HolidayRepository().GetPage(search, draw, start, length, dir, column);
return(Json(dataTableData, JsonRequestBehavior.AllowGet));
}
public IHttpActionResult UpdateHoliday(HolidayModel holidayModel)
{
long result;
JavaScriptSerializer serializer = new JavaScriptSerializer();
HolidayModel holiday = serializer.Deserialize <HolidayModel>(holidayModel.jsonData);
result = HolidayRepository.UpdateHoliday(holiday);
return(Ok(result));
}
public ActionResult HolidayDetail(int?id)
{
HolidayViewModel model = new HolidayViewModel();
if (id.HasValue)
{
model = new HolidayRepository().GetByID((int)id);
}
return(PartialView("_Holiday", model));
}
/// <summary>
/// Initializes a new instance of the HolidayService class.
/// </summary>
/// <param name="unitOfWork">UnitOfWork information</param>
public HolidayService(UnitOfWork unitOfWork)
{
if (unitOfWork == null)
{
throw new ArgumentNullException(UnitOfWorkConst);
}
this.unitOfWork = unitOfWork;
this.holidayRepository = new HolidayRepository(this.unitOfWork);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Set up MVC controllers
services.AddMvc();
services.AddControllers();
// Since we don't have a DB to connect to, hydrate model repositories here instead
ProductRepository.hydrate();
ManufacturerRepository.hydrate();
HolidayRepository.hydrate();
}
public IHttpActionResult GetHoliday()
{
try
{
DataSet ds = HolidayRepository.GetHoliday();
return(Ok(ds.Tables[0]));
}
catch
{
return(null);
}
}
public async Task LoadHolidays_ReturnsNothing_WithMissingData()
{
// arrange
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>());
var sut = new HolidayRepository(fileSystem, NullLogger <HolidayRepository> .Instance);
// act
var result = (await sut.LoadHolidays()).ToList();
// assert
Assert.Empty(result);
}
public DateTime GetNonHolidayDateFrom(DateTime startDate)
{
var repo = new HolidayRepository();
for (DateTime i = startDate; ; i = i.AddDays(1))
{
if (repo.IsHoliday(i))
{
continue;
}
return(i);
}
}
// GET: Project
public async Task <ActionResult> Index(string id, int year, int month)
{
var projectRepository = new ProjectRepository();
var memberIds = await projectRepository.FindMembersInProject(id);
var scheduleRepository = new ScheduleRepository();
var leaves = await scheduleRepository.FindLeavesByMonthForProjectMembers(memberIds, year, month);
var leaveCount = new Dictionary <DateTime, ProjectLeaveCountModel>();
leaves.ForEach(l =>
{
if (!leaveCount.ContainsKey(l.Date.Value))
{
leaveCount[l.Date.Value] = new ProjectLeaveCountModel
{
Date = l.Date.Value
};
}
leaveCount[l.Date.Value].Count++;
});
var userRepository = new UserRepository();
var countryCodes = await userRepository.FindDistinctCountryCodeForMembers(memberIds);
var holidayRepository = new HolidayRepository();
var holidays = await holidayRepository.FindHolidaysForCountries(year, countryCodes);
holidays.ForEach(h =>
{
h.Date = DateTime.SpecifyKind(h.Date, DateTimeKind.Utc);
if (h.Date.Month == month)
{
if (!leaveCount.ContainsKey(h.Date))
{
leaveCount[h.Date] = new ProjectLeaveCountModel
{
Date = h.Date
};
}
leaveCount[h.Date].Count++;
}
});
return(JsonNet(leaveCount.Values));
}
public JsonResult SaveHoliday(HolidayViewModel model)
{
ResponseData result = new Models.ResponseData();
if (model.HolID != 0)
{
result = new HolidayRepository().UpdateByEntity(model);
}
else
{
result = new HolidayRepository().AddByEntity(model);
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
public async Task LoadHolidays_ReturnsNothing_WithBrokenData()
{
// arrange
var rawJson = ResourceHelpers.ReadEmbeddedResource("BusinessDaysBetween.Business.Tests.TestResources.holidays_broken.json");
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ "holidays.json", new MockFileData(rawJson) },
});
var sut = new HolidayRepository(fileSystem, NullLogger <HolidayRepository> .Instance);
// act
var result = (await sut.LoadHolidays()).ToList();
// assert
Assert.Empty(result);
}
public CheckResult SaveHolidays(List <HolidayModel> model)
{
try
{
using (var db = DB.GetContext())
{
KeyBinder key = new KeyBinder();
HolidayRepository.SaveHolidays(db, key, model);
db.SaveChanges();
key.BindKeys();
model.ForEach(f => f.IsChanged = false);
return(new CheckResult());
}
}
catch (Exception ex)
{
return(new CheckResult(ex));
}
}
public async Task LoadHolidays_ReturnsOnlyValidHolidays_WithInvalidData()
{
// arrange
var rawJson = ResourceHelpers.ReadEmbeddedResource("BusinessDaysBetween.Business.Tests.TestResources.holidays_invalid.json");
var fileSystem = new MockFileSystem(new Dictionary <string, MockFileData>
{
{ "holidays.json", new MockFileData(rawJson) },
});
var sut = new HolidayRepository(fileSystem, NullLogger <HolidayRepository> .Instance);
// act
var result = (await sut.LoadHolidays()).ToList();
// assert
Assert.Equal(2, result.Count);
Assert.Collection(result,
h => Assert.Equal(HolidayType.Fixed, h.Type),
h => Assert.Equal(HolidayType.RollsToMonday, h.Type));
}
public void GetByMonth_TwoItemsInEachMonth_ReturnsTwoItemsFromRequestedMonth()
{
// Arrange
var repo = new HolidayRepository(Session);
repo.SaveOrUpdate(new Holiday(new DateTime(2013, 1, 1), "Holiday jan"));
repo.SaveOrUpdate(new Holiday(new DateTime(2013, 1, 2), "Holiday jan 2"));
repo.SaveOrUpdate(new Holiday(new DateTime(2013, 2, 1), "Holiday feb"));
repo.SaveOrUpdate(new Holiday(new DateTime(2013, 2, 2), "Holiday feb 2"));
repo.SaveOrUpdate(new Holiday(new DateTime(2013, 3, 1), "Holiday march"));
repo.SaveOrUpdate(new Holiday(new DateTime(2013, 3, 2), "Holiday march 2"));
// Act
var result = repo.GetByMonth(2, 2013).ToList();
// Assert
Assert.That(result.Count, Is.EqualTo(2));
AssertHoliday(result[0], new DateTime(2013, 2, 1), "Holiday feb");
AssertHoliday(result[1], new DateTime(2013, 2, 2), "Holiday feb 2");
}
public IHttpActionResult EditHoliday(HolidayModel holidayModel)
{
try
{
DataSet ds = HolidayRepository.GetHoliday();
var result = ds.Tables[0];
var query = result.AsEnumerable().Select(m => new
{
HolidayDate = m.Field <DateTime>("HolidayDate"),
Name = m.Field <string>("Name"),
Remark = m.Field <string>("Remarks")
});
var singleResult = query.Where(m => m.HolidayDate == holidayModel.HolidayDate);
return(Ok(singleResult));
}
catch
{
return(null);
}
}
public async Task<CommandResult> AddRangeAsync(List<Holiday> listOfHolidays, bool validateRepository = true)
{
CommandResult commandResult;
Stopwatch watch = Stopwatch.StartNew();
try
{
int recordsToSave = Count(listOfHolidays);
if (recordsToSave == 0)
{
commandResult = CommandResult.BadRequest("Nenhum registro salvo, a lista está vazia.");
}
else
{
if (!await CanAddAsync(listOfHolidays, validateRepository))
{
commandResult = CommandResult.BadRequest("Nenhum registro salvo, existem erros.");
}
else
{
await HolidayRepository.AddRangeAsync(listOfHolidays);
commandResult = await CommitAsync(_commandName, ActionType.Register);
if (commandResult.Success)
{
commandResult.Message = $"Ação concluída com sucesso. Salvos { recordsToSave } registros de um total de { recordsToSave }";
commandResult.Data = listOfHolidays;
}
}
}
}
catch (Exception ex)
{
commandResult = CommandResult.InternalServerError($"Ocorreu um erro ao salvar.");
}
watch.Stop();
commandResult.ElapsedTime = watch.ElapsedMilliseconds;
return commandResult;
}
/**
* Determine whether a provided day is a no-shipping holiday
*/
public bool validShippingDate(DateTime shippingDate)
{
if (!shipOnWeekends && (shippingDate.DayOfWeek == DayOfWeek.Saturday ||
shippingDate.DayOfWeek == DayOfWeek.Sunday))
{
return(false);
}
if (HolidayRepository.all()
.Any(holiday => holiday.month == shippingDate.Month && holiday.day == shippingDate.Day))
{
return(false);
}
if (manufacturer.holidays.Any(holiday =>
holiday.month == shippingDate.Month && holiday.day == shippingDate.Day))
{
return(false);
}
return(true);
}
// POST api/Task
public HttpResponseMessage PostTask(EventViewModel task)
{
//var httpContext = (HttpContextWrapper)Request.Properties["MS_HttpContext"];
//var models = httpContext.Request.Form["models"];
//var task = JsonConvert.DeserializeObject<EventViewModel>(models);
if (ModelState.IsValid)
{
var eventTaskList = db.EventTaskLists.Include("Property").Include("Crew").FirstOrDefault(e => e.Id == task.OwnerID);
if (eventTaskList != null)
{
task.Title = eventTaskList.Property.Name + ", " + eventTaskList.Crew.Name;
}
List <DateTime> holidays;
using (var holidayRepo = new HolidayRepository())
{
holidays = holidayRepo.GetHolidays().Select(h => h.HolidayDate.Date).ToList();
}
if (holidays.Contains(task.StartDate.Date))
{
var message = "Your schedule includes a holiday on: " + task.StartDate.Date;
HttpError err = new HttpError(message);
return(Request.CreateResponse(HttpStatusCode.Conflict, err));
}
if (!string.IsNullOrEmpty(task.RecurrenceRule))
{
var pattern = new RecurrencePattern(task.RecurrenceRule);
var evaluator = new RecurrencePatternEvaluator(pattern);
var items = evaluator.Evaluate(new CalDateTime(task.StartDate), task.Start,
task.StartDate.AddDays(1), false);
var allItems = evaluator.Evaluate(new CalDateTime(task.StartDate), task.Start,
task.End.AddYears(5), true); //Adding 5 years since the end date is equal to the start date. The recurrence rule handles our occurences
var holiday = allItems.FirstOrDefault(i => holidays.Contains(i.StartTime.Date));
if (holiday != null)
{
var message = "Your schedule includes a holiday on: " + holiday.StartTime.Date;
HttpError err = new HttpError(message);
return(Request.CreateResponse(HttpStatusCode.Conflict, err));
}
if (!items.Any())
{
var startEntity = new EventSchedule
{
Id = task.TaskID,
Title = task.Title,
StartTime = task.Start,
StartTimezone = task.StartTimezone,
EndTime = task.End,
EndTimezone = task.EndTimezone,
Description = task.Description,
RecurrenceRule = string.Empty,
RecurrenceException = string.Empty,
RecurrenceID = null,
IsAllDay = task.IsAllDay,
EventTaskListId = task.OwnerID ?? 0
};
db.EventSchedules.Add(startEntity);
}
}
var entity = new EventSchedule
{
Id = task.TaskID,
Title = task.Title,
StartTime = task.Start,
StartTimezone = task.StartTimezone,
EndTime = task.End,
EndTimezone = task.EndTimezone,
Description = task.Description,
RecurrenceRule = task.RecurrenceRule,
RecurrenceException = task.RecurrenceException,
RecurrenceID = task.RecurrenceID,
IsAllDay = task.IsAllDay,
EventTaskListId = task.OwnerID ?? 0
};
db.EventSchedules.Add(entity);
db.SaveChanges();
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, new[] { task });
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = task.TaskID }));
return(response);
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
}
public LoginController()
{
ContactRepository = new ContactRepository();
HolidayRepository = new HolidayRepository();
}
public async Task <ActionResult> LeaveDetails(string id, int year, int month, int day)
{
var projectRepository = new ProjectRepository();
var memberIds = await projectRepository.FindMembersInProject(id);
var scheduleRepository = new ScheduleRepository();
var leaves = await scheduleRepository.FindLeavesByMonthForProjectMembers(memberIds, year, month);
var leaveTypeRepository = new LeaveTypeRepository();
var leaveTypes = await leaveTypeRepository.FindAll();
var model = new LeaveDetailsModel();
model.Date = new DateTime(year, month, day);
model.Leaves = leaves.Where(l => l.Date.Value.Day == day)
.Select(l => new LeaveModel
{
CreatedById = l.CreatedById,
Date = l.Date.Value.ToString("dd MMMM yyyy"),
Hours = l.Hours,
Id = l.Id,
IsApproved = l.IsApproved,
IsHalfDay = l.IsHalfDay,
IsOnMorning = l.IsOnMorning,
LeaveType = l.LeaveType,
Reason = l.Reason,
Type = LookUpLeaveName(l.LeaveType, leaveTypes)
})
.ToList();
var userRepository = new UserRepository();
var users = await userRepository.FindByIds(memberIds);
var userLookUp = users.ToDictionary(u => u.Id);
model.Leaves.ForEach(l => {
if (userLookUp.ContainsKey(l.CreatedById))
{
var user = userLookUp[l.CreatedById];
l.CreatedByName = user.Profile.Name;
l.CreatedByProfileImage = user.GoogleProfile.ProfileImageUrl;
}
});
var countryCodes = await userRepository.FindDistinctCountryCodeForMembers(memberIds);
var holidayRepository = new HolidayRepository();
var holidays = await holidayRepository.FindHolidaysForCountries(year, countryCodes);
model.Holidays = holidays.Where(h => h.Date.Month == month && h.Date.Day == day)
.Select(h => new HolidayModel
{
Country = h.Country,
Name = h.Name,
Date = h.Date.ToString("dd MMMM yyyy")
}).ToList();
var usersByCountry = users.GroupBy(u => u.Profile.CountryCode);
foreach (var byCountry in usersByCountry)
{
if (byCountry.Count() > 1)
{
var holiday = model.Holidays.FirstOrDefault(h => h.Country == byCountry.Key);
if (holiday != null)
{
model.Holidays.AddRange(Enumerable.Repeat(holiday, byCountry.Count() - 1));
}
}
}
return(JsonNet(model));
}
public HolidayController()
{
_holidayRepo = new HolidayRepository();
}
private static void GetDataTimeSheetFromListDate(List <DateTime> lstDate)
{
TMSDbContext DbContext = new TMSDbContext();
IDbFactory dbFactory = new DbFactory();
IAppUserRepository appUserRepository = new AppUserRepository(dbFactory);
IChildcareLeaveRepository childcareLeaveRepository = new ChildcareLeaveRepository(dbFactory);
IFingerTimeSheetRepository fingerTimeSheetRepository = new FingerTimeSheetRepository(dbFactory);
ITimeDayRepository timeDayRepository = new TimeDayRepository(dbFactory);
IFingerTimeSheetTmpRepository tmpTimeSheetRepository = new FingerTimeSheetTmpRepository(dbFactory);
IOTRequestRepository OTRequestRepository = new OTRequestRepository(dbFactory);
IFingerMachineUserRepository fingerMachineUserRepository = new FingerMachineUserRepository(dbFactory);
IOTRequestUserRepository otrequestUserRepository = new OTRequestUserRepository(dbFactory);
IReportRepository reportRepository = new ReportRepository(dbFactory);
UnitOfWork unitOfWork = new UnitOfWork(dbFactory);
IRequestRepository requestRepository = new RequestRepository(dbFactory);
IExplanationRequestRepository explanationRepository = new ExplanationRequestRepository(dbFactory);
IAbnormalCaseRepository abnormalRepository = new AbnormalCaseRepository(dbFactory);
IEntitleDayAppUserRepository entitledayRepository = new EntitleDayAppUserRepository(dbFactory);
IUserOnsiteRepository userOnsiteRepository = new UserOnsiteRepository(dbFactory);
ISystemService systemService = new SystemService();
ISystemConfigRepository systemConfigRepository = new SystemConfigRepository(dbFactory);
IHolidayRepository holidayRepository = new HolidayRepository(dbFactory);
ICommonService commonService = new CommonService(systemConfigRepository, timeDayRepository, holidayRepository, unitOfWork);
FingerTimeSheetService fingerTimeSheetService = new FingerTimeSheetService(fingerTimeSheetRepository, tmpTimeSheetRepository, timeDayRepository, OTRequestRepository,
fingerMachineUserRepository, otrequestUserRepository,
appUserRepository, childcareLeaveRepository, reportRepository, unitOfWork,
requestRepository, explanationRepository, abnormalRepository, entitledayRepository, userOnsiteRepository, systemService, commonService);
var listDateImportTimeSheet = new List <DateTime>();
try
{
foreach (var datetime in lstDate)
{
var date = datetime.Date;
if (DbContext.FingerTimeSheets.Where(x => x.DayOfCheck == date).FirstOrDefault() == null)
{
listDateImportTimeSheet.Add(datetime);
}
}
foreach (var datetime in listDateImportTimeSheet)
{
var date = datetime.Date;
var date1 = datetime.AddDays(1).Date;
var listTimeSheet = DbContext.CHECKINOUT.Where(x => x.CHECKTIME >= date && x.CHECKTIME < date1).ToList();
if (listTimeSheet.Count > 0)
{
tmpTimeSheetRepository.RemoveAllData();
List <FingerTimeSheetTmp> listTmp = new List <FingerTimeSheetTmp>();
foreach (var item in listTimeSheet)
{
FingerTimeSheetTmp tmp = new FingerTimeSheetTmp();
var user = DbContext.USERINFO.FirstOrDefault(x => x.USERID == item.USERID);
if (user == null)
{
continue;
}
tmp.UserNo = user.Badgenumber;
tmp.Date = item.CHECKTIME;
tmp.AccName = DbContext.USERINFO.Where(x => x.USERID == item.USERID).Select(x => x.Name).FirstOrDefault();
tmpTimeSheetRepository.Add(tmp);
listTmp.Add(tmp);
}
unitOfWork.Commit();
int count = 0;
List <FingerTimeSheetTmpErrorModel> listModel = new List <FingerTimeSheetTmpErrorModel>();
var result = fingerTimeSheetService.ImportTimeSheet(out count, DbContext, out listModel);
}
}
}
catch (Exception e)
{
log.Error("ExData:" + e.Data);
log.Error("ExMess:" + e.Message);
}
}
public JsonResult DeleteHoliday(int id)
{
var result = new HolidayRepository().RemoveByID(id);
return(Json(result, JsonRequestBehavior.AllowGet));
}
public List <HolidayModel> GetHolidays()
{
return(HolidayRepository.GetHolidays(this.DbContext));
}
private HolidayManager(DSModel db)
: base(db)
{
this.ActiveModel = HolidayRepository.GetHolidays(db);
}
