public IActionResult AddEdit(DeviceConfigurationDetails pdevice)
 {
     try
     {
         if (pdevice != null && !string.IsNullOrEmpty(pdevice.devicecalibration.SetupId))
         {
             DeviceCalibration ldevice = lIDeviceCalibrationRepository.getDeviceCalibration(pdevice.devicecalibration.SetupId);
             if (ldevice != null)
             {
                 ldevice.Description = pdevice.devicecalibration.Description;
                 lIDeviceCalibrationRepository.UpdateDeviceCalibration(ldevice);
                 return(RedirectToAction("Index", "Equipment"));
             }
         }
     }
     catch (Exception ex)
     {
         logger.LogDebug("User Post Error: " + ex);
         return(null);
     }
     return(null);
 }
Exemple #2
0
        public JsonResult updatedevicecalibration([FromBody] UpdateDeviceCalibrationView pDeviceCalibration, string sessionid)
        {
            ErrorResponse error    = new ErrorResponse();
            var           response = new Dictionary <string, object>();

            try
            {
                logger.LogDebug("Pain Post Start");
                if (string.IsNullOrEmpty(sessionid))
                {
                    return(Json(new { Status = (int)HttpStatusCode.Accepted, result = "The Session Id should not be null", TimeZone = DateTime.UtcNow.ToString("s") }));
                }
                if (pDeviceCalibration != null)
                {
                    if (ModelState.IsValid == false)
                    {
                        var modelErrors = new List <string>();
                        foreach (var modelState in ModelState.Values)
                        {
                            foreach (var modelError in modelState.Errors)
                            {
                                modelErrors.Add(modelError.ErrorMessage);
                            }
                        }
                        return(Json(new { Status = (int)HttpStatusCode.Accepted, result = "The Required filed are missing", Error = modelErrors, TimeZone = DateTime.UtcNow.ToString("s") }));
                    }
                    User luser = lIUserRepository.getUserbySessionId(sessionid);
                    if (luser != null)
                    {
                        DeviceCalibration ldevice = lIDeviceCalibrationRepository.getDeviceCalibration(pDeviceCalibration.SetupId);
                        if (ldevice != null)
                        {
                            //if (!string.IsNullOrEmpty(pDeviceCalibration.TabletId))
                            ldevice.TabletId = pDeviceCalibration.TabletId;
                            //if (!string.IsNullOrEmpty(pDeviceCalibration.MacAddress))
                            ldevice.MacAddress = pDeviceCalibration.MacAddress;
                            //if (!string.IsNullOrEmpty(pDeviceCalibration.ChairId))
                            ldevice.ChairId = ldevice.ChairId;
                            //if (!string.IsNullOrEmpty(pDeviceCalibration.BoomId1))
                            ldevice.BoomId1 = pDeviceCalibration.BoomId1;
                            //if (!string.IsNullOrEmpty(pDeviceCalibration.BoomId2))
                            ldevice.BoomId2 = pDeviceCalibration.BoomId2;
                            //if (!string.IsNullOrEmpty(pDeviceCalibration.BoomId3))
                            ldevice.BoomId3 = pDeviceCalibration.BoomId3;
                            //if (!string.IsNullOrEmpty(pDeviceCalibration.EquipmentType))
                            ldevice.EquipmentType = pDeviceCalibration.EquipmentType;
                            //if (!string.IsNullOrEmpty(pDeviceCalibration.DeviceConfiguration))
                            ldevice.DeviceConfiguration = pDeviceCalibration.DeviceConfiguration;
                            //if (!string.IsNullOrEmpty(pDeviceCalibration.PatientSide))
                            ldevice.PatientSide = pDeviceCalibration.PatientSide;


                            //if (pDeviceCalibration.Actuator1RetractedAngle > 0)
                            ldevice.Actuator1RetractedAngle = pDeviceCalibration.Actuator1RetractedAngle;
                            //if (pDeviceCalibration.Actuator1RetractedPulse > 0)
                            ldevice.Actuator1RetractedPulse = pDeviceCalibration.Actuator1RetractedPulse;
                            //if (pDeviceCalibration.Actuator1ExtendedAngle > 0)
                            ldevice.Actuator1ExtendedAngle = pDeviceCalibration.Actuator1ExtendedAngle;
                            //if (pDeviceCalibration.Actuator1ExtendedPulse > 0)
                            ldevice.Actuator1ExtendedPulse = pDeviceCalibration.Actuator1ExtendedPulse;
                            //if (pDeviceCalibration.Actuator1NeutralAngle > 0)
                            ldevice.Actuator1NeutralAngle = pDeviceCalibration.Actuator1NeutralAngle;
                            //if (pDeviceCalibration.Actuator1NeutralPulse > 0)
                            ldevice.Actuator1NeutralPulse = pDeviceCalibration.Actuator1NeutralPulse;

                            //if (pDeviceCalibration.Actuator2RetractedAngle != null)
                            ldevice.Actuator2RetractedAngle = pDeviceCalibration.Actuator2RetractedAngle;
                            //if (pDeviceCalibration.Actuator2RetractedPulse != null)
                            ldevice.Actuator2RetractedPulse = pDeviceCalibration.Actuator2RetractedPulse;
                            //if (pDeviceCalibration.Actuator2ExtendedAngle != null)
                            ldevice.Actuator2ExtendedAngle = pDeviceCalibration.Actuator2ExtendedAngle;
                            //if (pDeviceCalibration.Actuator2ExtendedPulse != null)
                            ldevice.Actuator2ExtendedPulse = pDeviceCalibration.Actuator2ExtendedPulse;
                            //if (pDeviceCalibration.Actuator2NeutralAngle != null)
                            ldevice.Actuator2NeutralAngle = pDeviceCalibration.Actuator2NeutralAngle;
                            //if (pDeviceCalibration.Actuator2NeutralPulse != null)
                            ldevice.Actuator2NeutralPulse = pDeviceCalibration.Actuator2NeutralPulse;

                            //if (pDeviceCalibration.Actuator3RetractedAngle != null)
                            ldevice.Actuator3RetractedAngle = pDeviceCalibration.Actuator3RetractedAngle;
                            //if (pDeviceCalibration.Actuator3RetractedPulse != null)
                            ldevice.Actuator3RetractedPulse = pDeviceCalibration.Actuator3RetractedPulse;
                            //if (pDeviceCalibration.Actuator3ExtendedAngle != null)
                            ldevice.Actuator3ExtendedAngle = pDeviceCalibration.Actuator3ExtendedAngle;
                            //if (pDeviceCalibration.Actuator3ExtendedPulse != null)
                            ldevice.Actuator3ExtendedPulse = pDeviceCalibration.Actuator3ExtendedPulse;
                            //if (pDeviceCalibration.Actuator3NeutralAngle != null)
                            ldevice.Actuator3NeutralAngle = pDeviceCalibration.Actuator3NeutralAngle;
                            //if (pDeviceCalibration.Actuator3NeutralPulse != null)
                            ldevice.Actuator3NeutralPulse = pDeviceCalibration.Actuator3NeutralPulse;

                            //if (!string.IsNullOrEmpty(pDeviceCalibration.InstallerId))
                            ldevice.InstallerId = pDeviceCalibration.InstallerId;

                            ldevice.InActive    = pDeviceCalibration.InActive;
                            ldevice.UpdatedDate = DateTime.UtcNow;
                            //if (!string.IsNullOrEmpty(pDeviceCalibration.UpdatePending))
                            ldevice.UpdatePending = pDeviceCalibration.UpdatePending;
                            //if (!string.IsNullOrEmpty(pDeviceCalibration.NewControllerId))
                            ldevice.NewControllerId = pDeviceCalibration.NewControllerId;

                            //if (!string.IsNullOrEmpty(pDeviceCalibration.Description))
                            ldevice.Description = pDeviceCalibration.Description;
                            //if (pDeviceCalibration.Latitude != null)
                            ldevice.Latitude = pDeviceCalibration.Latitude;
                            //if (pDeviceCalibration.Longitude != null)
                            ldevice.Longitude = pDeviceCalibration.Longitude;

                            lIDeviceCalibrationRepository.UpdateDeviceCalibration(ldevice);

                            return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration updated successfully", TimeZone = DateTime.UtcNow.ToString("s") }));
                        }
                        else
                        {
                            return(Json(new { Status = (int)5, result = "Device Calibration record not found - Invalid SetupId", TimeZone = DateTime.UtcNow.ToString("s") }));
                        }
                    }
                    else
                    {
                        return(Json(new { Status = (int)HttpStatusCode.Unauthorized, result = "Unauthorized User", TimeZone = DateTime.UtcNow.ToString("s") }));
                    }
                }
                else
                {
                    return(Json(new { Status = (int)HttpStatusCode.Created, result = "Device Calibration Input not valid", TimeZone = DateTime.UtcNow.ToString("s") }));
                }
            }
            catch (Exception ex)
            {
                return(Json(new { Status = (int)HttpStatusCode.InternalServerError, result = "Device Calibration update failed", TimeZone = DateTime.UtcNow.ToString("s") }));
            }
        }
