public HttpResponseMessage RequestExternalShift(Guid Id, ExternalShiftActionDTO ExternalshiftRequestDTO)
        {
            try
            {
                var ExternalshiftBroadcast = db.ExternalShiftBroadcasts.Find(Id);
                if (ExternalshiftBroadcast == null)
                {
                    return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "ExternalShiftBroadCast not found"));
                }

                //Only the staff member assigned to the shift can request to cancel the shift

                var email = HttpContext.Current.User.Identity.Name;

                var user = db.UserProfiles.FirstOrDefault(a => a.Email == email && a.IsRegisteredExternal == true);

                var ExternalempLoyee = db.UserProfiles.FirstOrDefault(usr => usr.Email == email).Employees.FirstOrDefault(emp => emp.BusinessLocation.Id == ExternalshiftBroadcast.Shifts.First().InternalLocation.BusinessLocation.Id);

                //Check to see if there is already a pending shift request
                var shiftRequest = db.ExternalShiftRequests.Where(sc => sc.Type == ExternalShiftRequestType.TakeExternalShift &&
                                                                  sc.ExternalShiftBroadcast.Id == Id &&
                                                                  sc.Status == RequestStatus.Pending &&
                                                                  sc.CreatedBy.Id == user.Id);
                if (shiftRequest.Count() > 0)
                {
                    return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Existing request already pending for shift id:" + Id.ToString()));
                }

                ExternalShiftRequest shiftChangeRequest = new ExternalShiftRequest
                {
                    Id = Guid.NewGuid(),
                    ExternalShiftBroadcast = ExternalshiftBroadcast,
                    Type        = ExternalShiftRequestType.TakeExternalShift,
                    Status      = RequestStatus.Pending,
                    Reason      = ExternalshiftRequestDTO.Reason,
                    CreatedDate = WebUI.Common.Common.DateTimeNowLocal(),
                    CreatedBy   = user
                };

                db.ExternalShiftRequests.Add(shiftChangeRequest);
                db.SaveChanges();

                return(Request.CreateResponse(HttpStatusCode.Created, shiftChangeRequest.Id));
            }
            catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
            {
                foreach (var validationErrors in dbEx.EntityValidationErrors)
                {
                    foreach (var validationError in validationErrors.ValidationErrors)
                    {
                        System.Diagnostics.Trace.TraceInformation(
                            "Class: {0}, Property: {1}, Error: {2}",
                            validationErrors.Entry.Entity.GetType().FullName,
                            validationError.PropertyName,
                            validationError.ErrorMessage);
                    }
                }
                return(Request.CreateResponse(HttpStatusCode.ExpectationFailed));
            }
        }
