public SurgeryPresenter(ISurgeryView view)
{
surgeryView = view;
surgeryModel = new SurgeryModel();
wardModel = new WardModel();
patientRegModel = new PatientRegistrationModel();
}
public static async Task <bool> AddWard(WardModel ward)
{
String SQL = "INSERT INTO Ward(Name, DoctorID)" +
"VALUES('" + ward.Name + "','" + ward.DoctorID + "')";
using (SqlConnection dbConn = new SqlConnection(connectionString))
{
try
{
dbConn.Open();
SqlCommand cmd = new SqlCommand();
cmd.CommandType = CommandType.Text;
cmd.CommandText = SQL;
cmd.Connection = dbConn;
await cmd.ExecuteNonQueryAsync();
dbConn.Close();
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(false);
}
finally
{
dbConn.Close();
}
}
}//end of add
/// <summary>
/// Load xã
/// </summary>
/// <param name="districtID"></param>
/// <returns></returns>
public JsonResult LoadWard(int districtID)
{
var xmlDoc = XDocument.Load(Server.MapPath(@"~\Assets\client\data\Provinces_Data.xml"));
var xElements = xmlDoc.Descendants("Item").Where(x => x.Attribute("type").Value == "province").Descendants("Item").Where(x => x.Attribute("type").Value == "district" && x.Attribute("id").Value == districtID.ToString());
var lstDistrict = new List <WardModel>();
foreach (var item in xElements.Descendants("Item").Where(x => x.Attribute("type").Value == "precinct"))
{
WardModel p = new WardModel();
p.ID = int.Parse(item.Attribute("id").Value);
p.Name = item.Attribute("value").Value;
p.DistrictID = districtID;
lstDistrict.Add(p);
}
return(Json(new
{
// trả về 1 data chứa ds các tỉnh thành
data = lstDistrict,
status = true
}));
}
public async Task <ResponseModel> Delete(WardModel model)
{
ResponseModel response = new ResponseModel();
try
{
Ward md = await _context.WardRepository.FirstOrDefaultAsync(m => m.Id == model.Id);
if (!md.RowVersion.SequenceEqual(model.RowVersion))
{
response.ResponseStatus = Core.CommonModel.Enums.ResponseStatus.OutOfDateData;
return(response);
}
md.Deleted = true;
md.UpdateBy = base.UserId;
md.UpdateDate = DateTime.Now;
_context.WardRepository.Update(md);
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
throw ex;
}
return(response);
}
public AdmissionPresenter(IAdmissionView view)
{
admissionView = view;
admissionModel = new AdmissionModel();
patientRegModel = new PatientRegistrationModel();
wardModel = new WardModel();
}
public async Task <ActionResult <int> > CreateWard([FromBody] WardModel model)
{
//return Created($"{AppConstants.API_URL_PREFIX}/wards/", await Mediator.Send(new CreateWardCommand { Model = model }));
return(Ok(await Mediator.Send(new CreateWardCommand {
Model = model
})));
}
public async Task <ResponseModel> Insert(WardModel model)
{
ResponseModel response = new ResponseModel();
try
{
Ward md = new Ward();
md.Name = model.Name;
md.DistrictId = model.DistrictId;
md.ProvinceId = model.ProvinceId;
md.Precedence = model.Precedence;
md.IsActive = model.IsActive;
md.CreateBy = base.UserId;
md.CreateDate = DateTime.Now;
md.Deleted = false;
await _context.WardRepository.AddAsync(md).ConfigureAwait(true);
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
throw ex;
}
return(response);
}
public async Task <ResponseModel> UpdateAsync(WardModel wardModel)
{
var ward = await _context.Wards.FindAsync(wardModel.Id);
if (ward == null)
{
return(new ResponseModel()
{
code = ResponseCode.NOTFOUND,
description = "Ward can not be found"
});
}
ward.WardName = wardModel.WardName;
ward.ModifiedBy = wardModel.ModifiedBy;
ward.ModifiedDate = DateTimeOffset.Now;
int count = await _context.SaveChangesAsync();
if (count > 0)
{
return(new ResponseModel()
{
code = ResponseCode.SUCCESSFULL,
description = "Update is successful"
});
}
return(new ResponseModel()
{
code = ResponseCode.FAIL,
description = "No changes occurred"
});
}
//public static async Task<bool> UpdateWard(WardModel ward)
//{
// String SQL = "UPDATE Ward SET Name = @Name, DoctorID = @DocID WHERE ID = @ID";
// using (SqlConnection dbConn = new SqlConnection(connectionString))
// {
// try
// {
// dbConn.Open();
// SqlCommand cmd = new SqlCommand();
// cmd.CommandType = CommandType.Text;
// cmd.CommandText = SQL;
// cmd.Connection = dbConn;
// cmd.Parameters.AddWithValue("@Name", ward.Name);
// cmd.Parameters.AddWithValue("@disDate", ward.DoctorID);
// cmd.Parameters.AddWithValue("@disDate", ward.ID);
// await cmd.ExecuteNonQueryAsync();
// dbConn.Close();
// return true;
// }
// catch (Exception ex)
// {
// Console.WriteLine(ex);
// return false;
// }
// finally
// {
// dbConn.Close();
// }
// }
//}
public static async Task <bool> UpdateWard(WardModel ward)
{
String SQL = "UPDATE Ward SET Name = '" + ward.Name + "' WHERE ID = '" + ward.ID + "'";
using (SqlConnection dbConn = new SqlConnection(connectionString))
{
try
{
dbConn.Open();
SqlCommand cmd = new SqlCommand();
cmd.CommandType = CommandType.Text;
cmd.CommandText = SQL;
cmd.Connection = dbConn;
await cmd.ExecuteNonQueryAsync();
dbConn.Close();
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(false);
}
finally
{
dbConn.Close();
}
}
}//end of update
public async Task <ResponseModel> UpdateStatusAsync(WardModel wardModel)
{
var ward = await _context.Wards.FindAsync(wardModel.Id);
if (ward == null)
{
return(new ResponseModel()
{
code = ResponseCode.NOTFOUND,
description = "Ward can not be found"
});
}
ward.Status = wardModel.Status.ToString();
ward.ModifiedBy = wardModel.ModifiedBy;
ward.ModifiedDate = DateTimeOffset.Now;
int count = await _context.SaveChangesAsync();
if (count > 0)
{
return(new ResponseModel()
{
code = ResponseCode.SUCCESSFULL,
description = $"{wardModel.WardName} has been updated successfully"
});
}
return(new ResponseModel()
{
code = ResponseCode.FAIL,
description = "Update was not successful. Please try again or contact an administrator, if error persist"
});
}
private async Task <BaseResult> Update(District district, int updateBy = 0, string updateByUserName = "")
{
var result = new BaseResult()
{
Result = Result.Success
};
var districtForUpdate = _districtRepository.Query().FirstOrDefault(d => d.Id == district.Id);
if (districtForUpdate == null || district.Id <= 0)
{
result.Result = Result.Failed;
result.Message = "Không tìm thấy quận yêu cầu!";
return(result);
}
else
{
var city = _cityRepository.Query()
.AsNoTracking()
.FirstOrDefault(c => c.Id == district.ParentId);
var exists = _districtRepository.Query()
.Include(d => d.City)
.Any(c => !c.IsDeleted && c.City.Name == city.Name && c.Name == district.Name && c.Id != districtForUpdate.Id);
if (exists)
{
result.Result = Result.Failed;
result.Message = "Quận/Huyện đã tồn tại!";
return(result);
}
district.CityRealm = city.CityRealm;
district.Name = district.Name.Trim();
district.UnsignName = !string.IsNullOrEmpty(district.Name) ? district.Name.Unsigned() : "";
}
try
{
districtForUpdate = district.ToDistrict(districtForUpdate);
//Cập nhật thông tin chung của thực thể
districtForUpdate = districtForUpdate.UpdateCommonInt(updateBy, updateByUserName);
await _districtRepository.UpdateAsync(districtForUpdate);
var wards = _wardRepository.Query()
.Include(d => d.District)
.Where(d => d.ParentId == districtForUpdate.Id)
.ToList();
foreach (Ward w in wards)
{
WardModel ward = w.ToModel();
ward.CityRealm = districtForUpdate.CityRealm;
await _wardService.CreateOrUpdate(ward);
}
}
catch (Exception e)
{
result.Result = Result.SystemError;
result.Message = e.ToString();
}
return(result);
}
public async Task <bool> AddWardAsync(WardModel _ward)
{
_ward.WardId = new Guid();
_context.Wards.Add(_ward);
var saveResult = await _context.SaveChangesAsync();
return(saveResult == 1);
}
public async Task <bool> EditWardAsync(WardModel _ward)
{
var ward = await _context.Wards.FindAsync(_ward.WardId);
ward.WardName = _ward.WardName;
ward.WardCapacity = _ward.WardCapacity;
ward.WardCategory = ward.WardCategory;
var saveResult = await _context.SaveChangesAsync();
return(saveResult == 1);
}
public async Task <IHttpActionResult> GetWardDoc(WardModel ward)
{
var wards = await WardService.GetDocByWardID(ward);
if (wards.Count > 0)
{
return(Ok(wards));
}
else
{
return(BadRequest("No Doctor Available!"));
}
}
public async Task <IHttpActionResult> UpdateWard(WardModel ward)
{
if (ward == null)
{
return(BadRequest("Please provide valid inputs!"));
}
if (await WardService.UpdateWard(ward))
{
return(Ok("Ward Udpated Successfully!"));
}
else
{
return(BadRequest("Failed to Update Ward!"));
}
}
public async Task <IActionResult> AddW(WardModel _ward)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
var successful = await _hospitalAndWardService.AddWardAsync(_ward);
if (!successful)
{
return(BadRequest("Could not Add Ward"));
}
return(RedirectToAction("Index"));
}
public static async Task <List <WardModel> > GetDocByWardID(WardModel ward)
{
List <WardModel> wards = new List <WardModel>();
using (SqlConnection dbConn = new SqlConnection(connectionString))
{
var query = "select u.ID, CONCAT(u.Firstname, ' ' , u.Lastname) AS [Name] from [User] u " +
"join Ward w on w.DoctorID = u.ID " +
"where w.ID =" + ward.ID;
SqlDataReader reader;
try
{
dbConn.Open();
SqlCommand cmd = new SqlCommand(query, dbConn);
reader = await cmd.ExecuteReaderAsync();
if (reader.HasRows)
{
while (reader.Read())
{
WardModel wardItems = new WardModel();
//roomItems.ID = reader.GetInt32(0);
//roomItems.Name = reader.GetString(1);
wardItems.DocName = reader.GetString(1);
//wardItems.DoctorID = reader.GetInt32(2);
//roomItems.IsAvailable = reader.GetBoolean(3);
//roomItems.WardID = reader.GetInt32(2);
wards.Add(wardItems);
}
}
}
catch (Exception ex)
{
reader = null;
Console.WriteLine(ex);
}
finally
{
dbConn.Close();
}
return(wards);
}
}
public async Task <BaseResult> CreateOrUpdate(WardModel model, int updateBy = 0, string updateByUserName = "")
{
var ward = model.ToWard();
//Cập nhật thông tin chung của thực thể
ward = ward.UpdateCommonInt(updateBy, updateByUserName);
if (ward.Id > 0)
{
//Cập nhật
return(await Update(ward));
}
else
{
//Thêm mới
return(await Create(ward));
}
}
}//end of add
//public static async Task<bool> AddWard(WardModel ward)
//{
// String SQL = "INSERT INTO Ward(Name,DoctorID) VALUES(@Name,@DocID)";
// using (SqlConnection dbConn = new SqlConnection(connectionString))
// {
// try
// {
// dbConn.Open();
// SqlCommand cmd = new SqlCommand();
// cmd.CommandType = CommandType.Text;
// cmd.CommandText = SQL;
// cmd.Connection = dbConn;
// cmd.Parameters.AddWithValue("@Name", ward.Name);
// cmd.Parameters.AddWithValue("@DocID", ward.DoctorID);
// await cmd.ExecuteNonQueryAsync();
// dbConn.Close();
// return true;
// }
// catch (Exception ex)
// {
// Console.WriteLine(ex);
// return false;
// }
// finally
// {
// dbConn.Close();
// }
// }
//}
//fetch all the available doctors who havent been assigned to a ward
public static async Task <List <WardModel> > GetAvailableDoc()
{
List <WardModel> wards = new List <WardModel>();
using (SqlConnection dbConn = new SqlConnection(connectionString))
{
// var query = "SELECT * FROM [User] u LEFT JOIN Ward w on w.DoctorID = u.ID WHERE u.RoleID = 2 AND w.DoctorID IS NULL";
var query = "SELECT u.ID, CONCAT(u.Firstname, ' ', u.Lastname) As DoctorName FROM [User] u LEFT JOIN Ward w on w.DoctorID = u.ID WHERE u.RoleID = 2 AND w.DoctorID IS NULL";
SqlDataReader reader;
try
{
dbConn.Open();
SqlCommand cmd = new SqlCommand(query, dbConn);
reader = await cmd.ExecuteReaderAsync();
if (reader.HasRows)
{
while (reader.Read())
{
WardModel wardItems = new WardModel();
//the index is entered according to the query
wardItems.DocName = reader.GetString(1);
wardItems.DoctorID = reader.GetInt32(0);
wards.Add(wardItems);
}
}
}
catch (Exception ex)
{
reader = null;
Console.WriteLine(ex);
}
finally
{
dbConn.Close();
}
return(wards);
}
}
public static async Task <List <WardModel> > GetWards()
{
List <WardModel> wards = new List <WardModel>();
using (SqlConnection dbConn = new SqlConnection(connectionString))
{
var query = "Select * from Ward";
// var query = "SELECT u.Firstname FROM [User] INNER JOIN " +
// "Ward ON u.ID = Ward.DoctorID WHERE Room.IsAvailable = 1";
SqlDataReader reader;
try
{
dbConn.Open();
SqlCommand cmd = new SqlCommand(query, dbConn);
reader = await cmd.ExecuteReaderAsync();
if (reader.HasRows)
{
while (reader.Read())
{
WardModel wardItems = new WardModel();
wardItems.ID = reader.GetInt32(0);
wardItems.Name = reader.GetString(1);
wardItems.DoctorID = reader.GetInt32(2);
wards.Add(wardItems);
}
}
}
catch (Exception ex)
{
reader = null;
Console.WriteLine(ex);
}
finally
{
dbConn.Close();
}
return(wards);
}
}
public async Task <ResponseModel> AddAsync(WardModel wardModel)
{
Ward ward = _mapper.Map <Ward>(wardModel);
_context.Wards.Add(ward);
int count = await _context.SaveChangesAsync();
if (count > 0)
{
return(new ResponseModel()
{
code = ResponseCode.SUCCESSFULL,
description = $"{wardModel.WardName} has been updated successfully"
});
}
return(new ResponseModel()
{
code = ResponseCode.FAIL,
description = "Update was not successful. Please try again or contact an administrator, if error persist"
});
}
public ApiResult <List <WardModel> > LoadWard(int districtID)
{
var xElement = xmlDoc.Element("Root").Elements("Item").Elements("Item")
.Single(x => x.Attribute("type").Value == "district" && int.Parse(x.Attribute("id").Value) == districtID);
if (xElement == null)
{
return(new ApiErrorResult <List <WardModel> >("Không đọc được dữ liệu"));
}
var list = new List <WardModel>();
WardModel ward = null;
foreach (var item in xElement.Elements("Item").Where(x => x.Attribute("type").Value == "precinct"))
{
ward = new WardModel();
ward.ID = int.Parse(item.Attribute("id").Value);
ward.Name = item.Attribute("value").Value;
ward.DistrictId = int.Parse(xElement.Attribute("id").Value);
list.Add(ward);
}
return(new ApiSuccessResult <List <WardModel> >(list));
}
public JsonResult LoadWard(int districtID)
{
var xmlDoc = XDocument.Load(Server.MapPath(@"~/Assets/Client/data/Provinces_Data.xml"));
var xElement = xmlDoc.Element("Root").Elements("Item").Elements("Item")
.Single(x => x.Attribute("type").Value == "district" && int.Parse(x.Attribute("id").Value) == districtID);
var list = new List <WardModel>();
WardModel ward = null;
foreach (var item in xElement.Elements("Item").Where(x => x.Attribute("type").Value == "precinct"))
{
ward = new WardModel();
ward.ID = int.Parse(item.Attribute("id").Value);
ward.Name = item.Attribute("value").Value;
ward.DistrictID = int.Parse(xElement.Attribute("id").Value);
list.Add(ward);
}
return(Json(new
{
data = list,
status = true
}));
}
public static WardProduct DtToWardProduct(DataTable dt, string wardCode)
{
List <PatientRoomClass> items = new List <PatientRoomClass>();
List <string> listClass = new List <string>();
StaffReal staffReal = new StaffReal();
StaffData staffData = new StaffData();
DataTable dtStaffReal = new DataTable();
decimal sumStaffReal = 0;
decimal sumOfMulClass = 0;
decimal sumOfRealStaff = 0;
decimal percentage = 0;
decimal sumPatientKardex = 0;
decimal sumOfMulClassmulClsx100 = 0;
decimal sumPatientClass = 0;
// set value to object PatientRoomClass
foreach (DataRow row in dt.Rows)
{
int ptClass = 0;
var item = new PatientRoomClass();
Tuple <string, string> patient = GetData.PatientHnAdm(row["BED_RowID"].ToString());
string papmiNo = patient.Item1;
string epi = patient.Item2;
item.BED_RowID = row["BED_RowID"].ToString();
item.BED_Code = GetData.GetBedType(row["BED_RowID"].ToString()) + row["BED_Code"].ToString();
item.Paadm_AdmNo = epi;
sumPatientKardex += GetData.GetPatientKardex(epi);
item.Papmi_No = papmiNo;
item.PatientClass = GetData.GetPatientClass(papmiNo);
if (!string.IsNullOrEmpty(papmiNo))
{
sumPatientClass += 1;
}
if (Int32.TryParse(item.PatientClass, out ptClass))
{
listClass.Add(item.PatientClass);
}
if (item.PatientClass == null)
{
item.PatientClass = "??";
}
var reasonNotAvail = GetData.GetStatReasonNotAvail(row["BED_RowID"].ToString());
item.PatientClass = string.IsNullOrEmpty(reasonNotAvail) ? item.PatientClass : reasonNotAvail;
items.Add(item);
}
WardModel wardModel = new WardModel
{
PatientRoomClassList = items
};
string wardSql = string.Empty;
if (Data.MapWardCacheWithSql.TryGetValue(wardCode, out wardSql))
{
dtStaffReal = SqlServerDA.DataTableBindDataCommand(QueryString.GetRealStaffQueryString(wardSql, DateTime.Now), Constants.Svh21CHKConnectionString);
}
// set staff real to object StaffReal
foreach (DataRow row in dtStaffReal.Rows)
{
staffReal.DayRnReal = Convert.ToDecimal(row["DayRnReal"]);
staffReal.DayNrReal = Convert.ToDecimal(row["DayNrReal"]);
staffReal.EveRnReal = Convert.ToDecimal(row["EveRnReal"]);
staffReal.EveNrReal = Convert.ToDecimal(row["EveNrReal"]);
staffReal.NigRnReal = Convert.ToDecimal(row["NigRnReal"]);
staffReal.NigNrReal = Convert.ToDecimal(row["NigNrReal"]);
}
sumStaffReal = Calculate.SumStaffReal(staffReal);
string wardCase = string.Empty;
int add = 0;
if (wardCode.Contains("W"))
{
wardCase = "W";
Data.MapWardAdd.TryGetValue(wardCode, out add);
sumOfMulClass = Calculate.PatientClassCalc(listClass, wardCase, add);
sumOfMulClassmulClsx100 = Calculate.GetClsMul100(sumOfMulClass);
sumOfRealStaff = Calculate.GetSumOfRealStaff(sumStaffReal, wardCase);
percentage = Calculate.GetPercentag(sumOfMulClassmulClsx100, sumOfRealStaff);
staffData = Calculate.GetStaffData(sumOfMulClass, wardCase);
}
else if (wardCode.Contains("ICU"))
{
}
else if (wardCode.Contains("N"))
{
}
Staff staff = new Staff()
{
StaffReal = staffReal,
StaffData = staffData
};
WardCalculate wardCalc = new WardCalculate
{
WardPercentage = percentage,
NumPatientKardex = sumPatientKardex,
NumPatientClass = sumPatientClass
};
WardProduct result = new WardProduct
{
WardCode = wardCode,
WardModel = wardModel,
WardCalculate = wardCalc,
Staffs = staff
};
return(result);
}
public static Ward ToEntity(this WardModel model)
{
return(AutoMapperConfiguration.Mapper.Map <WardModel, Ward>(model));
}
public WardRegistrationPresenter(IWardRegistrationView view)
{
wardView = view;
wardModel = new WardModel();
}
public async Task <ResponseModel> Delete([FromBody] WardModel model)
{
var response = await _wardService.Delete(model);
return(response);
}
public static Ward ToEntity(this WardModel model, Ward destination)
{
return(AutoMapperConfiguration.Mapper.Map(model, destination));
}
public async Task <WardModel> FindWardAsync(Guid _wardId)
{
ward = await _context.Wards.FindAsync(_wardId);
return(ward);
}
public async Task <IActionResult> CreateOrUpdate([FromBody] WardModel ward)
{
var result = await _wardService.CreateOrUpdate(ward);
return(Ok(result));
}