public async Task <ActionResult <HolidayModel> > Post(int employeeId, HolidayModel model)
{
try
{
//Make sure HolidayId is not already taken
var existing = await _repository.GetHolidayAsync(employeeId, model.Id);
if (existing != null)
{
return(BadRequest("Holiday Id in Use"));
}
//map
var Holiday = _mapper.Map <Holiday>(model);
//save and return
if (!await _repository.StoreNewHolidayAsync(employeeId, Holiday))
{
return(BadRequest("Bad request, could not create record!"));
}
else
{
var location = _linkGenerator.GetPathByAction("Get",
"Holiday",
new { employeeId = Holiday.EmployeeId, Holiday.Id });
return(Created(location, _mapper.Map <HolidayModel>(Holiday)));
}
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
}
public async Task <HttpResponseMessage> updateHolidayMapping(HolidayModel HolidayModel)
{
_database = MongoDBHandler.mDatabase();
IMongoCollection <HolidayModel> collectionHolidayModelMapping = _database.GetCollection <HolidayModel>("HolidayMapping");
if (HolidayModel != null)
{
FilterDefinition <HolidayModel> filter;
filter = Builders <HolidayModel> .Filter.Empty;
var nakshatraHolidayId = HolidayModel.NakshatraHolidayId.ToString().ToUpper();
filter = filter & Builders <HolidayModel> .Filter.Eq(x => x.NakshatraHolidayId, nakshatraHolidayId);
var searchResult = await collectionHolidayModelMapping.Find(filter).FirstOrDefaultAsync();
// Update this record.
if (searchResult != null)
{
searchResult = HolidayModel;
var filter1 = Builders <HolidayModel> .Filter.Eq(c => c.NakshatraHolidayId, HolidayModel.NakshatraHolidayId);
collectionHolidayModelMapping.ReplaceOne(filter, HolidayModel, new UpdateOptions {
IsUpsert = true
});
}
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, searchResult);
return(response);
}
return(null);
}
private void btnSave_Click(object sender, EventArgs e)
{
Cursor = Cursors.WaitCursor;
try
{
if (validate())
{
HolidaysBAL _objBAL = new HolidaysBAL();
HolidayModel _objModel = new HolidayModel();
_objModel._HolidayID = selectedRecordId;
_objModel._HolidayDate = Convert.ToDateTime(dtpHolidayDate.Text);
_objModel._Description = tbxDescription.Text;
_objModel._ModifiedDate = DateTime.Now;
if (selectedRecordId == 0)
{
_objBAL.SaveHoliday(_objModel);
}
else
{
_objBAL.UpdateHoliday(_objModel);
}
MakeEmpty();
MessageBox.Show("Record Saved Successfully!");
FillGrid();
}
}
catch
{ }
finally
{
Cursor = Cursors.Default;
}
}
public ActionResult HolidayForm()
{
ViewData["LoginUserInfo"] = LoginUserInfo;
string ProgramID = "Z001";
ProgramModel SysProgram = null;
if (!GeneralObj.CheckProgID(LoginUserInfo.ProgramList, ProgramID))
{
return(View("../SysMsg/NoAccess"));
}
else
{
SysProgram = GeneralObj.GetProgram(LoginUserInfo.ProgramList, ProgramID);
ViewData["SysProgram"] = SysProgram;
}
UserFreeStyleModel UserFreeStyle;
UserFreeStyle = JsonConvert.DeserializeObject <UserFreeStyleModel>(Session[UserFreeStyle_id].ToString());
HolidayModel Holiday = ModelFactory.GetHolidayData(UserFreeStyle.SignId);
ViewData["Holiday"] = Holiday;
return(View());
}
public ActionResult Edit(int id)
{
if (!_permissionService.Authorize("ManageHoliday"))
{
return(AccessDeniedView());
}
if (id == 0)
{
throw new ArgumentNullException("id");
}
var model = new HolidayModel();
var objHoliday = _smsService.GetHolidayById(id);
if (objHoliday != null)
{
model = objHoliday.ToModel();
}
model.AvailableAcadmicYears = _smsService.GetAllAcadmicYears().Select(x => new SelectListItem()
{
Text = x.Name.Trim(),
Value = x.Id.ToString(),
Selected = model.AcadmicYearId == x.Id
}).ToList();
return(View(model));
}
public void GetGridViewList(string Where, string Orderby, int PageNum, int Limit, ref List <HolidayModel> DataList, ref int TotalRecord)
{
int offset = PageNum * Limit;
//主要SQL
string SqlMain = "SELECT ROW_NUMBER() OVER (ORDER BY " + Orderby + ") AS RowNum,* FROM gvHoliday WHERE 1 = 1 " + Where;
string Sql = "SELECT TOP " + Limit + " * FROM ( ";
Sql += SqlMain;
Sql += " ) TEMP WHERE RowNum > " + offset;
DataTable dt = DbAccess.ExecuteDataTable(Sql);
for (int i = 0; i < dt.Rows.Count; i++)
{
HolidayModel M = new HolidayModel();
M.Company = dt.Rows[i]["Company"].ToString();
M.CompanyName = dt.Rows[i]["CompanyName"].ToString();
M.YearId = dt.Rows[i]["YearId"].ToString();
M.EditPK = dt.Rows[i]["PK"].ToString();
DataList.Add(M);
}
//取得總數量
Sql = "SELECT COUNT(*) AS TOTAL FROM (" + SqlMain + ") TEMP";
dt = DbAccess.ExecuteDataTable(Sql);
TotalRecord = Convert.ToInt32(dt.Rows[0]["TOTAL"].ToString());
}
public async Task <IHttpActionResult> UpdateHoliday(int clientId, [FromBody] HolidayModel model)
{
var userId = GetUserId();
var holiday = await _holidayManager.UpdateAsync(model, clientId, userId);
return(Ok(holiday));
}
public async Task <ActionResult <HolidayModel> > Put(int employeeId, int Id, HolidayModel updatedModel)
{
try
{
var currentHoliday = await _repository.GetHolidayAsync(employeeId, Id);
if (currentHoliday == null)
{
return(NotFound($"Could not find Holiday with Id of {Id}"));
}
_mapper.Map(updatedModel, currentHoliday);
if (await _repository.UpdateHolidayAsync(employeeId, currentHoliday))
{
return(_mapper.Map <HolidayModel>(currentHoliday));
}
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
return(BadRequest());
}
public async Task <HolidayModel> UpdateAsync(HolidayModel model, int clientId, int userId)
{
if (model == null)
{
throw new ArgumentNullException();
}
if (!await _permissionManager.HasPermission(clientId, userId, Permission.CanEditHoliday))
{
throw new Exception("User has not permission to perform this operation");
}
var result = await _holidayRepository.IsHolidayExistsAsync(clientId, model.Id, model.StartDate, model.EndDate);
if (result)
{
throw new Exception("Already inserted holiday");
}
var holiday = _holidayMapper.ConvertToDataModel(model);
holiday = await _holidayRepository.UpdateAsync(holiday);
return(_holidayMapper.ConvertToModel(holiday));
}
public IHttpActionResult DeleteHoliday(HolidayModel holiday)
{
long result;
result = HolidayRepository.DeleteHoliday(holiday.HolidayDate);
return(Ok(result));
}
public HolidayViewModel(IMainRepository repository)
{
_model = new HolidayModel(repository);
_messanger = new Messanger();
_monthsNames = InitializeMonthsCollection();
_days = InitializeDaysCollection();
IntializeSelectedData();
}
/// <summary>
/// Maps the specified original.
/// </summary>
/// <param name="original">The original.</param>
/// <returns></returns>
public static HolidayModel Map(this Holiday original)
{
var mappedOutcome = new HolidayModel
{
Description = original.Description
};
return(mappedOutcome);
}
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 Edit(Guid id)
{
HolidayModel holiday = new HolidayModel(id);
if (holiday == null)
{
return(HttpNotFound());
}
return(View(holiday));
}
public ActionResult List()
{
if (!_permissionService.Authorize("ManageHoliday"))
{
return(AccessDeniedView());
}
var model = new HolidayModel();
return(View(model));
}
public ActionResult Edit([Bind(Include = "CalendarID,Title,Description,StartDate,NoOfDays")] HolidayModel holiday, string existing)
{
Session["err"] = "Error, Please Check Input Fields";
Session["msg"] = "";
if (ModelState.IsValid)
{
string compareexist = holiday.StartDate.Year + "-" + holiday.StartDate.Month + "-" + holiday.StartDate.Day;
if (compareexist + holiday.Title != existing)
{
Calendar holidayexisting = db.Calendars.Where(c => c.Date == holiday.StartDate && c.Title == holiday.Title).FirstOrDefault();
if (holidayexisting != null)
{
Session["err"] = "Holiday title already exists";
ViewBag.Existing = existing;
ViewBag.Message = Session["msg"];
ViewBag.Error = Session["err"];
Session["err"] = "";
Session["msg"] = "";
return(View(holiday));
}
}
int nofofdays = holiday.NoOfDays;
DateTime startdate = holiday.StartDate;
while (nofofdays != 0)
{
Calendar holidayupdate = db.Calendars.Where(c => c.Date == startdate && c.Title != "SUNDAY").FirstOrDefault();
if (holidayupdate != null)
{
holidayupdate.Title = holiday.Title;
holidayupdate.Description = holiday.Description;
holidayupdate.IsHoliday = true;
db.Entry(holidayupdate).State = EntityState.Modified;
db.SaveChanges();
}
nofofdays = nofofdays - 1;
startdate = startdate.AddDays(+1);
}
Session["err"] = "";
Session["msg"] = "Modified Successfully";
return(RedirectToAction("Index"));
}
ViewBag.Existing = existing;
ViewBag.Message = Session["msg"];
ViewBag.Error = Session["err"];
Session["err"] = "";
Session["msg"] = "";
return(View(holiday));
}
public void Update(HolidayModel model)
{
var upt = this._repoHoliday.Find(model.id);
upt.holidayDate = model.holidayDate.Date;
upt.description = model.description;
upt.holidayTypeId = model.HolidayType.value;
upt.updatedBy = this.GetCurrentUserId();
upt.updatedDate = DateTime.Now;
this._repoHoliday.Update(upt);
this._unitOfWork.Save();
}
public void Create(HolidayModel model, out Guid holidayId)
{
var currentUserId = this.GetCurrentUserId();
var ins = this._repoHoliday.PrepareEntity(model)
.SetValue(x => x.holidayDate, model.holidayDate.Date)
.SetValue(x => x.description, model.description)
.SetValue(x => x.holidayTypeId, model.HolidayType.value)
.SetValue(x => x.updatedBy, currentUserId)
.Insert()
.GetEntity();
this._unitOfWork.Save();
holidayId = ins.id;
}
public async Task <ActionResult <HolidayDto> > UpdateTeamAsync(int id, [FromBody] HolidayModel model)
{
var request = new UpdateHolidayCommand(companyId: _companyId,
holidayId: id,
userId: _userId,
model.Name,
model.StartDate,
model.EndDate,
model.Teams,
model.IsFullDay,
model.IsForAllTeams);
return(Single(await CommandAsync(request)));
}
private void FillForm(Int32 _HolidayId)
{
try
{
HolidaysBAL _objBAL = new HolidaysBAL();
HolidayModel _objModel = _objBAL.SearchHoliday(_HolidayId);
dtpHolidayDate.Text = _objModel._HolidayDate.ToString();
tbxDescription.Text = _objModel._Description;
tbxModifiedDate.Text = _objModel._ModifiedDate.ToString();
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
private static string FillAdaptiveCard <T>(T card, string pathToFiles)
{
if (typeof(T) == typeof(Holiday))
{
Holiday holiday = card as Holiday;
StringBuilder adaptiveCardJsonToModify = new StringBuilder(File.ReadAllText(pathToFiles));
foreach (var prop in card.GetType().GetProperties())
{
adaptiveCardJsonToModify.Replace("{" + prop.Name + "}", prop.GetValue(holiday).ToString());
}
adaptiveCardJsonToModify.Replace("{DayOfWeek}", holiday.Date.DayOfWeek.ToString()).Replace("{Date.Date}", holiday.Date.ToString("dd/MM/yyyy"));
return(adaptiveCardJsonToModify.ToString());
}
else if (typeof(T) == typeof(HolidayModel))
{
HolidayModel holiday = card as HolidayModel;
StringBuilder adaptiveCardJsonToModify = new StringBuilder(File.ReadAllText(pathToFiles));
foreach (var prop in card.GetType().GetProperties())
{
adaptiveCardJsonToModify.Replace("{" + prop.Name + "}", prop.GetValue(holiday).ToString());
}
adaptiveCardJsonToModify.Replace("{DayOfWeek}", holiday.Date.DayOfWeek.ToString()).Replace("{Date.Date}", holiday.Date.ToString("dd/MM/yyyy"));
return(adaptiveCardJsonToModify.ToString());
}
else
{
LeaveRequest leaveRequest = card as LeaveRequest;
StringBuilder adaptiveCardJsonToModify = new StringBuilder(File.ReadAllText(pathToFiles));
foreach (var prop in leaveRequest.GetType().GetProperties())
{
adaptiveCardJsonToModify.Replace("{" + prop.Name + "}", prop?.GetValue(leaveRequest)?.ToString());
}
adaptiveCardJsonToModify.Replace("{StartDate.DayOfWeek}", leaveRequest.StartDate.DayOfWeek.ToString()).Replace("{StartDate.Date}", leaveRequest.StartDate.ToString("dd/MM/yyyy"));
if (leaveRequest.EndDate != null)
{
adaptiveCardJsonToModify = adaptiveCardJsonToModify.Append("\n To \n");
adaptiveCardJsonToModify.Replace("{EndDate.DayOfWeek}", leaveRequest.EndDate?.DayOfWeek.ToString()).Replace("{EndDate.Date}", leaveRequest.EndDate?.ToString("dd/MM/yyyy"));
}
else
{
adaptiveCardJsonToModify.Replace("{EndDate.DayOfWeek}", "").Replace("{EndDate.Date}", "");
}
return(adaptiveCardJsonToModify.ToString());
}
}
public ActionResult Create(HolidayModel model)
{
ViewBag.LeaveDuration = LeaveServices.GetAllLeaveDuration();
if (ModelState.IsValid)
{
DateTime StartDate;
DateTime EndDate;
HolidayEntity ob = new HolidayEntity();
if (model.StartDate == null)
{
TempData[HRMWeb.Helpers.AlertStyles.Warning] = "Please Input Start Date";
return(View(model));
}
if (model.EndDate == null)
{
TempData[HRMWeb.Helpers.AlertStyles.Warning] = "Please Input End Date";
return(View(model));
}
StartDate = model.StartDate;
EndDate = model.EndDate;
if (StartDate > EndDate)
{
TempData[HRMWeb.Helpers.AlertStyles.Warning] = "Start Date can not exceed End Date";
return(View(model));
}
ob.HolidayId = 0;
ob.HolidayName = model.HolidayName;
ob.LeaveDurationId = model.LeaveDurationId == 0 ? (int)LeaveServices.Leave_Duration.FullDay : model.LeaveDurationId;
ob.StartDate = model.StartDate;
ob.EndDate = model.EndDate;
ob.UpdatedBy = HRMHelper.CurrentUser.UserId;
ob.CreatedBy = HRMHelper.CurrentUser.UserId;
int x = HolidayServices.InsertUpdateHoliday(ob);
if (x > 0)
{
ob.HolidayId = x;
TempData[HRMWeb.Helpers.AlertStyles.Success] = "Holiday Saved Successfully";
model = new HolidayModel();
}
else
{
TempData[HRMWeb.Helpers.AlertStyles.Danger] = "Save Fails";
}
}
return(View(model));
}
public Form1()
{
InitializeComponent();
monthCalendarHoliday.Hide();
EmployeeModel em = new EmployeeModel();
HolidayModel hm = new HolidayModel();
hm.get_holiday(2);
DateTime searched_date = Convert.ToDateTime("2020-02-21 00:00:00");
//Console.WriteLine(em.get_employees_not_available_for_specific_date(searched_date));
Console.WriteLine(em.get_employees_available_for_specific_date(searched_date));
}
public ActionResult Add(HolidayModel holidayModel)
{
try
{
holidayModel.AddHoliday();
TempData["message"] = "Successfully added Branch.";
TempData["alertType"] = "success";
}
catch (Exception e)
{
TempData["message"] = "Failed to Add Branch.";
TempData["alertType"] = "danger";
Console.Write(e.Message);
}
return(View(holidayModel));
}
public static void CreateHoliday(HolidayModel holidayModel)
{
using (ctaDBEntities entities = new ctaDBEntities())
{
Holiday hol = new Holiday()
{
date = holidayModel.date, duration = holidayModel.duration, market_id = holidayModel.market_id
};
entities.Holidays.Add(hol);
entities.SaveChanges();
if (!(entities.Database.Connection.State == ConnectionState.Closed))
{
entities.Database.Connection.Close();
}
}
}
public static long InsertHoliday(HolidayModel holiday)
{
try
{
BuildQuery qb = new BuildQuery(ConfigurationManager.ConnectionStrings["DefaultConnection"].ToString());
qb.ClearParameters();
qb.SetInParam("@HolidayDate", holiday.HolidayDate, SqlDbType.DateTime);
qb.SetInParam("@Name", holiday.Name, SqlDbType.NVarChar);
qb.SetInParam("@Remarks", holiday.Remark, SqlDbType.NVarChar);
var result = qb.ExecuteNonQuery("spInsertHoliday", CommandType.StoredProcedure);
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public static void DeleteHoliday(HolidayModel holidayModel)
{
using (ctaDBEntities entities = new ctaDBEntities())
{
Holiday hol = entities.Holidays.Where(s => s.Id == holidayModel.Id).FirstOrDefault();
if (hol != null)
{
entities.Holidays.Remove(hol);
entities.SaveChanges();
}
if (!(entities.Database.Connection.State == ConnectionState.Closed))
{
entities.Database.Connection.Close();
}
}
}
public ActionResult Create()
{
if (!_permissionService.Authorize("ManageHoliday"))
{
return(AccessDeniedView());
}
var model = new HolidayModel();
model.AvailableAcadmicYears = _smsService.GetAllAcadmicYears().Select(x => new SelectListItem()
{
Text = x.Name.Trim(),
Value = x.Id.ToString(),
Selected = x.IsActive
}).ToList();
return(View(model));
}
private void button_decline_req_Click(object sender, EventArgs e)
{
int selected_emp_email = int.Parse(Holiday_dataGrid.CurrentCell.Value.ToString());
try
{
HolidayModel hm = new HolidayModel();
hm.reject_holiday(selected_emp_email);
// Update table with new results
Holiday_dataGrid.Refresh();
} catch (Exception es)
{
Console.WriteLine(es);
MessageBox.Show("Action failed whilst trying to alter the status of this holiday", "Action failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public ActionResult Edit(HolidayModel model, FormCollection frm, bool continueEditing)
{
if (!_permissionService.Authorize("ManageHoliday"))
{
return(AccessDeniedView());
}
var user = _userContext.CurrentUser;
// Check for duplicate classroom, if any
var checkHoliday = _smsService.CheckHolidayExists(model.Name, model.Id);
if (checkHoliday)
{
ModelState.AddModelError("Name", "A Holiday with the same name already exists. Please choose a different name.");
}
if (ModelState.IsValid)
{
var objHoliday = _smsService.GetHolidayById(model.Id);
if (objHoliday != null)
{
model.CreatedOn = objHoliday.CreatedOn;
objHoliday = model.ToEntity(objHoliday);
objHoliday.ModifiedOn = DateTime.Now;
_smsService.UpdateHoliday(objHoliday);
}
}
else
{
model.AvailableAcadmicYears = _smsService.GetAllAcadmicYears().Select(x => new SelectListItem()
{
Text = x.Name.Trim(),
Value = x.Id.ToString(),
Selected = model.AcadmicYearId == x.Id
}).ToList();
return(View(model));
}
SuccessNotification("Holiday updated successfully.");
if (continueEditing)
{
return(RedirectToAction("Edit", new { id = model.Id }));
}
return(RedirectToAction("List"));
}
