/// <summary>
/// Method to add BloodGroup - SS
/// </summary>
/// <param name="name">name of BloodGroup</param>
/// <param name="instituteId">institute id</param>
/// <returns>message</returns>
public async Task <SharedLookUpResponse> AddBloodGroupAsync(AddBloodGroupManagementAc addBloodGroup, int instituteId)
{
if (!await _iMSDbContext.BloodGroups.AnyAsync(x => x.InstituteId == instituteId && x.Code.ToLowerInvariant() == addBloodGroup.Code.ToLowerInvariant()))
{
var bloodGroup = new BloodGroup()
{
CreatedOn = DateTime.UtcNow,
InstituteId = instituteId,
Name = addBloodGroup.Name,
Code = addBloodGroup.Code,
Description = addBloodGroup.Description,
Status = true
};
_iMSDbContext.BloodGroups.Add(bloodGroup);
await _iMSDbContext.SaveChangesAsync();
return(new SharedLookUpResponse()
{
HasError = false, Message = "Blood group added successfully"
});
}
else
{
return new SharedLookUpResponse()
{
HasError = true, ErrorType = SharedLookUpResponseType.Code, Message = "Blood group with the same code is already exist"
}
};
}
public async Task <BloodGroup> AddBloodGroupAsync(BloodGroup bloodgroup)
{
await Conn.InsertAsync(bloodgroup);
bloodgroup.SerialNo = Conn.LastInsertId();
return(bloodgroup);
}
public JsonResult Add(BloodGroup bg)
{
MTSHRDataLayer.BloodGroup data_bloodgroup = new MTSHRDataLayer.BloodGroup();
int result = data_bloodgroup.Create(bg.Blood_Group);
return(Json(new { success = result }, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Create(DonationEventInputModel viewModel, RequestInfoViewModel model)
{
var userDonorId = this.userManager.GetUserId(this.User);
var hospitalDataId = model.HospitalDataId != null ? model.HospitalDataId : viewModel.HospitalId;
if (hospitalDataId == null)
{
return(this.RedirectToAction("HttpStatusCodeHandler", "Error", this.NotFound()));
}
double neededQuantity = model.NeededQuantity;
double quantity = viewModel.Quantity;
BloodGroup bloodGroup = viewModel.BloodGroup;
RhesusFactor rhesusFactor = viewModel.RhesusFactor;
await this.donationEventsService
.CreateDonation(
hospitalDataId,
userDonorId,
neededQuantity,
quantity,
bloodGroup,
rhesusFactor);
return(this.RedirectToAction("QAndA", "Home"));
}
public async Task CreateDonation(
string requestOrHospitalId,
string userDonorId,
double neededQuantity,
double quantity,
BloodGroup bloodGroup,
RhesusFactor rhesusFactor)
{
var donorData = this.donorDataUserRepository.All()
.FirstOrDefault(ddu => ddu.ApplicationUserId == userDonorId);
if (donorData == null)
{
throw new ArgumentException(GlobalConstants.NoDonorDataErrorMessage);
}
var request = this.requestRepository.All()
.FirstOrDefault(r => r.Id == requestOrHospitalId);
var hospitalData = this.hospitalDataUserRepository.All()
.FirstOrDefault(hd =>
request != null ?
hd.Id == request.HospitalId : hd.Id == requestOrHospitalId);
if (hospitalData == null)
{
throw new ArgumentException(GlobalConstants.NoHospitalDataErrorMessage);
}
var bloodBank = this.bloodBankRepository.All()
.FirstOrDefault(bbk => bbk.HospitalDataId == hospitalData.Id);
var bag = this.bloodBagRepository.All()
.FirstOrDefault(bg => bg.BloodBankId == bloodBank.Id);
var donationEvent = new DonationEvent
{
DateOfDonation = DateTime.UtcNow,
RequestId = request != null ? requestOrHospitalId : null,
UserDonorId = userDonorId,
};
await this.donationEventRepository.AddAsync(donationEvent);
await this.donationEventRepository.SaveChangesAsync();
bag = new BloodBag
{
Quantity = quantity != 0 ? quantity : neededQuantity,
CollectionDate = DateTime.UtcNow,
DonorDataId = donorData.Id,
BloodGroup = bloodGroup,
RhesusFactor = rhesusFactor,
BloodBankId = bloodBank.Id,
};
await this.bloodBagRepository.AddAsync(bag);
await this.bloodBagRepository.SaveChangesAsync();
}
public async Task <IActionResult> Edit(int id, BloodGroup bloodGroup)
{
if (id != bloodGroup.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(bloodGroup);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BloodGroupExists(bloodGroup.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(bloodGroup));
}
public override int GetHashCode()
{
int hash = 1;
if (Name.Length != 0)
{
hash ^= Name.GetHashCode();
}
if (MatricNo.Length != 0)
{
hash ^= MatricNo.GetHashCode();
}
if (School.Length != 0)
{
hash ^= School.GetHashCode();
}
if (BloodGroup.Length != 0)
{
hash ^= BloodGroup.GetHashCode();
}
if (Programme.Length != 0)
{
hash ^= Programme.GetHashCode();
}
if (ProfilePicture.Length != 0)
{
hash ^= ProfilePicture.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
private void btnAdd_Click(object sender, EventArgs e)
{
try
{
if (string.IsNullOrWhiteSpace(tbxBlood.Text))
{
errorProviderBlood.SetError(tbxBlood, "Enter Blood Type");
return;
}
else
{
BloodGroup bloodGroup = new BloodGroup
{
Value = tbxBlood.Text
};
db.BloodGroups.Add(bloodGroup);
db.SaveChanges();
updateInfo();
clearTxt();
}
}
catch (Exception ex)
{
MessageBox.Show("Please try again after 2 minutes!");
File.AppendAllText(path, "\n" + ex + ":" + DateTime.Now);
return;
}
}
partial void BloodGroups_Inserting(BloodGroup entity)
{
entity.InsertDate = DateTime.Now;
entity.InsertUser = Application.User.Name;
entity.UpdateDate = DateTime.Now;
entity.UpdateUser = Application.User.Name;
}
public Patient(string username, string password, string name, string parentName, string surname, Gender gender, string jmbg, string identityCard,
string healthInsuranceCard, BloodGroup bloodGroup, DateTime dateOfBirth, string contactNumber, string emailAddress, City city, bool guestAccount)
: base(username, password, name, parentName, surname, gender, jmbg, identityCard, healthInsuranceCard, bloodGroup, dateOfBirth, contactNumber, emailAddress, city)
{
GuestAccount = guestAccount;
}
public async Task <BloodGroup> SaveBloodGroupAsync(BloodGroup bloodgroup)
{
using (var txScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
if (bloodgroup.IsNew)
{
await AddBloodGroupAsync(bloodgroup);
}
else
{
await UpdateBloodGroupAsync(bloodgroup);
}
// One To One
if (bloodgroup.Patient != null)
{
if (bloodgroup.Patient.IsDeleted)
{
var id = bloodgroup.Patient.PatientID;
await Conn.DeleteByIdAsync <Patient>(id);
}
else if (!bloodgroup.Patient.IsDeleted)
{
var patient = bloodgroup.Patient;
patient.PatientID = bloodgroup.SerialNo;
await Conn.SaveAsync(patient);
}
}
txScope.Complete();
}
return(bloodgroup);
}
public bool Insert(BloodGroup newBloodGroup)
{
using (MySqlHealthContext ctx = new MySqlHealthContext())
{
ctx.BloodGroups.Add(newBloodGroup);
return(ctx.SaveChanges() > -1);
}
}
public ActionResult DeleteConfirmed(int id)
{
BloodGroup bloodGroup = db.BloodGroups.Find(id);
db.BloodGroups.Remove(bloodGroup);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "id,Name")] BloodGroup BloodGroup)
{
if (ModelState.IsValid)
{
db.Update(BloodGroup);
return(RedirectToAction("Index"));
}
return(View(BloodGroup));
}
public async Task AddRecipientAsync(
string userHospitalId,
string firstName,
string middleName,
string lastName,
int age,
double neededQuantity,
EmergencyStatus recipientEmergency,
BloodGroup bloodGroup,
RhesusFactor rhesusFactor)
{
var hospitalData = this.hospitalDataRepository.All()
.FirstOrDefault(uhd => uhd.ApplicationUserId == userHospitalId);
if (hospitalData == null)
{
throw new ArgumentException(GlobalConstants.NoHospitalDataErrorMessage);
}
if (firstName == null ||
middleName == null ||
lastName == null ||
age == 0 ||
neededQuantity == 0)
{
throw new ArgumentException(GlobalConstants.NotFullRecipientDataErrorMessage);
}
var recipient = new Recipient
{
FirstName = firstName,
MiddleName = middleName,
LastName = lastName,
Age = age,
NeededQuantity = neededQuantity,
RecipientEmergency = recipientEmergency,
BloodGroup = bloodGroup,
RhesusFactor = rhesusFactor,
};
var recipientHospitalData = new RecipientHospitalData
{
HospitalDataId = hospitalData.Id,
RecipientId = recipient.Id,
};
recipient.HospitalDataId = recipientHospitalData.HospitalDataId;
await this.recipientsRepository.AddAsync(recipient);
await this.recipientsRepository.SaveChangesAsync();
await this.recipientHospitalDataRepository.AddAsync(recipientHospitalData);
await this.recipientHospitalDataRepository.SaveChangesAsync();
}
public async Task <string> CreateRequestAsync(
string userId,
string content,
DateTime publishedOn,
EmergencyStatus emergencyStatus,
BloodGroup bloodGroup,
RhesusFactor rhesusFactor,
double neededQuantity)
{
if (neededQuantity == 0)
{
throw new ArgumentException(GlobalConstants.NoQuantityErrrorMessage);
}
var hospitalData = this.hospitalDataRepository.All()
.Where(hd => hd.ApplicationUserId == userId)
.FirstOrDefault();
if (hospitalData == null)
{
throw new ArgumentException(GlobalConstants.NoHospitalDataErrorMessage);
}
var location = this.locationDataRepository.All()
.FirstOrDefault(l => l.Id == hospitalData.LocationId);
var request = new Request
{
HospitalName = hospitalData.Name,
Content = content,
PublishedOn = publishedOn,
EmergencyStatus = emergencyStatus,
BloodGroup = bloodGroup,
RhesusFactor = rhesusFactor,
NeededQuantity = neededQuantity,
Location = location,
};
request.HospitalId = hospitalData.Id;
await this.requestsRepository.AddAsync(request);
await this.requestsRepository.SaveChangesAsync();
var userHospital = new HospitalDataRequest
{
HospitalDataId = hospitalData.Id,
RequestId = request.Id,
};
await this.requestsHospitalDataRepository.AddAsync(userHospital);
await this.requestsHospitalDataRepository.SaveChangesAsync();
return(request.Id);
}
public ActionResult Edit([Bind(Include = "Id,Name")] BloodGroup bloodGroup)
{
if (ModelState.IsValid)
{
db.Entry(bloodGroup).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(bloodGroup));
}
//-----ADD BLOODGROUP------//
public void AddNewBloodGroup(BloodGroup bloodgroup)
{
List <SqlParameter> parameters = new List <SqlParameter>
{
new SqlParameter("@bgname", bloodgroup.BloodGroupName),
new SqlParameter("@Action", "INSERT")
};
dBConnectionOp.ExecuteNonQuery("BloodGroupSP", parameters);
}
public void Create(BloodGroupViewModel bloodGroupVM)
{
var BloodGroup = new BloodGroup
{
BloodGroupName = bloodGroupVM.BloodGroupName
};
unitOfWork.BloodGroupRepository.Insert(BloodGroup);
unitOfWork.Save();
}
public void Delete(int id)
{
var BloodGroup = new BloodGroup
{
BloodGroupId = id
};
unitOfWork.BloodGroupRepository.Delete(BloodGroup);
unitOfWork.Save();
}
public ActionResult Delete(int id = 0)
{
BloodGroup user = db.GetById(id);
if (user == null)
{
return(HttpNotFound());
}
return(View(user));
}
public ActionResult Create([Bind(Include = "Name")] BloodGroup BloodGroup)
{
if (ModelState.IsValid)
{
db.Add(BloodGroup);
return(RedirectToAction("Index"));
}
return(View(BloodGroup));
}
public bool Delete(long id)
{
BloodGroup singleDelete = GetSingle(id);
if (singleDelete != null)
{
return(bpo.Delete(singleDelete));
}
return(false);
}
public ActionResult Details(int id = 0)
{
BloodGroup Gender = db.GetById(id);
if (Gender == null)
{
return(HttpNotFound());
}
return(View(Gender));
}
private void CreateCatBloodGroupTableData()
{
foreach (string cat in CatBloodGroup.GetCatagoryList())
{
BloodGroup catagory = new BloodGroup();
catagory.BloodGroupCode = cat;
catagory.Name = cat;
SaveBloodGroup(catagory);
}
}
public ActionResult AddNewBloodGroup([FromBody] BloodGroup bloodgroup)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_BLOODGROUPDAL.AddNewBloodGroup(bloodgroup);
return(Ok());
}
private void SaveBloodGroup(BloodGroup group)
{
BloodGroup blood = db.BloodGroups.Find(group.BloodGroupCode);
if (blood == null)
{
db.BloodGroups.Add(group);
db.SaveChanges();
}
}
public ActionResult Delete(int id)
{
using (HISDBEntities db = new HISDBEntities())
{
BloodGroup bg = db.BloodGroups.Where(x => x.GroupID == id).FirstOrDefault <BloodGroup>();
db.BloodGroups.Remove(bg);
db.SaveChanges();
return(Json(new { success = true, message = "Deleted Successfully" }, JsonRequestBehavior.AllowGet));
}
}
public async Task <IActionResult> Create(BloodGroup bloodGroup)
{
if (ModelState.IsValid)
{
_context.Add(bloodGroup);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(bloodGroup));
}
public ActionResult Create([Bind(Include = "Id,Name")] BloodGroup bloodGroup)
{
if (ModelState.IsValid)
{
db.BloodGroups.Add(bloodGroup);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(bloodGroup));
}
public bool update(long id, BloodGroup bp)
{
BloodGroup singleDelete = GetSingle(id);
if (singleDelete != null)
{
singleDelete.Bloodgroupname = bp.Bloodgroupname;
return(bpo.Update(singleDelete));
}
return(false);
}
public Patient(string nme, BloodGroup bg)
{
Name = nme;
Blood = bg;
}
