public static DeviceCalibration DeviceCalibrationViewToDeviceCalibration(DeviceCalibrationView lDeviceCalibration)
{
if (lDeviceCalibration == null)
{
return(null);
}
DeviceCalibration ldevice = new DeviceCalibration()
{
ControllerId = lDeviceCalibration.ControllerId,
ControllerDateTime = lDeviceCalibration.ControllerDateTime,
MacAddress = lDeviceCalibration.MacAddress,
ChairId = lDeviceCalibration.ChairId,
BoomId1 = lDeviceCalibration.BoomId1,
BoomId2 = lDeviceCalibration.BoomId2,
BoomId3 = lDeviceCalibration.BoomId3,
EquipmentType = lDeviceCalibration.EquipmentType,
DeviceConfiguration = lDeviceCalibration.DeviceConfiguration,
PatientSide = lDeviceCalibration.PatientSide,
Actuator1RetractedAngle = lDeviceCalibration.Actuator1RetractedAngle,
Actuator1RetractedPulse = lDeviceCalibration.Actuator1RetractedPulse,
Actuator1ExtendedAngle = lDeviceCalibration.Actuator1ExtendedAngle,
Actuator1ExtendedPulse = lDeviceCalibration.Actuator1ExtendedPulse,
Actuator1NeutralAngle = lDeviceCalibration.Actuator1NeutralAngle,
Actuator1NeutralPulse = lDeviceCalibration.Actuator1NeutralPulse,
Actuator2RetractedAngle = lDeviceCalibration.Actuator2RetractedAngle,
Actuator2RetractedPulse = lDeviceCalibration.Actuator2RetractedPulse,
Actuator2ExtendedAngle = lDeviceCalibration.Actuator2ExtendedAngle,
Actuator2ExtendedPulse = lDeviceCalibration.Actuator2ExtendedPulse,
Actuator2NeutralAngle = lDeviceCalibration.Actuator2NeutralAngle,
Actuator2NeutralPulse = lDeviceCalibration.Actuator2NeutralPulse,
Actuator3RetractedAngle = lDeviceCalibration.Actuator3RetractedAngle,
Actuator3RetractedPulse = lDeviceCalibration.Actuator3RetractedPulse,
Actuator3ExtendedAngle = lDeviceCalibration.Actuator3ExtendedAngle,
Actuator3ExtendedPulse = lDeviceCalibration.Actuator3ExtendedPulse,
Actuator3NeutralAngle = lDeviceCalibration.Actuator3NeutralAngle,
Actuator3NeutralPulse = lDeviceCalibration.Actuator3NeutralPulse,
InstallerId = lDeviceCalibration.InstallerId,
InActive = lDeviceCalibration.InActive,
UpdatePending = lDeviceCalibration.UpdatePending,
NewControllerId = lDeviceCalibration.NewControllerId,
Description = lDeviceCalibration.Description,
Latitude = lDeviceCalibration.Latitude,
Longitude = lDeviceCalibration.Longitude,
TabletId = lDeviceCalibration.TabletId
};
return(ldevice);
}
public JsonResult createdevicecalibration([FromBody] DeviceCalibrationView pDeviceCalibration, string sessionid)
{
ErrorResponse error = new ErrorResponse();
var response = new Dictionary <string, object>();
try
{
logger.LogDebug("Create device calibration Start");
if (pDeviceCalibration != null && !string.IsNullOrEmpty(sessionid))
{
User luser = lIUserRepository.getUserbySessionId(sessionid);
if (luser != null)
{
pDeviceCalibration.InstallerId = luser.UserId;
DeviceCalibration ldevice = DeviceCalibrationExtension.DeviceCalibrationViewToDeviceCalibration(pDeviceCalibration);
if (ldevice != null)
{
ldevice.CreatedDate = DateTime.UtcNow;
ldevice.UpdatedDate = DateTime.UtcNow;
ldevice.SetupId = Guid.NewGuid().ToString();
lIDeviceCalibrationRepository.InsertDeviceCalibration(ldevice);
return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration inserted successfully", setupid = ldevice.SetupId, TimeZone = DateTime.UtcNow.ToString("s") }));
}
else
{
return(Json(new { Status = (int)HttpStatusCode.Created, result = "Device Calibration insertion failed", TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
else
{
return(Json(new { Status = (int)HttpStatusCode.Created, result = "Device Calibration insertion failed", TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
else
{
return(Json(new { Status = (int)HttpStatusCode.Created, result = "Device Calibration insertion failed", TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
catch (Exception ex)
{
return(Json(new { Status = (int)HttpStatusCode.InternalServerError, result = "Device Calibration insertion failed", TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
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") }));
}
}
