public IActionResult Delete(string id)
{
DeviceCalibration ldevice = (from p in context.DeviceCalibration
where p.SetupId == id
select p).FirstOrDefault();
if (ldevice != null)
{
int res = lIDeviceCalibrationRepository.deleteDeviceCalibrationCascade(id);
if (res > 0)
{
//Insert to User Activity Log
UserActivityLog llog = new UserActivityLog();
llog.SessionId = HttpContext.Session.GetString("SessionId");
llog.ActivityType = "Update";
llog.StartTimeStamp = !string.IsNullOrEmpty(HttpContext.Session.GetString("SessionTime")) ? Convert.ToDateTime(HttpContext.Session.GetString("SessionTime")) : DateTime.Now;
llog.Duration = Convert.ToInt32((DateTime.Now - Convert.ToDateTime(HttpContext.Session.GetString("SessionTime"))).TotalSeconds);
llog.RecordChangeType = "Delete";
llog.RecordType = "Equipment";
llog.Comment = "Record deleted";
llog.RecordJson = JsonConvert.SerializeObject(ldevice);
llog.UserId = HttpContext.Session.GetString("UserId");
llog.UserName = HttpContext.Session.GetString("UserName");
llog.UserType = HttpContext.Session.GetString("UserType");
if (!string.IsNullOrEmpty(HttpContext.Session.GetString("ReviewID")))
{
llog.ReviewId = HttpContext.Session.GetString("ReviewID");
}
lIUserActivityLogRepository.InsertUserActivityLog(llog);
}
}
return(RedirectToAction("Index", "Equipment"));
}
public JsonResult downloaddevicecalibration(string controllerid)
{
try
{
if (!string.IsNullOrEmpty(controllerid))
{
DeviceCalibration _result = lIDeviceCalibrationRepository.getDeviceCalibrationbyControllerId(controllerid);
if (_result != null)
{
return(Json(new { Status = (int)HttpStatusCode.OK, result = "success", Calibration = _result, TimeZone = DateTime.UtcNow.ToString("s") }));
}
else
{
return(Json(new { Status = (int)HttpStatusCode.Redirect, result = "Device calibration is not exist", TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
else
{
return(Json(new { Status = (int)HttpStatusCode.Accepted, result = "request string is not proper", TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
catch (Exception ex)
{
return(Json(new { Status = (int)HttpStatusCode.InternalServerError, result = "Internal server error", TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
public JsonResult createdevicecalibration([FromBody] CreateDeviceCalibrationView pDeviceCalibration, string sessionid)
{
ErrorResponse error = new ErrorResponse();
var response = new Dictionary <string, object>();
try
{
if (string.IsNullOrEmpty(sessionid))
{
return(Json(new { Status = (int)HttpStatusCode.Accepted, result = "The Session Id should not be null", TimeZone = DateTime.UtcNow.ToString("s") }));
}
logger.LogDebug("Create device calibration Start");
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)
{
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 model is not valid", 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 Request is null", 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 static DeviceCalibration DeviceCalibrationViewToDeviceCalibration(CreateDeviceCalibrationView 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 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);
}
public int deleteDeviceCalibrationCascade(string setupId)
{
DeviceCalibration ldevice = (from p in context.DeviceCalibration
where p.SetupId == setupId
select p).FirstOrDefault();
if (ldevice != null)
{
List <PatientConfiguration> lpatientCofig = (from p in context.PatientConfiguration
where p.SetupId == ldevice.SetupId
select p).ToList();
if (lpatientCofig != null)
{
foreach (PatientConfiguration lpat in lpatientCofig)
{
List <Protocol> lprotocolList = (from p in context.Protocol where p.RxId == lpat.RxId select p).ToList();
foreach (Protocol lprotocol in lprotocolList)
{
var pain = (from p in context.Pain where p.ProtocolId == lprotocol.ProtocolId select p).ToList();
context.Pain.RemoveRange(pain);
context.SaveChanges();
var session = (from p in context.Session where p.ProtocolId == lprotocol.ProtocolId select p).ToList();
context.Session.RemoveRange(session);
context.SaveChanges();
var protocol = (from p in context.Protocol where p.ProtocolId == lprotocol.ProtocolId select p).ToList();
context.Protocol.RemoveRange(protocol);
context.SaveChanges();
}
}
context.PatientConfiguration.RemoveRange(lpatientCofig);
context.SaveChanges();
}
context.DeviceCalibration.RemoveRange(ldevice);
return(context.SaveChanges());
}
return(0);
}
public void UpdateDeviceCalibration(DeviceCalibration pDeviceCalibration)
{
context.Entry(pDeviceCalibration).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
context.SaveChanges();
}
public void InsertDeviceCalibration(DeviceCalibration pDeviceCalibration)
{
context.DeviceCalibration.Add(pDeviceCalibration);
context.SaveChanges();
}
// GET: /<controller>/
public IActionResult Index(int id, string Username, string equipmentType, string actuator = "", string tab = "")
{
ReviewModel lmodel = new ReviewModel();
ViewBag.tab = tab;
ViewBag.User = Username;
ViewBag.actuator = actuator;
ViewBag.EquipmentType = equipmentType;
ViewBag.Id = id;
UsageViewModel lusage = new UsageViewModel();
lusage.MaxSessionSuggested = 0;
lusage.PercentageCompleted = 0;
lusage.PercentagePending = 0;
ViewBag.Usage = lusage;
PainViewModel lpain = new PainViewModel();
lpain.TotalPain = 0;
lpain.LowPain = 0;
lpain.MediumPain = 0;
lpain.HighPain = 0;
ViewBag.Pain = lpain;
JsonSerializerSettings lsetting1 = new JsonSerializerSettings();
lsetting1.ContractResolver = new CamelCasePropertyNamesContractResolver();
lsetting1.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
ViewBag.AppleDataFlexionString = JsonConvert.SerializeObject(new List <ColumnrangeSeriesData>(), lsetting1);
ViewBag.VolumeDataFlexionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.PainVolumeDataFlexionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.AppleDataExtensionString = JsonConvert.SerializeObject(new List <ColumnrangeSeriesData>(), lsetting1);
ViewBag.VolumeDataExtensionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.PainVolumeDataExtensionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.AppleDataFlexionExtensionString = JsonConvert.SerializeObject(new List <ColumnrangeSeriesData>(), lsetting1);
ViewBag.VolumeDataFlexionExtensionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.PainVolumeDataFlexionExtensionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
try
{
//Insert to User Activity Log -Patient
JsonSerializerSettings lsetting = new JsonSerializerSettings();
lsetting.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
if (HttpContext.Session.GetString("UserType") != ConstantsVar.Admin.ToString())
{
if (string.IsNullOrEmpty(HttpContext.Session.GetString("ReviewID")))
{
PatientReview lreview = new PatientReview();
lreview.ReviewId = Guid.NewGuid().ToString();
lreview.UserId = HttpContext.Session.GetString("UserId");
lreview.UserName = HttpContext.Session.GetString("UserName");
lreview.UserType = HttpContext.Session.GetString("UserType");
lreview.SessionId = HttpContext.Session.GetString("SessionId");
Patient ppatient = context.Patient.FirstOrDefault(x => x.PatientId == id);
if (ppatient != null)
{
lreview.PatientId = id.ToString();
lreview.PatientName = ppatient.PatientName;
}
lreview.ActivityType = "Review";
lreview.StartTimeStamp = DateTime.Now;
lreview.Duration = 0;
int res = lIPatientReviewRepository.InsertPatientReview(lreview);
if (!string.IsNullOrEmpty(lreview.ReviewId) && res > 0)
{
HttpContext.Session.SetString("ReviewID", lreview.ReviewId);
HttpContext.SetCookie("ReviewID", lreview.ReviewId, 5, CookieExpiryIn.Hours);
ViewBag.StartTimer = "true";
}
}
}
if (!string.IsNullOrEmpty(actuator) && !string.IsNullOrEmpty(tab) && tab == "Dashboard")
{
string _uType = HttpContext.Session.GetString("UserType");
if (_uType == "3" || _uType == "2" || _uType == "1" || _uType == "0" || _uType == "6")
{
{
PatientRx patientRx = lIPatientRxRepository.getByRxIDId(id, actuator);
ViewBag.PatientRx = patientRx;
}
//Usage
PatientRx lPatientRx = lIPatientRxRepository.getPatientRx(id, equipmentType, actuator);
lusage.MaxSessionSuggested = 0;
lusage.PercentageCompleted = 0;
lusage.PercentagePending = 100;
ViewBag.Usage = lusage;
if (lPatientRx != null)
{
double requiredSession = (((Convert.ToDateTime(lPatientRx.RxEndDate) - Convert.ToDateTime(lPatientRx.RxStartDate)).TotalDays / 7) * (int)lPatientRx.RxDaysPerweek * (int)lPatientRx.RxSessionsPerWeek);
int totalSession = lPatientRx.Session != null?lPatientRx.Session.ToList().Count : 0;
lusage.MaxSessionSuggested = (int)requiredSession;
lusage.PercentageCompleted = (int)((totalSession / requiredSession) * 100);
lusage.PercentagePending = 100 - lusage.PercentageCompleted;
ViewBag.Usage = lusage;
}
//Pain
PatientRx lPatientRxPain = lIPatientRxRepository.getPatientRxPain(id, equipmentType, actuator);
lpain.TotalPain = 0;
lpain.LowPain = 0;
lpain.MediumPain = 0;
lpain.HighPain = 100;
ViewBag.Pain = lpain;
if (lPatientRxPain != null)
{
List <Session> lSessionList = lPatientRx.Session != null?lPatientRxPain.Session.ToList() : null;
if (lSessionList != null && lSessionList.Count > 0)
{
lpain.TotalPain = lSessionList.Select(x => x.Pain.Count).Sum();
lpain.LowPain = lpain.TotalPain > 0 ? (int)(((double)(lSessionList.Select(x => x.Pain.Where(y => y.PainLevel <= 2).Count()).Sum()) / lpain.TotalPain) * 100) : 0;
lpain.MediumPain = lpain.TotalPain > 0 ? (int)(((double)(lSessionList.Select(x => x.Pain.Where(y => y.PainLevel > 2 && y.PainLevel <= 5).Count()).Sum()) / lpain.TotalPain) * 100) : 0;
lpain.HighPain = 100 - lpain.MediumPain - lpain.LowPain;
ViewBag.Pain = lpain;
}
}
ROMChartViewModel ROM = lIPatientRxRepository.getPatientRxROMChart(id, equipmentType, actuator);
if (ROM != null)
{
ViewBag.ROM = ROM;
}
ViewBag.EquipmentType = equipmentType;
if (equipmentType == "Shoulder")
{
List <ColumnrangeSeriesData> appleData = new List <ColumnrangeSeriesData>();
List <ColumnSeriesData> volumeData = new List <ColumnSeriesData>();
List <ColumnSeriesData> painvolumeData = new List <ColumnSeriesData>();
//Equipment ROM HighStock Chart
HightStockShoulderViewModel highStockModel = lIPatientRxRepository.getPatientRxEquipmentROMForShoulderInHighStockChart(id, equipmentType, actuator);
if (highStockModel != null)
{
appleData = highStockModel.ROM;
ViewBag.AppleDataFlexion = (appleData != null && appleData.Count > 0) ? appleData.OrderBy(o => o.X).ToList() : appleData;
ViewBag.AppleDataFlexionString = appleData != null?JsonConvert.SerializeObject(appleData, lsetting1) : JsonConvert.SerializeObject(new List <ColumnrangeSeriesData>(), lsetting1);
volumeData = highStockModel.Volume;
ViewBag.VolumeDataFlexion = (volumeData != null && volumeData.Count > 0) ? volumeData.OrderBy(o => o.X).ToList() : volumeData;
ViewBag.VolumeDataFlexionString = volumeData != null?JsonConvert.SerializeObject(volumeData, lsetting1) : JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
painvolumeData = highStockModel.PainVolume;
ViewBag.PainVolumeDataFlexion = (painvolumeData != null && painvolumeData.Count > 0) ? painvolumeData.OrderBy(o => o.X).ToList() : painvolumeData;
ViewBag.PainVolumeDataFlexionString = painvolumeData != null?JsonConvert.SerializeObject(painvolumeData, lsetting1) : JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.AppleDataExtensionString = JsonConvert.SerializeObject(new List <ColumnrangeSeriesData>(), lsetting1);
ViewBag.VolumeDataExtensionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.PainVolumeDataExtensionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.AppleDataFlexionExtensionString = JsonConvert.SerializeObject(new List <ColumnrangeSeriesData>(), lsetting1);
ViewBag.VolumeDataFlexionExtensionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.PainVolumeDataFlexionExtensionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
}
else
{
ViewBag.AppleDataFlexionString = JsonConvert.SerializeObject(new List <ColumnrangeSeriesData>(), lsetting1);
ViewBag.VolumeDataFlexionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.PainVolumeDataFlexionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.AppleDataExtensionString = JsonConvert.SerializeObject(new List <ColumnrangeSeriesData>(), lsetting1);
ViewBag.VolumeDataExtensionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.PainVolumeDataExtensionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.AppleDataFlexionExtensionString = JsonConvert.SerializeObject(new List <ColumnrangeSeriesData>(), lsetting1);
ViewBag.VolumeDataFlexionExtensionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.PainVolumeDataFlexionExtensionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
}
//Equipment ROM
ViewBag.EquipmentType = equipmentType;
}
else
{
//Equipment ROM HighStock Chart
List <ColumnrangeSeriesData> appleDataFlexion = new List <ColumnrangeSeriesData>();
List <ColumnSeriesData> volumeDataFlexion = new List <ColumnSeriesData>();
List <ColumnSeriesData> painvolumeDataFlexion = new List <ColumnSeriesData>();
List <ColumnrangeSeriesData> appleDataExtension = new List <ColumnrangeSeriesData>();
List <ColumnSeriesData> volumeDataExtension = new List <ColumnSeriesData>();
List <ColumnSeriesData> painvolumeDataExtension = new List <ColumnSeriesData>();
List <ColumnrangeSeriesData> appleDataFlexionExtension = new List <ColumnrangeSeriesData>();
List <ColumnSeriesData> volumeDataFlexionExtension = new List <ColumnSeriesData>();
List <ColumnSeriesData> painvolumeDataFlexionExtension = new List <ColumnSeriesData>();
HightStockShoulderViewModel highStockModelFlexion = lIPatientRxRepository.getPatientRxEquipmentROMByFlexionInHighStockChart(id, equipmentType, actuator);
HightStockShoulderViewModel highStockModelExtension = lIPatientRxRepository.getPatientRxEquipmentROMByExtensionInHighStockChart(id, equipmentType, actuator);
HightStockShoulderViewModel highStockModelFlexionExtension = lIPatientRxRepository.getPatientRxEquipmentROMByFlexionExtensionInHighStockChart(id, equipmentType, actuator);
if (highStockModelFlexion != null)
{
appleDataFlexion = highStockModelFlexion.ROM;
ViewBag.AppleDataFlexion = (appleDataFlexion != null && appleDataFlexion.Count > 0) ? appleDataFlexion.OrderBy(o => o.X).ToList() : appleDataFlexion;
ViewBag.AppleDataFlexionString = appleDataFlexion != null?JsonConvert.SerializeObject(appleDataFlexion, lsetting1) : JsonConvert.SerializeObject(new List <ColumnrangeSeriesData>(), lsetting1);
volumeDataFlexion = highStockModelFlexion.Volume;
ViewBag.VolumeDataFlexion = (volumeDataFlexion != null && volumeDataFlexion.Count > 0) ? volumeDataFlexion.OrderBy(o => o.X).ToList() : volumeDataFlexion;
ViewBag.VolumeDataFlexionString = volumeDataFlexion != null?JsonConvert.SerializeObject(volumeDataFlexion, lsetting1) : JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
painvolumeDataFlexion = highStockModelFlexion.PainVolume;
ViewBag.PainVolumeDataFlexion = (painvolumeDataFlexion != null && painvolumeDataFlexion.Count > 0) ? painvolumeDataFlexion.OrderBy(o => o.X).ToList() : painvolumeDataFlexion;
ViewBag.PainVolumeDataFlexionString = painvolumeDataFlexion != null?JsonConvert.SerializeObject(painvolumeDataFlexion, lsetting1) : JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
}
else
{
ViewBag.AppleDataFlexionString = JsonConvert.SerializeObject(new List <ColumnrangeSeriesData>(), lsetting1);
ViewBag.VolumeDataFlexionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.PainVolumeDataFlexionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
}
if (highStockModelExtension != null)
{
appleDataExtension = highStockModelExtension.ROM;
ViewBag.AppleDataExtension = (appleDataExtension != null && appleDataExtension.Count > 0) ? appleDataExtension.OrderBy(o => o.X).ToList() : appleDataExtension;
ViewBag.AppleDataExtensionString = appleDataExtension != null?JsonConvert.SerializeObject(appleDataExtension, lsetting1) : JsonConvert.SerializeObject(new List <ColumnrangeSeriesData>(), lsetting1);
volumeDataExtension = highStockModelExtension.Volume;
ViewBag.VolumeDataExtension = (volumeDataExtension != null && volumeDataExtension.Count > 0) ? volumeDataExtension.OrderBy(o => o.X).ToList() : volumeDataExtension;
ViewBag.VolumeDataExtensionString = volumeDataExtension != null?JsonConvert.SerializeObject(volumeDataExtension, lsetting1) : JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
painvolumeDataExtension = highStockModelExtension.PainVolume;
ViewBag.PainVolumeDataExtension = (painvolumeDataExtension != null && painvolumeDataExtension.Count > 0) ? painvolumeDataExtension.OrderBy(o => o.X).ToList() : painvolumeDataExtension;
ViewBag.PainVolumeDataExtensionString = painvolumeDataExtension != null?JsonConvert.SerializeObject(painvolumeDataExtension, lsetting1) : JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
}
else
{
ViewBag.AppleDataExtensionString = JsonConvert.SerializeObject(new List <ColumnrangeSeriesData>(), lsetting1);
ViewBag.VolumeDataExtensionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.PainVolumeDataExtensionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
}
if (highStockModelFlexionExtension != null)
{
appleDataFlexionExtension = highStockModelFlexionExtension.ROM;
ViewBag.AppleDataFlexionExtension = (appleDataFlexionExtension != null && appleDataFlexionExtension.Count > 0) ? appleDataFlexionExtension.OrderBy(o => o.X).ToList() : appleDataFlexionExtension;
ViewBag.AppleDataFlexionExtensionString = appleDataFlexionExtension != null?JsonConvert.SerializeObject(appleDataFlexionExtension, lsetting1) : JsonConvert.SerializeObject(new List <ColumnrangeSeriesData>(), lsetting1);
volumeDataFlexionExtension = highStockModelFlexionExtension.Volume;
ViewBag.VolumeDataFlexionExtension = (volumeDataFlexionExtension != null && volumeDataFlexionExtension.Count > 0) ? volumeDataFlexionExtension.OrderBy(o => o.X).ToList() : volumeDataFlexionExtension;
ViewBag.VolumeDataFlexionExtensionString = volumeDataFlexionExtension != null?JsonConvert.SerializeObject(volumeDataFlexionExtension, lsetting1) : JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
painvolumeDataFlexionExtension = highStockModelFlexionExtension.PainVolume;
ViewBag.PainVolumeDataFlexionExtension = (painvolumeDataFlexionExtension != null && painvolumeDataFlexionExtension.Count > 0) ? painvolumeDataFlexionExtension.OrderBy(o => o.X).ToList() : painvolumeDataFlexionExtension;
ViewBag.PainVolumeDataFlexionExtensionString = painvolumeDataFlexionExtension != null?JsonConvert.SerializeObject(painvolumeDataFlexionExtension, lsetting1) : JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
}
else
{
ViewBag.AppleDataFlexionExtensionString = JsonConvert.SerializeObject(new List <ColumnrangeSeriesData>(), lsetting1);
ViewBag.VolumeDataFlexionExtensionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
ViewBag.PainVolumeDataFlexionExtensionString = JsonConvert.SerializeObject(new List <ColumnSeriesData>(), lsetting1);
}
//Equipment ROM
ViewBag.EquipmentType = equipmentType;
}
//Treatment Calendar
List <TreatmentCalendarViewModel> TreatmentCalendarList = lIPatientRxRepository.getTreatmentCalendar(id, equipmentType, actuator);
if (TreatmentCalendarList != null && TreatmentCalendarList.Count > 0)
{
ViewBag.TreatmentCalendar = TreatmentCalendarList;
}
//Current Sessions
List <Session> SessionList = lIPatientRxRepository.getCurrentSessions(id, equipmentType, actuator);
if (SessionList != null && SessionList.Count > 0)
{
ViewBag.SessionList = SessionList;
}
if (actuator == "Forward Flexion" || actuator == "External Rotation")
{
ViewBag.Extension = "External Rotation";
ViewBag.Flexion = "Flexion";
}
else
{
ViewBag.Flexion = "Flexion";
ViewBag.Extension = "Extension";
}
}
}
else if (!string.IsNullOrEmpty(actuator) && !string.IsNullOrEmpty(tab) && tab == "Details")
{
List <SelectListItem> list = new List <SelectListItem>();
NewPatient _newPatient = new NewPatient();
if (TempData["Patient"] != null && !string.IsNullOrEmpty(TempData["Patient"].ToString()))
{
_newPatient = JsonConvert.DeserializeObject <NewPatient>(TempData["Patient"].ToString());
}
getDetails();
List <Sides> Sides = Utilities.GetSide();
list = new List <SelectListItem>();
foreach (Sides ex in Sides)
{
list.Add(new SelectListItem {
Text = ex.Side.ToString(), Value = ex.Side.ToString()
});
}
ViewBag.sides = new SelectList(list, "Value", "Text");
_newPatient = INewPatient.GetPatientByPatId(Convert.ToInt32(id));
ViewBag.PatientName = _newPatient.PatientName;
_newPatient.Action = "edit";
_newPatient.Actuator = actuator;
if (HttpContext.Session.GetString("UserType") == ConstantsVar.Admin.ToString() || HttpContext.Session.GetString("UserType") == ConstantsVar.Support.ToString())
{
List <User> _userProviderlist = lIUserRepository.getUserListByType(ConstantsVar.Provider);
var ObjList = _userProviderlist.Select(r => new SelectListItem
{
Value = r.UserId.ToString(),
Text = r.Name
});
ViewBag.Provider = new SelectList(ObjList, "Value", "Text");
}
List <User> _userTherapistlist = lIUserRepository.getUserListByType(ConstantsVar.Therapist);
var ObjListTherapist = _userTherapistlist.Select(r => new SelectListItem
{
Value = r.UserId.ToString(),
Text = r.Name
});
ViewBag.Therapist = new SelectList(ObjListTherapist, "Value", "Text");
List <User> _patientAdministratorlist = lIUserRepository.getUserListByType(ConstantsVar.PatientAdministrator);
var ObjListPatientAdmin = _patientAdministratorlist.Select(r => new SelectListItem
{
Value = r.UserId.ToString(),
Text = r.Name
});
ViewBag.PatientAdministrator = new SelectList(ObjListPatientAdmin, "Value", "Text");
_newPatient.returnView = "review";
lmodel.Patient = _newPatient;
}
else if (!string.IsNullOrEmpty(actuator) && !string.IsNullOrEmpty(tab) && tab == "Rx")
{
NewPatientWithProtocol newPatientWithProtocol = new NewPatientWithProtocol();
List <EquipmentExcercise> EquipmentExcerciselist = Utilities.GetEquipmentExcercise();
List <ExcerciseProtocol> ExcerciseProtocollist = Utilities.GetExcerciseProtocol();
newPatientWithProtocol.NewPatientRXList = new List <NewPatientRx>();
List <PatientRx> PatientRx = null;
ViewBag.Action = "edit";
PatientRx = INewPatient.GetNewPatientRxByPatId(id.ToString());
if (PatientRx != null && PatientRx.Count > 0)
{
foreach (PatientRx patRx in PatientRx)
{
ViewBag.EquipmentType = patRx.EquipmentType;
ViewBag.PatientName = patRx.Patient.PatientName;
ViewBag.SurgeryDate = patRx.Patient.SurgeryDate;
EquipmentExcercise EquipmentExcercise = EquipmentExcerciselist.Where(p => p.Limb.ToLower() == patRx.EquipmentType.ToLower() && p.ExcerciseEnum == patRx.DeviceConfiguration).FirstOrDefault();
ExcerciseProtocol ExcerciseProtocol = ExcerciseProtocollist.Where(p => p.Limb == patRx.EquipmentType && p.ExcerciseEnum == patRx.DeviceConfiguration).Distinct().FirstOrDefault();
NewPatientRx _NewPatientRx = new NewPatientRx();
_NewPatientRx.Action = "edit";
DeviceCalibration ldeviceCalibration = lIDeviceCalibrationRepository.getDeviceCalibrationByRxID(patRx.RxId);
if (patRx.EquipmentType.ToLower() == "shoulder")
{
if (patRx.DeviceConfiguration == "Forward Flexion")
{
_NewPatientRx.HeadingFlexion = "Degree of Flexion";
_NewPatientRx.CurrentFlex = Constants.Sh_Flex_Current;
_NewPatientRx.GoalFlex = Constants.Sh_Flex_Goal;
_NewPatientRx.Flex_Current_Start = Constants.Sh_Flex_Current;
_NewPatientRx.Flex_Current_End = Constants.Sh_Flex_Goal;
_NewPatientRx.Flex_Goal_Start = Constants.Sh_Flex_Current;
_NewPatientRx.Flex_Goal_End = Constants.Sh_Flex_Goal;
}
if (patRx.DeviceConfiguration == "External Rotation")
{
_NewPatientRx.HeadingFlexion = "Degree of External Rotation";
_NewPatientRx.CurrentFlex = Constants.Sh_ExRot_Current;
_NewPatientRx.GoalFlex = Constants.Sh_ExRot_Goal;
_NewPatientRx.Flex_Current_Start = Constants.Sh_ExRot_Current;
_NewPatientRx.Flex_Current_End = Constants.Sh_ExRot_Goal;
_NewPatientRx.Flex_Goal_Start = Constants.Sh_ExRot_Current;
_NewPatientRx.Flex_Goal_End = Constants.Sh_ExRot_Goal;
}
}
else if (patRx.EquipmentType.ToLower() == "ankle")
{
_NewPatientRx.HeadingFlexion = "Degree of Flexion";
_NewPatientRx.HeadingExtension = "Degree of Extension";
_NewPatientRx.CurrentFlex = Constants.Ankle_Flex_Current;
_NewPatientRx.GoalFlex = Constants.Ankle_Flex_Goal;
_NewPatientRx.CurrentExten = Constants.Ankle_Ext_Current;
_NewPatientRx.GoalExten = Constants.Ankle_Ext_Goal;
_NewPatientRx.Flex_Current_Start = Constants.Ankle_Flex_Current;
_NewPatientRx.Flex_Current_End = Constants.Ankle_Flex_Goal;
_NewPatientRx.Flex_Goal_Start = Constants.Ankle_Flex_Current;
_NewPatientRx.Flex_Goal_End = Constants.Ankle_Flex_Goal;
_NewPatientRx.Ext_Current_Start = Constants.Ankle_Ext_Current;
_NewPatientRx.Ext_Current_End = Constants.Ankle_Ext_Goal;
_NewPatientRx.Ext_Goal_Start = Constants.Ankle_Ext_Current;
_NewPatientRx.Ext_Goal_End = Constants.Ankle_Ext_Goal;
}
else
{
_NewPatientRx.HeadingFlexion = "Degree of Flexion";
_NewPatientRx.HeadingExtension = "Degree of Extension";
_NewPatientRx.CurrentFlex = Constants.Knee_Flex_Current;
_NewPatientRx.GoalFlex = Constants.Knee_Flex_Goal;
_NewPatientRx.CurrentExten = Constants.Knee_Ext_Current;
_NewPatientRx.GoalExten = Constants.Knee_Ext_Goal;
_NewPatientRx.Flex_Current_Start = Constants.Knee_Flex_Current_Start;
_NewPatientRx.Flex_Current_End = Constants.Knee_Flex_Current_End;
_NewPatientRx.Flex_Goal_Start = Constants.Knee_Flex_Goal_Start;
_NewPatientRx.Flex_Goal_End = (ldeviceCalibration != null && ldeviceCalibration.Actuator2ExtendedAngle != null) ? Convert.ToInt32(ldeviceCalibration.Actuator2ExtendedAngle) : Constants.Knee_Flex_Goal_End;
_NewPatientRx.Ext_Current_Start = Constants.Knee_Ext_Current_Start;
_NewPatientRx.Ext_Current_End = Constants.Knee_Ext_Current_End;
_NewPatientRx.Ext_Goal_Start = Constants.Knee_Ext_Goal_Start;
_NewPatientRx.Ext_Goal_End = (ldeviceCalibration != null && ldeviceCalibration.Actuator2RetractedAngle != null) ? Convert.ToInt32(ldeviceCalibration.Actuator2RetractedAngle) : Constants.Knee_Ext_Goal_End;
}
_NewPatientRx.TherapyType = EquipmentExcercise.ExcerciseName;
_NewPatientRx.DeviceConfiguration = EquipmentExcercise.ExcerciseEnum;
_NewPatientRx.ProtocolEnum = ExcerciseProtocol.ProtocolEnum;
_NewPatientRx.ProtocolName = ExcerciseProtocol.ProtocolName;
_NewPatientRx.EquipmentType = patRx.EquipmentType;
_NewPatientRx.RxId = patRx.RxId;
_NewPatientRx.RxDaysPerweek = patRx.RxDaysPerweek;
_NewPatientRx.RxSessionsPerWeek = patRx.RxSessionsPerWeek;
_NewPatientRx.RxStartDate = patRx.RxStartDate;
_NewPatientRx.RxEndDate = patRx.RxEndDate;
_NewPatientRx.ProviderId = patRx.ProviderId;
_NewPatientRx.PatientId = patRx.PatientId;
_NewPatientRx.CurrentExtension = patRx.CurrentExtension;
_NewPatientRx.CurrentFlexion = patRx.CurrentFlexion;
_NewPatientRx.GoalExtension = patRx.GoalExtension;
_NewPatientRx.GoalFlexion = patRx.GoalFlexion;
_NewPatientRx.PainThreshold = patRx.PainThreshold;
_NewPatientRx.RateOfChange = patRx.RateOfChange;
newPatientWithProtocol.PainThreshold = patRx.PainThreshold;
newPatientWithProtocol.RateOfChange = patRx.RateOfChange;
newPatientWithProtocol.NewPatientRXList.Add(_NewPatientRx);
}
}
newPatientWithProtocol.returnView = "Rx";
lmodel.Rx = newPatientWithProtocol;
}
else if (!string.IsNullOrEmpty(actuator) && !string.IsNullOrEmpty(tab) && tab == "Exercises")
{
ViewBag.PatientName = Username;
List <NewProtocol> _result = INewPatient.GetProtocolListBypatId(id.ToString());
ViewBag.VisibleAddButton = false;
ViewBag.VisibleAddButtonExt = false;
if (!string.IsNullOrEmpty(equipmentType))
{
if (equipmentType.ToLower() == "shoulder")
{
PatientConfiguration lconfig = lIPatientConfigurationRepository.getPatientConfigurationbyPatientId(id, equipmentType, "Forward Flexion");
if (lconfig != null)
{
ViewBag.VisibleAddButton = true;
if (_result != null)
{
List <NewProtocol> _resultFlex = _result.Where(x => x.ExcerciseEnum == "Forward Flexion").ToList();
if (_resultFlex == null || (_resultFlex != null && _resultFlex.Count == 0))
{
ViewBag.RxId = lconfig.RxId;
}
}
}
PatientConfiguration lconfigext = lIPatientConfigurationRepository.getPatientConfigurationbyPatientId(Convert.ToInt32(id), equipmentType, "External Rotation");
if (lconfigext != null)
{
ViewBag.VisibleAddButtonExt = true;
if (_result != null)
{
List <NewProtocol> _resultExt = _result.Where(x => x.ExcerciseEnum == "External Rotation").ToList();
if (_resultExt == null || (_resultExt != null && _resultExt.Count == 0))
{
ViewBag.RxIdExt = lconfig.RxId;
}
}
}
}
else
{
PatientConfiguration lconfig = lIPatientConfigurationRepository.getPatientConfigurationbyPatientId(Convert.ToInt32(id), equipmentType);
if (lconfig != null)
{
ViewBag.VisibleAddButton = true;
if (_result == null || (_result != null && _result.Count == 0))
{
ViewBag.RxId = lconfig.RxId;
}
else
{
ViewBag.RxId = _result[0].RxId;
}
}
}
}
ViewBag.ProtocolList = _result;
ViewBag.etype = equipmentType;
if (String.IsNullOrEmpty(Username))
{
ViewBag.PatientName = Username;
}
if (_result != null && _result.Count > 0 && String.IsNullOrEmpty(Username))
{
ViewBag.PatientName = _result[0].PatientName;
}
lmodel.Exercises = _result;
}
else if (!string.IsNullOrEmpty(actuator) && !string.IsNullOrEmpty(tab) && tab == "Sessions")
{
if (!String.IsNullOrEmpty(id.ToString()))
{
ViewBag.actuator = actuator;
ViewBag.EquipmentType = equipmentType;
ViewBag.patientId = id;
ViewBag.PatientName = Username;
HttpContext.Session.SetString("PatientID", id.ToString());
}
if (string.IsNullOrEmpty(actuator) && !string.IsNullOrEmpty(equipmentType))
{
if (equipmentType.ToLower() == "shoulder")
{
actuator = "Forward Flexion";
}
else
{
actuator = "Flexion-Extension";
}
ViewBag.actuator = actuator;
}
logger.LogDebug("Pain Post Start");
if (!String.IsNullOrEmpty(Username))
{
HttpContext.Session.SetString("PatientName", Username);
}
if (HttpContext.Session.GetString("PatientName") != null && HttpContext.Session.GetString("PatientName").ToString() != "")
{
if (!String.IsNullOrEmpty(Username))
{
ViewBag.PatientName = HttpContext.Session.GetString("PatientName").ToString();
}
}
List <UserSession> pSession = new List <UserSession>();
HttpContext.Session.SetString("ProtocolName", "");
HttpContext.Session.SetString("ProtocoloId", "");
if (!String.IsNullOrEmpty(Username) && !String.IsNullOrEmpty(id.ToString()))
{
pSession = lISessionInterface.getSessionList(id.ToString(), actuator);
}
else
{
if (String.IsNullOrEmpty(Username) && String.IsNullOrEmpty(id.ToString()) && HttpContext.Session.GetString("UserId") != null && HttpContext.Session.GetString("UserType") != null && HttpContext.Session.GetString("UserType").ToString() == "2")
{
pSession = lISessionInterface.getSessionListByTherapistId(HttpContext.Session.GetString("UserId"));
}
else
{
pSession = lISessionInterface.getSessionList();
}
}
if (pSession != null && pSession.Count > 0)
{
lmodel.Sessions = pSession;
ViewBag.SessionList = pSession;
}
}
else if (!string.IsNullOrEmpty(actuator) && !string.IsNullOrEmpty(tab) && tab == "History")
{
ViewBag.History = lIAppointmentScheduleRepository.getAppointmentListByPatientId(Convert.ToInt32(id), HttpContext.Session.GetString("timezoneid"));
}
else if (!string.IsNullOrEmpty(actuator) && !string.IsNullOrEmpty(tab) && tab == "Messages")
{
Patient lpatient = IPatient.GetPatientByPatientID(id);
if (lpatient != null)
{
List <MessageView> lmessages = lIMessageRepository.getMessagesbyTimeZone(lpatient.PatientLoginId, HttpContext.Session.GetString("UserId"), HttpContext.Session.GetString("timezoneid"));
ViewBag.PatientId = lpatient.PatientLoginId;
ViewBag.Messages = lmessages.OrderBy(x => x.Datetime);
}
}
else if (!string.IsNullOrEmpty(actuator) && !string.IsNullOrEmpty(tab) && tab == "PatientReviews")
{
List <PatientReviewTab> lPatientReviews = new List <PatientReviewTab>();
try
{
if (!string.IsNullOrEmpty(HttpContext.Session.GetString("UserId")))
{
ViewBag.lPatientReviews = lIPatientReviewRepository.GetPatientReviewListTab(ViewBag.User);
lmodel.PatientReviews = lPatientReviews;
}
else
{
ViewBag.lPatientReviews = lIPatientReviewRepository.GetPatientReviewList();
lmodel.PatientReviews = ViewBag.lPatientReviews;
}
}
catch (Exception ex)
{
logger.LogDebug("Patient Review Error: " + ex);
return(View());
}
}
return(View(lmodel));
}
catch (Exception ex)
{
logger.LogDebug("Error: " + ex);
return(View(null));
}
}
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") }));
}
}
public JsonResult checkdevicecalibration([FromBody] CheckDeviceCalibration pDeviceCalibration, string sessionid)
{
ErrorResponse error = new ErrorResponse();
var response = new Dictionary <string, object>();
try
{
logger.LogDebug("Check Device calibration 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 pdevice = lIDeviceCalibrationRepository.getDeviceCalibrationbyControllerId(pDeviceCalibration.ControllerId);
if (pdevice != null)
{
if (string.IsNullOrEmpty(pDeviceCalibration.BoomId3))
{
if (!string.IsNullOrEmpty(pDeviceCalibration.EquipmentType) && !string.IsNullOrEmpty(pDeviceCalibration.DeviceConfiguration) && !string.IsNullOrEmpty(pDeviceCalibration.PatientSide) && !string.IsNullOrEmpty(pDeviceCalibration.ChairId) && !string.IsNullOrEmpty(pDeviceCalibration.BoomId1) && !string.IsNullOrEmpty(pDeviceCalibration.BoomId2))
{
pdevice = lIDeviceCalibrationRepository.getDeviceCalibrationbyCEDPCB1B2(pDeviceCalibration.ControllerId, pDeviceCalibration.EquipmentType, pDeviceCalibration.DeviceConfiguration, pDeviceCalibration.PatientSide, pDeviceCalibration.ChairId, pDeviceCalibration.BoomId1, pDeviceCalibration.BoomId2);
if (pdevice != null)
{
return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration Information- Same setup being re-calibrated", usecasecode = 2, setupid = pdevice.SetupId, TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
}
else if (string.IsNullOrEmpty(pDeviceCalibration.BoomId3) && string.IsNullOrEmpty(pDeviceCalibration.BoomId2))
{
if (!string.IsNullOrEmpty(pDeviceCalibration.EquipmentType) && !string.IsNullOrEmpty(pDeviceCalibration.DeviceConfiguration) && !string.IsNullOrEmpty(pDeviceCalibration.PatientSide) && !string.IsNullOrEmpty(pDeviceCalibration.ChairId) && !string.IsNullOrEmpty(pDeviceCalibration.BoomId1))
{
pdevice = lIDeviceCalibrationRepository.getDeviceCalibrationbyCEDPCB1(pDeviceCalibration.ControllerId, pDeviceCalibration.EquipmentType, pDeviceCalibration.DeviceConfiguration, pDeviceCalibration.PatientSide, pDeviceCalibration.ChairId, pDeviceCalibration.BoomId1);
if (pdevice != null)
{
return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration Information- Same setup being re-calibrated", usecasecode = 2, setupid = pdevice.SetupId, TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
}
else
{
if (!string.IsNullOrEmpty(pDeviceCalibration.EquipmentType) && !string.IsNullOrEmpty(pDeviceCalibration.DeviceConfiguration) && !string.IsNullOrEmpty(pDeviceCalibration.PatientSide) && !string.IsNullOrEmpty(pDeviceCalibration.ChairId) && !string.IsNullOrEmpty(pDeviceCalibration.BoomId1) && !string.IsNullOrEmpty(pDeviceCalibration.BoomId2) && !string.IsNullOrEmpty(pDeviceCalibration.BoomId3))
{
pdevice = lIDeviceCalibrationRepository.getDeviceCalibrationbyCEDPCB1B2B3(pDeviceCalibration.ControllerId, pDeviceCalibration.EquipmentType, pDeviceCalibration.DeviceConfiguration, pDeviceCalibration.PatientSide, pDeviceCalibration.ChairId, pDeviceCalibration.BoomId1, pDeviceCalibration.BoomId2, pDeviceCalibration.BoomId3);
if (pdevice != null)
{
return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration Information- Same setup being re-calibrated", usecasecode = 2, setupid = pdevice.SetupId, TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
}
if (!string.IsNullOrEmpty(pDeviceCalibration.EquipmentType) && !string.IsNullOrEmpty(pDeviceCalibration.DeviceConfiguration) && !string.IsNullOrEmpty(pDeviceCalibration.PatientSide))
{
pdevice = lIDeviceCalibrationRepository.getDeviceCalibrationbyCEDP(pDeviceCalibration.ControllerId, pDeviceCalibration.EquipmentType, pDeviceCalibration.DeviceConfiguration, pDeviceCalibration.PatientSide);
if (pdevice != null)
{
return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration Information - Same setup, minor faulty component other than controller replaced", usecasecode = 3, setupid = pdevice.SetupId, TimeZone = DateTime.UtcNow.ToString("s") }));
}
else
{
return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration Information - The controller is being configured for a different type of exercise or limb with or without the same minor components", usecasecode = 4, setupid = "", TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
}
else
{
if (!string.IsNullOrEmpty(pDeviceCalibration.EquipmentType) && !string.IsNullOrEmpty(pDeviceCalibration.DeviceConfiguration) && !string.IsNullOrEmpty(pDeviceCalibration.PatientSide) && !string.IsNullOrEmpty(pDeviceCalibration.ChairId))
{
pdevice = lIDeviceCalibrationRepository.getDeviceCalibrationbyEDPC(pDeviceCalibration.EquipmentType, pDeviceCalibration.DeviceConfiguration, pDeviceCalibration.PatientSide, pDeviceCalibration.ChairId);
if (pdevice != null)
{
return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration Information - New Controller replaced in an existing Device Calibration of same type", usecasecode = 5, setupid = pdevice.SetupId, TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
if (!string.IsNullOrEmpty(pDeviceCalibration.EquipmentType) && !string.IsNullOrEmpty(pDeviceCalibration.DeviceConfiguration) && !string.IsNullOrEmpty(pDeviceCalibration.PatientSide) && !string.IsNullOrEmpty(pDeviceCalibration.BoomId1))
{
pdevice = lIDeviceCalibrationRepository.getDeviceCalibrationbyEDPB1(pDeviceCalibration.EquipmentType, pDeviceCalibration.DeviceConfiguration, pDeviceCalibration.PatientSide, pDeviceCalibration.BoomId1);
if (pdevice != null)
{
return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration Information - New Controller replaced in an existing Device Calibration of same type", usecasecode = 5, setupid = pdevice.SetupId, TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
if (!string.IsNullOrEmpty(pDeviceCalibration.EquipmentType) && !string.IsNullOrEmpty(pDeviceCalibration.DeviceConfiguration) && !string.IsNullOrEmpty(pDeviceCalibration.PatientSide) && !string.IsNullOrEmpty(pDeviceCalibration.BoomId2))
{
pdevice = lIDeviceCalibrationRepository.getDeviceCalibrationbyEDPB2(pDeviceCalibration.EquipmentType, pDeviceCalibration.DeviceConfiguration, pDeviceCalibration.PatientSide, pDeviceCalibration.BoomId2);
if (pdevice != null)
{
return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration Information - New Controller replaced in an existing Device Calibration of same type", usecasecode = 5, setupid = pdevice.SetupId, TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
if (!string.IsNullOrEmpty(pDeviceCalibration.EquipmentType) && !string.IsNullOrEmpty(pDeviceCalibration.DeviceConfiguration) && !string.IsNullOrEmpty(pDeviceCalibration.PatientSide) && !string.IsNullOrEmpty(pDeviceCalibration.BoomId3))
{
pdevice = lIDeviceCalibrationRepository.getDeviceCalibrationbyEDPB3(pDeviceCalibration.EquipmentType, pDeviceCalibration.DeviceConfiguration, pDeviceCalibration.PatientSide, pDeviceCalibration.BoomId3);
if (pdevice != null)
{
return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration Information - New Controller replaced in an existing Device Calibration of same type", usecasecode = 5, setupid = pdevice.SetupId, TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
if (!string.IsNullOrEmpty(pDeviceCalibration.EquipmentType) && !string.IsNullOrEmpty(pDeviceCalibration.DeviceConfiguration) && !string.IsNullOrEmpty(pDeviceCalibration.PatientSide) && !string.IsNullOrEmpty(pDeviceCalibration.ChairId) && !string.IsNullOrEmpty(pDeviceCalibration.BoomId1) && !string.IsNullOrEmpty(pDeviceCalibration.BoomId2) && !string.IsNullOrEmpty(pDeviceCalibration.BoomId3))
{
pdevice = lIDeviceCalibrationRepository.getDeviceCalibrationbyEDPCB1B2B3(pDeviceCalibration.EquipmentType, pDeviceCalibration.DeviceConfiguration, pDeviceCalibration.PatientSide, pDeviceCalibration.ChairId, pDeviceCalibration.BoomId1, pDeviceCalibration.BoomId2, pDeviceCalibration.BoomId3);
if (pdevice != null)
{
return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration Information -New Controller replaced in an existing Device Calibration of same type", usecasecode = 5, setupid = pdevice.SetupId, TimeZone = DateTime.UtcNow.ToString("s") }));
}
else
{
return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration Information - Considered complete new Setup", usecasecode = 1, setupid = "", TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
else if (!string.IsNullOrEmpty(pDeviceCalibration.EquipmentType) && !string.IsNullOrEmpty(pDeviceCalibration.DeviceConfiguration) && !string.IsNullOrEmpty(pDeviceCalibration.PatientSide) && !string.IsNullOrEmpty(pDeviceCalibration.ChairId) && !string.IsNullOrEmpty(pDeviceCalibration.BoomId1) && !string.IsNullOrEmpty(pDeviceCalibration.BoomId2))
{
pdevice = lIDeviceCalibrationRepository.getDeviceCalibrationbyEDPCB1B2(pDeviceCalibration.EquipmentType, pDeviceCalibration.DeviceConfiguration, pDeviceCalibration.PatientSide, pDeviceCalibration.ChairId, pDeviceCalibration.BoomId1, pDeviceCalibration.BoomId2);
if (pdevice != null)
{
return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration Information - New Controller replaced in an existing Device Calibration of same type", usecasecode = 5, setupid = pdevice.SetupId, TimeZone = DateTime.UtcNow.ToString("s") }));
}
else
{
return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration Information - Considered complete new Setup", usecasecode = 1, setupid = "", TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
else if (!string.IsNullOrEmpty(pDeviceCalibration.EquipmentType) && !string.IsNullOrEmpty(pDeviceCalibration.DeviceConfiguration) && !string.IsNullOrEmpty(pDeviceCalibration.PatientSide) && !string.IsNullOrEmpty(pDeviceCalibration.ChairId) && !string.IsNullOrEmpty(pDeviceCalibration.BoomId1))
{
pdevice = lIDeviceCalibrationRepository.getDeviceCalibrationbyEDPCB1(pDeviceCalibration.EquipmentType, pDeviceCalibration.DeviceConfiguration, pDeviceCalibration.PatientSide, pDeviceCalibration.ChairId, pDeviceCalibration.BoomId1);
if (pdevice != null)
{
return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration Information - New Controller replaced in an existing Device Calibration of same type", usecasecode = 5, setupid = pdevice.SetupId, TimeZone = DateTime.UtcNow.ToString("s") }));
}
else
{
return(Json(new { Status = (int)HttpStatusCode.OK, result = "Device Calibration Information - Considered complete new Setup", usecasecode = 1, 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 Request is null", TimeZone = DateTime.UtcNow.ToString("s") }));
}
}
catch (Exception ex)
{
return(Json(new { Status = (int)HttpStatusCode.InternalServerError, result = "Get Device Calibration failed", TimeZone = DateTime.UtcNow.ToString("s") }));
}
return(Json(new { Status = (int)HttpStatusCode.Created, result = "Device Calibration Input not valid", 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") }));
}
}
public static IWidget[] ResolveWidgetsForScope(IRUSDevice scopeDevice, BusyObject busy)
{
if (_models.ContainsKey(scopeDevice))
{
throw new InvalidOperationException("Only one set of widgets per scope is allowed");
}
using (var core = new DICore())
{
registerBasicServices();
instantiateWidgets();
var widgets = core.Container.ResolveAll <IWidget>().ToArray();
_allWidgets.AddRange(widgets.Select(w => new WidgetInfo(w, scopeDevice)));
_models[scopeDevice] = core.Container.TryResolveAll <IDeviceHandler>()?.ToList() ?? new List <IDeviceHandler>();
return(widgets);
void registerBasicServices()
{
core.Container.Register(scopeDevice);
core.Container.Register(scopeDevice.Name); // We're registering string. Dont be confused
core.Container.Register(busy);
}
void instantiateWidgets()
{
var instantiator = core.InstantiationStrategy;
var instantiationCoroutines = widgetsFactory(core.Container).ToArray();
instantiator.ExecuteCoroutines(instantiationCoroutines);
}
}
//////////////////////////////////////
IEnumerable <IEnumerator <ResolutionStepResult> > widgetsFactory(IDIContainer container)
{
string dataViewScope = nameof(dataViewScope);
string flashDumpViewScope = nameof(flashDumpViewScope);
yield return(injectExporters(container, dataViewScope));
yield return(DeviceInitialization.InstantiationCoroutine(dataViewScope, container));
yield return(DeviceFiles.InstantiationCoroutine(dataViewScope, container));
yield return(DeviceStatus.InstantiationCoroutine(dataViewScope, container));
yield return(DataRequest.InstantiationCoroutine(dataViewScope, container));
yield return(DataView.InstantiationCoroutine("Данные", dataViewScope, container));
foreach (var command in getCommands(scopeDevice, busy))
{
if (command == Command.DOWNLOAD_FLASH && Command.DOWNLOAD_FLASH.GetInfo().IsSupportedForDevice(scopeDevice.Id))
{
yield return(FlashUploadCommand.InstantiationCoroutine(flashDumpViewScope, container));
}
yield return(DeviceCommand.InstantiationCoroutine(command, dataViewScope, container));
}
foreach (var calibrator in getCalibrators(scopeDevice, new FileSaver(scopeDevice.Id, FileExtensionFactory.Instance).SaveCalibrationFileAsync, busy).ToArray())
{
yield return(DeviceCalibration.InstantiationCoroutine(calibrator, dataViewScope, container));
yield return(injectCalibrationWidgets(container, calibrator));
}
foreach (var widget in deviceSpecificWidgetsFactory())
{
yield return(widget);
}
yield return(DataViewSettings.InstantiationCoroutine(false, dataViewScope, container));
IEnumerable <IEnumerator <ResolutionStepResult> > deviceSpecificWidgetsFactory()
{
if (scopeDevice.Id.IsOneOf(RUSDeviceId.RUS_TECHNOLOGICAL_MODULE, RUSDeviceId.RUS_MODULE, RUSDeviceId.EMC_MODULE))
{
yield return(FlashDumpLoad.InstantiationCoroutine(flashDumpViewScope, container));
yield return(DataView.InstantiationCoroutine("Данные дампа Flash", flashDumpViewScope, container));
yield return(DataViewSettings.InstantiationCoroutine(true, flashDumpViewScope, container));
yield return(injectExporters(container, flashDumpViewScope));
}
if (scopeDevice.Id.IsOneOf(RUSDeviceId.RUS_MODULE))
{
yield return(RUSModuleSetDirection.InstantiationCoroutine(dataViewScope, container));
yield return(RUSTelemetryStreamSender.InstantiationCoroutine(dataViewScope, container));
}
}
}
}