Exemplo n.º 2
0
        //[Authorize(Roles = Constants.RoleBusinessLocationManager + "," + Constants.RoleBusinessAdmin)]
        public ActionResult ApproveExternalShiftRequest(string reqId, string reason, bool isRecurring)
        {
            //Current user has requested to be linked to a business
            using (HttpClientWrapper httpClient = new HttpClientWrapper(Session))
            {
                var acceptDTO = new ExternalShiftActionDTO {
                    Id = Guid.Parse(reqId), Reason = reason
                };

                if (!isRecurring)
                {
                    HttpResponseMessage response = httpClient.PostAsJsonAsync("api/ManagerShiftActionAPI/ApproveExternalShiftRequest/" + reqId, acceptDTO).Result;
                    Response.StatusCode = (int)response.StatusCode;
                    if (!response.IsSuccessStatusCode)
                    {
                        Response.SuppressFormsAuthenticationRedirect = true;
                        return(this.Content(JsonConvert.DeserializeObject <dynamic>(response.Content.ReadAsStringAsync().Result).Message.ToString()));
                    }
                }
            }
            return(Content("Success"));
        }
        public HttpResponseMessage RejectExternalShiftRequest(string id, ExternalShiftActionDTO rejectDTO)
        {
            try
            {
                var requestId = Guid.Parse(id);
                var email     = HttpContext.Current.User.Identity.Name;

                var scRequest = db.ExternalShiftRequests.FirstOrDefault(er => er.Id == requestId && er.Status == RequestStatus.Pending);

                //Ensure user has "Put" manager permissions for the business location which the request corresponds to
                if (!ClaimsAuthorization.CheckAccess("Put", "BusinessLocationId", scRequest.ExternalShiftBroadcast.Shifts.First().Roster.BusinessLocation.Id.ToString()))
                {
                    return(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "You do not have permissions."));
                }

                if (scRequest == null)
                {
                    return(Request.CreateErrorResponse(HttpStatusCode.ExpectationFailed, "Unable to find pending shift change request."));
                }

                //Update Request object
                scRequest.Status          = RequestStatus.Denied;
                scRequest.ActionedDate    = WebUI.Common.Common.DateTimeNowLocal();
                scRequest.ActionedComment = rejectDTO.Reason;
                //Attach the Employee record which matches the logged in user profile and business id.
                scRequest.ActionedBy = db.UserProfiles.FirstOrDefault(usr => usr.Email == email).Employees.FirstOrDefault(emp => emp.BusinessLocation.Id == scRequest.ExternalShiftBroadcast.Shifts.First().Roster.BusinessLocation.Id);

                db.SaveChanges();

                MessagingService.ShiftChangeRequestRejected(scRequest.CreatedBy.Email, scRequest.CreatedBy.FirstName, "", scRequest.ActionedBy.FirstName + ' ' + scRequest.ActionedBy.LastName, rejectDTO.Reason);


                return(Request.CreateResponse(HttpStatusCode.OK));
            }
            catch (Exception ex)
            {
                throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
            }
        }
        public HttpResponseMessage ApproveExternalShiftRequest(string id, ExternalShiftActionDTO acceptDTO)
        {
            try
            {
                var requestId = Guid.Parse(id);
                var email     = HttpContext.Current.User.Identity.Name;

                var user = db.UserProfiles.FirstOrDefault(usr => usr.Id == db.ExternalShiftRequests.FirstOrDefault(a => a.Id == requestId).CreatedBy.Id&& usr.IsRegisteredExternal == true);

                var ExternalshiftRequest = db.ExternalShiftRequests.Find(requestId);

                var businessLocation = ExternalshiftRequest.ExternalShiftBroadcast.Shifts.FirstOrDefault().Roster.BusinessLocation;

                //Set the Status of ExternalBroadCastShift pending to Filled.
                ExternalshiftRequest.ExternalShiftBroadcast.Status = ExternalShiftStatus.Filled;

                // if user already Existing in table.
                var Externalemp = db.Employees.Where(emp => emp.UserProfile.Id == user.Id).FirstOrDefault();

                if (Externalemp == null)
                {
                    EmployeeDTO empModel = new EmployeeDTO();
                    empModel.FirstName   = user.FirstName;
                    empModel.LastName    = user.LastName;
                    empModel.DateOfBirth = user.DateofBirth;
                    empModel.Email       = user.Email;
                    empModel.IsActive    = true;
                    empModel.IsAdmin     = false;
                    empModel.MobilePhone = user.MobilePhone;
                    empModel.Type        = EmployeeTypeDTO.External;

                    Externalemp             = MapperFacade.MapperConfiguration.Map <EmployeeDTO, Employee>(empModel);
                    Externalemp.Id          = Guid.NewGuid();
                    Externalemp.UserProfile = user;


                    Externalemp.BusinessLocation = businessLocation;
                    //Create QR code for the employee
                    System.Drawing.Bitmap qrCodeImage = WebUI.Common.Common.GenerateQR(empModel.Id.ToString());

                    using (System.IO.MemoryStream memory = new System.IO.MemoryStream())
                    {
                        qrCodeImage.Save(memory, System.Drawing.Imaging.ImageFormat.Jpeg);
                        Externalemp.QRCode = memory.ToArray();
                    }

                    db.Employees.Add(Externalemp);
                }

                var scRequest = db.ExternalShiftRequests.FirstOrDefault(er => er.Id == requestId && er.Status == RequestStatus.Pending);

                if (scRequest == null)
                {
                    return(Request.CreateErrorResponse(HttpStatusCode.ExpectationFailed, "Unable to find pending External shift request."));
                }

                //Ensure user has "Put" manager permissions for the business which the request corresponds to
                if (!ClaimsAuthorization.CheckAccess("Put", "BusinessLocationId", scRequest.ExternalShiftBroadcast.Shifts.First().Roster.BusinessLocation.Id.ToString()))
                {
                    return(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "You do not have permissions."));
                }


                //Update Request object
                scRequest.Status          = RequestStatus.Approved;
                scRequest.ActionedDate    = WebUI.Common.Common.DateTimeNowLocal();
                scRequest.ActionedComment = acceptDTO.Reason;
                //Attach the Employee record which matches the logged in user profile and business id.
                scRequest.ActionedBy = db.UserProfiles.FirstOrDefault(usr => usr.Email == email).Employees.FirstOrDefault(emp => emp.BusinessLocation.Id == scRequest.ExternalShiftBroadcast.Shifts.First().InternalLocation.BusinessLocation.Id);

                //If this is an open shift Take request, then need to reject all other requests for same shift
                // and send notification
                if (scRequest.Type == ExternalShiftRequestType.TakeExternalShift)
                {
                    foreach (var shift in scRequest.ExternalShiftBroadcast.Shifts)
                    {
                        shift.Employee = Externalemp; //Assign the open shift to the employee
                    }
                    foreach (var ExternalShiftRequest in db.ExternalShiftRequests.Where(scr => scr.ExternalShiftBroadcast.Id == scRequest.ExternalShiftBroadcast.Id && scr.Id != scRequest.Id))
                    {
                        ExternalShiftRequest.Status          = RequestStatus.Denied;
                        ExternalShiftRequest.ActionedDate    = WebUI.Common.Common.DateTimeNowLocal();
                        ExternalShiftRequest.ActionedComment = acceptDTO.Reason;
                        ExternalShiftRequest.ActionedBy      = db.UserProfiles.FirstOrDefault(usr => usr.Email == email).Employees.FirstOrDefault(emp => emp.BusinessLocation.Id == scRequest.ExternalShiftBroadcast.Shifts.First().InternalLocation.BusinessLocation.Id);
                    }

                    MessagingService.OpenShiftRequestAccept(scRequest.CreatedBy.Email, scRequest.CreatedBy.FirstName, scRequest.ExternalShiftBroadcast.Description);
                }
                db.SaveChanges();

                return(Request.CreateResponse(HttpStatusCode.OK));
            }
            catch (Exception ex)
            {
                throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
            }
        }