Exemple #3
0
        public JsonResult updatedevicecalibration([FromBody] DeviceCalibrationView pDeviceCalibration, string sessionid)
        {
            ErrorResponse error    = new ErrorResponse();
            var           response = new Dictionary <string, object>();

            try
            {
                logger.LogDebug("Pain Post Start");

                if (pDeviceCalibration != null && !string.IsNullOrEmpty(pDeviceCalibration.SetupId) && !string.IsNullOrEmpty(sessionid))
                {
                    User luser = lIUserRepository.getUserbySessionId(sessionid);
                    if (luser != null)
                    {
                        DeviceCalibration ldevice = lIDeviceCalibrationRepository.getDeviceCalibration(pDeviceCalibration.SetupId);
                        if (ldevice != null)
                        {
                            if (!string.IsNullOrEmpty(pDeviceCalibration.TabletId))
                            {
                                ldevice.TabletId = pDeviceCalibration.TabletId;
                            }
                            if (!string.IsNullOrEmpty(pDeviceCalibration.MacAddress))
                            {
                                ldevice.MacAddress = pDeviceCalibration.MacAddress;
                            }
                            if (!string.IsNullOrEmpty(pDeviceCalibration.ChairId))
                            {
                                ldevice.ChairId = ldevice.ChairId;
                            }
                            if (!string.IsNullOrEmpty(pDeviceCalibration.BoomId1))
                            {
                                ldevice.BoomId1 = pDeviceCalibration.BoomId1;
                            }
                            if (!string.IsNullOrEmpty(pDeviceCalibration.BoomId2))
                            {
                                ldevice.BoomId2 = pDeviceCalibration.BoomId2;
                            }
                            if (!string.IsNullOrEmpty(pDeviceCalibration.BoomId3))
                            {
                                ldevice.BoomId3 = pDeviceCalibration.BoomId3;
                            }
                            if (!string.IsNullOrEmpty(pDeviceCalibration.EquipmentType))
                            {
                                ldevice.EquipmentType = pDeviceCalibration.EquipmentType;
                            }
                            if (!string.IsNullOrEmpty(pDeviceCalibration.DeviceConfiguration))
                            {
                                ldevice.DeviceConfiguration = pDeviceCalibration.DeviceConfiguration;
                            }
                            if (!string.IsNullOrEmpty(pDeviceCalibration.PatientSide))
                            {
                                ldevice.PatientSide = pDeviceCalibration.PatientSide;
                            }
                            if (pDeviceCalibration.Actuator1RetractedAngle > 0)
                            {
                                ldevice.Actuator1RetractedAngle = pDeviceCalibration.Actuator1RetractedAngle;
                            }
                            if (pDeviceCalibration.Actuator1RetractedPulse > 0)
                            {
                                ldevice.Actuator1RetractedPulse = pDeviceCalibration.Actuator1RetractedPulse;
                            }
                            if (pDeviceCalibration.Actuator1ExtendedAngle > 0)
                            {
                                ldevice.Actuator1ExtendedAngle = pDeviceCalibration.Actuator1ExtendedAngle;
                            }
                            if (pDeviceCalibration.Actuator1ExtendedPulse > 0)
                            {
                                ldevice.Actuator1ExtendedPulse = pDeviceCalibration.Actuator1ExtendedPulse;
                            }
                            if (pDeviceCalibration.Actuator1NeutralAngle > 0)
                            {
                                ldevice.Actuator1NeutralAngle = pDeviceCalibration.Actuator1NeutralAngle;
                            }
                            if (pDeviceCalibration.Actuator1NeutralPulse > 0)
                            {
                                ldevice.Actuator1NeutralPulse = pDeviceCalibration.Actuator1NeutralPulse;
                            }
                            if (pDeviceCalibration.Actuator2RetractedAngle > 0)
                            {
                                ldevice.Actuator2RetractedAngle = pDeviceCalibration.Actuator2RetractedAngle;
                            }
                            if (pDeviceCalibration.Actuator2RetractedPulse > 0)
                            {
                                ldevice.Actuator2RetractedPulse = pDeviceCalibration.Actuator2RetractedPulse;
                            }
                            if (pDeviceCalibration.Actuator2ExtendedAngle > 0)
                            {
                                ldevice.Actuator2ExtendedAngle = pDeviceCalibration.Actuator2ExtendedAngle;
                            }
                            if (pDeviceCalibration.Actuator2ExtendedPulse > 0)
                            {
                                ldevice.Actuator2ExtendedPulse = pDeviceCalibration.Actuator2ExtendedPulse;
                            }
                            if (pDeviceCalibration.Actuator2NeutralAngle > 0)
                            {
                                ldevice.Actuator2NeutralAngle = pDeviceCalibration.Actuator2NeutralAngle;
                            }
                            if (pDeviceCalibration.Actuator2NeutralPulse > 0)
                            {
                                ldevice.Actuator2NeutralPulse = pDeviceCalibration.Actuator2NeutralPulse;
                            }
                            if (pDeviceCalibration.Actuator3RetractedAngle > 0)
                            {
                                ldevice.Actuator3RetractedAngle = pDeviceCalibration.Actuator3RetractedAngle;
                            }
                            if (pDeviceCalibration.Actuator3RetractedPulse > 0)
                            {
                                ldevice.Actuator3RetractedPulse = pDeviceCalibration.Actuator3RetractedPulse;
                            }
                            if (pDeviceCalibration.Actuator3ExtendedAngle > 0)
                            {
                                ldevice.Actuator3ExtendedAngle = pDeviceCalibration.Actuator3ExtendedAngle;
                            }
                            if (pDeviceCalibration.Actuator3ExtendedPulse > 0)
                            {
                                ldevice.Actuator3ExtendedPulse = pDeviceCalibration.Actuator3ExtendedPulse;
                            }
                            if (pDeviceCalibration.Actuator3NeutralAngle > 0)
                            {
                                ldevice.Actuator3NeutralAngle = pDeviceCalibration.Actuator3NeutralAngle;
                            }
                            if (pDeviceCalibration.Actuator3NeutralPulse > 0)
                            {
                                ldevice.Actuator3NeutralPulse = pDeviceCalibration.Actuator3NeutralPulse;
                            }
                            if (!string.IsNullOrEmpty(pDeviceCalibration.InstallerId))
                            {
                                ldevice.InstallerId = pDeviceCalibration.InstallerId;
                            }

                            ldevice.InActive    = pDeviceCalibration.InActive;
                            ldevice.UpdatedDate = DateTime.UtcNow;
                            if (!string.IsNullOrEmpty(pDeviceCalibration.UpdatePending))
                            {
                                ldevice.UpdatePending = pDeviceCalibration.UpdatePending;
                            }
                            if (!string.IsNullOrEmpty(pDeviceCalibration.NewControllerId))
                            {
                                ldevice.NewControllerId = pDeviceCalibration.NewControllerId;
                            }

                            if (!string.IsNullOrEmpty(pDeviceCalibration.Description))
                            {
                                ldevice.Description = pDeviceCalibration.Description;
                            }
                            if (pDeviceCalibration.Latitude != null)
                            {
                                ldevice.Latitude = pDeviceCalibration.Latitude;
                            }
                            if (pDeviceCalibration.Longitude != null)
                            {
                                ldevice.Longitude = pDeviceCalibration.Longitude;
                            }

                            lIDeviceCalibrationRepository.UpdateDeviceCalibration(ldevice);

                            return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration updated successfully", TimeZone = DateTime.UtcNow.ToString("s") }));
                        }
                        else
                        {
                            return(Json(new { Status = (int)HttpStatusCode.RedirectMethod, result = "Device Calibration update failed", TimeZone = DateTime.UtcNow.ToString("s") }));
                        }
                    }

                    else
                    {
                        return(Json(new { Status = (int)HttpStatusCode.Created, result = "Device Calibration Input not valid", TimeZone = DateTime.UtcNow.ToString("s") }));
                    }
                }
                else
                {
                    return(Json(new { Status = (int)HttpStatusCode.Created, result = "Device Calibration Input not valid", TimeZone = DateTime.UtcNow.ToString("s") }));
                }
            }
            catch (Exception ex)
            {
                return(Json(new { Status = (int)HttpStatusCode.InternalServerError, result = "Device Calibration update failed", TimeZone = DateTime.UtcNow.ToString("s") }));
            }
        }