public ActionResult InsertFamily(ReferralViewModel newReferral)
{
if (!newReferral.client.insertFamilyComplete)
{
// Check if guardian has been entered into family list, adds if not.
if (!newReferral.client.guardian.isGuardian)
{
// Marks family member as guardian.
newReferral.client.guardian.isGuardian = true;
// Adds guardian's home address to client's address.
newReferral.client.clientAddress = newReferral.client.guardian.familyAddress;
// Adds home number to client's main phone.
newReferral.client.phone = newReferral.client.guardian.familyContact.Find(c => c.additionalContactInfoTypeID == 1);
// Adds guardian to client object's family list.
newReferral.client.clientFamily.Add(newReferral.client.guardian);
}
// Marks client object as insert family completed.
newReferral.client.insertFamilyComplete = true;
// Returns updated client object to Session.
Session["client"] = newReferral.client;
// Calls method to insert client if all insert properties are true.
InsertNewClient(newReferral.client);
}
return(PartialView("_FamilyPartial", newReferral));
}
public JsonResult Refer(ReferralViewModel refer)
{
if (refer.postedFile != null)
{
string path = Server.MapPath("~/Uploads/");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string filename = Path.GetFileName(refer.postedFile.FileName);
refer.postedFile.SaveAs(path + filename);
refer.ResumeID = referService.Resume(filename);
ViewBag.Message = " and Resume uploaded";
}
else
{
ViewBag.Message = " with no resume";
}
bool trial = referService.Referring(refer);
if (trial)
{
ViewBag.Message = "Candidate referred" + ViewBag.Message;
return(Json(new { success = true, message = ViewBag.Message }));
}
else
{
ViewBag.Message = "Failed";
return(Json(new { success = false, message = ViewBag.Message }));
}
}
//
// GET: /PartnerPortal/Referral/Details/5
public ActionResult Details(long referralID)
{
var model = new ReferralViewModel(referralID);
ViewBag.SelectStatus = model.Status;
return(View(model));
}
/// <summary>
/// Updates referral
/// </summary>
/// <param name="referral">referral model</param>
/// <returns></returns>
public Response <ReferralViewModel> UpdateReferral(ReferralViewModel referral)
{
const string apiUrl = baseRoute + "UpdateReferral";
var response = communicationManager.Put <ReferralModel, Response <ReferralModel> >(referral.ToModel(), apiUrl);
return(response.ToViewModel());
}
/// <summary>
/// Convert ReferralViewModel ViewModel to ReferralModel Model
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static ReferralModel ToModel(this ReferralViewModel model)
{
if (model == null)
{
return(null);
}
var entity = new ReferralModel
{
ReferralID = model.ReferralID,
ReferralName = model.ReferralName,
ReferralOrganization = model.ReferralOrganization,
ReferralCategoryID = model.ReferralCategoryID,
ReferralSourceID = model.ReferralSourceID,
ReferralOriginID = model.ReferralOriginID,
ReferralProgramID = model.ReferralProgramID,
ReferralClosureReasonID = model.ReferralClosureReasonID,
ReferralConcern = model.ReferralConcern,
ContactName = model.ContactName,
Organization = model.Organization,
ReferredDate = model.ReferredDate,
ReferralContactID = model.ReferralContactID,
ContactID = model.ContactID,
ProgramName = model.ProgramName,
ModifiedOn = model.ModifiedOn
};
return(entity);
}
public static ReferralViewModel LoadReferral()
{
ReferralViewModel objReferral = new ReferralViewModel();
objReferral.Clinics = LoadClinics();
objReferral.Wards = LoadWards();
objReferral.CHW = CurrentCHW();
return(objReferral);
}
private void PopulateDropDowns(ReferralViewModel viewModel)
{
//for (int i=2000; i< 2019; i++)
//{
// viewModel.DOBYear = i;
//}
viewModel.localAuthorities = _context.LocalAuthority.ToList();
viewModel.genders = _context.Gender.ToList();
viewModel.statuses = _context.Status.ToList();
viewModel.archiveReasons = _context.ArchiveReason.ToList();
}
// GET: Referral/Create
public IActionResult Create()
{
ReferralViewModel viewModel = new ReferralViewModel();
viewModel.ReferralReceivedDate = DateTime.Now;
//set initial status to 'Under Consideration By Service'
viewModel.ReferralStatusId = 6;
//newref.ReferralSuitableColor = "red";
PopulateDropDowns(viewModel);
return(View(viewModel));
}
/// <summary>
/// Inserts additional client detail information to the new client in session.
/// </summary>
/// <param name="newReferral"></param>
/// <returns>Partial view with client and referral objects.</returns>
public ActionResult InsertClientDetails(ReferralViewModel newReferral)
{
if (!newReferral.client.insertClientDetailsComplete)
{
// Marks client object as insert client completed.
newReferral.client.insertClientDetailsComplete = true;
// Returns updated client object to Session.
Session["client"] = newReferral.client;
// Calls method to insert client if all insert properties are true.
InsertNewClient(newReferral.client);
}
return(PartialView("_ClientDetailsPartial", newReferral));
}
/// <summary>
/// Convert ReferralContactModel Model to ReferralContactViewModel ViewModel
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public static ReferralContactViewModel ToViewModel(this ReferralContactModel entity)
{
if (entity == null)
{
return(null);
}
var model = new ReferralViewModel
{
ReferralID = entity.ReferralID,
ReferralContactID = entity.ReferralContactID,
ContactID = entity.ContactID,
ModifiedOn = entity.ModifiedOn
};
return(model);
}
/// <summary>
/// Controller that interfaces withe the view to return data received from the database.
/// </summary>
public ActionResult Referral()
{
ReferralViewModel view = new ReferralViewModel()
{
client = new Client(),
referral = new Referral()
};
if (Session["client"] != null)
{
// Clears session of current client.
Session["client"] = view.client;
}
GetAllLists();
return(View(view));
}
public ActionResult InsertReferralDetails(ReferralViewModel newReferral)
{
if (!newReferral.referral.insertReferralDetailsComplete)
{
// Assigns client in session to a client object.
Client newClient = new Client();
if (Session["client"] != null)
{
newClient = (Client)Session["client"];
}
if (newReferral.referral.insertReferralMainComplete)
{
// Updates the client's referral to include the new referral details.
var thisReferral = newClient.clientReferrals.FindIndex(r => r.insertReferralMainComplete);
// Inserts the referral details.
newClient.clientReferrals[thisReferral] = newReferral.referral;
// Marks insert of referral Details as complete.
newClient.clientReferrals[thisReferral].insertReferralDetailsComplete = true;
// Marks entire referral object as complete on the client object.
newClient.insertReferralComplete = true;
}
else
{
newReferral.referral.insertReferralDetailsComplete = true;
newClient.clientReferrals.Add(newReferral.referral);
}
// Returns updated client object to Session.
Session["client"] = newClient;
// Calls method to insert client if all insert properties are true.
InsertNewClient(newClient);
}
return(PartialView("_ReferralDetailsPartial", newReferral));
}
// GET: Referral/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
Referral model = await _context.Referral.FindAsync(id);
if (model == null)
{
return(NotFound());
}
ReferralViewModel viewModel = new ReferralViewModel();
_mapper.Map(model, viewModel);
PopulateDropDowns(viewModel);
return(View(viewModel));
}
public ActionResult AddReferral(ReferralViewModel referralViewModel)
{
if (ModelState.IsValid)
{
db.Referral_V2s.Add(new Referral_v2
{
referral_Doctors_Name = referralViewModel.referral_Doctors_Name,
referral_doctor_Add = referralViewModel.referral_doctor_Add,
referral_doctor_num = referralViewModel.referral_doctor_num,
referral_doctor_Email = referralViewModel.referral_doctor_Email,
PatientName = referralViewModel.PatientName,
PatientID = referralViewModel.PatientID,
refferal_Date = referralViewModel.refferal_Date,
referral_ValidDate = referralViewModel.referral_ValidDate,
refferal_Location = referralViewModel.refferal_Location,
referral_Reasoning = referralViewModel.referral_Reasoning
});
db.SaveChanges();
return(RedirectToAction("Index", "Referral_v2"));
}
return(View(referralViewModel));
}
public ActionResult InsertReferral(ReferralViewModel newReferral)
{
Client newClient = new Client();
newClient = (Client)Session["client"];
if (newClient.clientReferrals != null)
{
var thisReferral = newClient.clientReferrals.FindIndex(r => r.insertReferralDetailsComplete);
newClient.clientReferrals[thisReferral] = newReferral.referral;
// Marks client object as insert referral completed.
newReferral.referral.insertReferralMainComplete = true;
// Adds new referral object to the client object.
newClient.clientReferrals.Add(newReferral.referral);
// Marks entire referral as entry complete.
newClient.insertReferralComplete = true;
}
else
{
newReferral.referral.insertReferralMainComplete = true;
newClient.clientReferrals.Add(newReferral.referral);
}
// Returns updated client to session.
Session["client"] = newClient;
// Calls method to insert client if all insert properties are true.
InsertNewClient(newReferral.client);
// Gets list again for view.
GetAllLists();
return(PartialView("_ReferralPartial", newReferral));
}
public async Task <IActionResult> Referral(ReferralViewModel model)
{
var validationResult = SignupValidator.Validate((SignupViewModel)model);
if (!validationResult.IsValid)
{
return(Json(new { Status = false, Messages = validationResult.Messages }));
}
if (!Guid.TryParse(model.Code, out Guid code))
{
return(Json(new { Status = false, Messages = new List <string> {
"Invalid referral code."
} }));
}
var referral = ReferralService.Get(code);
if (referral == null)
{
return(Json(new { Status = false, Messages = new List <string> {
"Invalid referral code."
} }));
}
var userModel = await UserService.CreateUser(new CreateUserModel
{
ConfirmPassword = model.ConfirmPassword,
Email = model.Email,
Password = model.Password,
Roles = new List <string> {
Roles.User
},
Username = model.Username
});
return(Json(new { Status = true }));
}
public ActionResult Referal()
{
UserRepository userDetails = new UserRepository();
List <ReferralViewModel> referralViewModels = new List <ReferralViewModel>();
if (User.Identity.Name == null)
{
return(RedirectToAction("SignIn", "User"));
}
List <Referral> referrals = hotelDetails.GetCandidateDetails(User.Identity.Name);
foreach (var referral in referrals)
{
ReferralViewModel referralViewModel = AutoMapper.Mapper.Map <Referral, ReferralViewModel>(referral);
referralViewModels.Add(referralViewModel);
}
UserReferralViewModel userReferralViewModel = new UserReferralViewModel();
User user = userDetails.GetUserDetailByName(User.Identity.Name);
userReferralViewModel.UserViewModel = AutoMapper.Mapper.Map <User, UserViewModel>(user);
userReferralViewModel.ReferralViewModels = referralViewModels;
return(View(userReferralViewModel));
}
public bool Referring(ReferralViewModel item)
{
try
{
Referral x = new Referral();
History backup = new History();
//When candidate is referred, entry updation in ReferralTable and HistoryTable
backup.CandidateName = x.CandidateName = item.FirstName + " " + item.MiddleName + " " + item.LastName;
backup.EmployeeID = x.EmployeeID = item.EmployeeID;
backup.JobID = x.JobID = item.JobID;
backup.Email = x.Email = item.Email;
backup.PhoneNumber = x.PhoneNumber = item.PhoneNumber;
backup.Date = x.ReferDate = DateTime.Now;
backup.StatusID = 1;
x.StatusID = 1;
x.Experience = item.Experience;
x.Location = item.Location;
x.ResumeID = item.ResumeID;
backup.DOB = x.DOB = item.DOB;
//x.DOB and backup.DOB not yet provided
db.Referrals.Add(x);
db.SaveChanges();
backup.ReferralID = x.ReferralID;
db.Histories.Add(backup);
db.SaveChanges();
return(true);
}
catch (Exception e)
{
return(false);
}
}
public async Task <IActionResult> Referral(string code)
{
var model = new ReferralViewModel {
Code = code, CodeIsValid = true
};
if (!Guid.TryParse(code, out Guid referralCode))
{
model.CodeIsValid = false;
return(View(code));
}
var referral = await ReferralService.Get(referralCode);
if (referral == null)
{
model.CodeIsValid = false;
return(View(model));
}
model.Email = referral.Email;
return(View(model));
}
public Response <ReferralViewModel> UpdateReferral(ReferralViewModel referral)
{
return(referralRepository.UpdateReferral(referral));
}
public Response <ReferralViewModel> AddReferral(ReferralViewModel referral)
{
return(referralRepository.AddReferral(referral));
}
public async Task <IActionResult> Create(ReferralViewModel viewModel)
{
if (ModelState.IsValid)
{
Referral model = new Referral();
_mapper.Map(viewModel, model);
if (viewModel.ReferralArchiveReasonId == 0)
{
model.ReferralArchiveReasonId = null;
}
_context.Add(model);
await _context.SaveChangesAsync();
// referral.ReferralSuitable = true;
if (model.ReferralSuitableColor == "green")
{
model.ReferralArchiveReasonId = null;
model.ReferralSuitable = true;
return(RedirectToAction("Create", "Submissions", new { id = model.ReferralId }));
}
else
{
//set referral status to Archive
model.ReferralStatusId = 8;
model.ReferralSuitable = false;
var archive = new ArchiveReferral[]
{
new ArchiveReferral {
ArchiveReferralName = model.ReferralName,
ArchiveReferralGenderId = model.ReferralGenderId,
ArchiveReferralLocalAuthorityId = model.ReferralLocalAuthorityId,
ArchiveReferralReceivedDate = model.ReferralReceivedDate,
ArchiveReferralAge = model.ReferralAge,
ArchiveReferralComments = model.ReferralComments,
ArchiveReferralStatusId = model.ReferralStatusId,
ArchiveReferralSuitable = model.ReferralSuitable,
ArchiveReferralArchiveReasonId = model.ReferralArchiveReasonId,
ArchiveReferralSuitableComments = model.ReferralSuitableComments,
ArchiveReferralNotSuitableComments = model.ReferralNotSuitableComments
}
};
foreach (ArchiveReferral g in archive)
{
try
{
_context.ArchiveReferral.Add(g);
_context.SaveChanges();
}
catch (Exception)
{
throw;
}
}
}
return(RedirectToAction("Index", "Referrals"));
}
return(RedirectToAction("Index", "Referrals"));
}
public async Task <IActionResult> Edit(int id, ReferralViewModel viewModel)
{
if (id != viewModel.ReferralId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
if (viewModel.ReferralSuitableColor == "green")
{
viewModel.ReferralSuitable = true;
}
else
{
viewModel.ReferralSuitable = false;
}
Referral model = await _context.Referral.FindAsync(id);
_mapper.Map(viewModel, model);
_context.Update(model);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ReferralExists(viewModel.ReferralId))
{
return(NotFound());
}
else
{
throw;
}
}
if (viewModel.ReferralSuitable == true)
{
// referral.ReferralSuitable = true;
viewModel.ReferralStatusId = 5;
return(RedirectToAction("Index", "Referrals"));
}
else
{
return(RedirectToAction("Index", "Referrals"));
}
}
// If offer is made///
if (viewModel.ReferralStatusId == 7)
{
var occupancy = new Occupancy[]
{
new Occupancy {
OccupancyRefId = viewModel.ReferralName,
OccupancyPlacementStartDate = viewModel.ReferralPlacementStartDate,
OccupancyDOB = viewModel.ReferralDOB,
OccupancyGenderId = viewModel.ReferralGenderId,
OccupancyLocalAuthorityId = viewModel.ReferralLocalAuthorityId
}
};
foreach (Occupancy g in occupancy)
{
try
{
_context.Occupancy.Add(g);
_context.SaveChanges();
}
catch (Exception)
{
throw;
}
//try
//{
// referral.ReferralStatusId = 8;
// referral.ReferralArchiveReasonId
// // var delref = await _context.Referral.FindAsync(id);
// // _context.Referral.Remove(delref);
// await _context.SaveChangesAsync();
// return RedirectToAction(nameof(Index));
//}
//catch (Exception)
//{
// throw;
//}
}
_context.Update(viewModel);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
//If Referal is archived///
if (viewModel.ReferralStatusId == 8)
{
var archive = new ArchiveReferral[]
{
new ArchiveReferral {
ArchiveReferralName = viewModel.ReferralName,
ArchiveReferralGenderId = viewModel.ReferralGenderId,
ArchiveReferralLocalAuthorityId = viewModel.ReferralLocalAuthorityId,
ArchiveReferralReceivedDate = viewModel.ReferralReceivedDate,
ArchiveReferralAge = viewModel.ReferralAge,
ArchiveReferralComments = viewModel.ReferralComments,
ArchiveReferralStatusId = viewModel.ReferralStatusId,
ArchiveReferralSuitable = viewModel.ReferralSuitable,
ArchiveReferralArchiveReasonId = viewModel.ReferralArchiveReasonId,
ArchiveReferralSuitableComments = viewModel.ReferralSuitableComments,
ArchiveReferralNotSuitableComments = viewModel.ReferralNotSuitableComments,
ArchiveReferralType = viewModel.ReferralType
}
};
foreach (ArchiveReferral g in archive)
{
try
{
_context.ArchiveReferral.Add(g);
_context.SaveChanges();
}
catch (Exception)
{
throw;
}
}
try
{
var delref = await _context.Referral.FindAsync(id);
_context.Referral.Remove(delref);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (Exception)
{
throw;
}
}
//return View(referral);
return(RedirectToAction(nameof(Index)));
}
public ActionResult SubmitReferral(ReferralViewModel referral)
{
try
{
using (var connection = AppUtils.GetOpenConnection())
{
//Insert CHW
CHW chw = referral.CHW;
string sql = @"INSERT INTO CHW (HouseholdIdNumber,Name) VALUES";
sql += "(@HouseholdIdNumber, @Name)";
Dapper.SqlMapper.Execute(connection, sql, chw);
//Insert Clinic
Clinic clinic = referral.Clinic;
sql = @"INSERT INTO clinic (ClinicDescription,Active) VALUES";
sql += "(@ClinicDescription, @Active)";
Dapper.SqlMapper.Execute(connection, sql, clinic);
//Insert Ward
Ward ward = referral.Ward;
sql = @"INSERT INTO Ward (HouseholdIdNumber,Name) VALUES";
sql += "(@HouseholdIdNumber, @Name)";
Dapper.SqlMapper.Execute(connection, sql, ward);
//Insert House
Referral objReferral = referral.Referral;
sql = @"INSERT INTO Referrals (VisitId,ReferralReasonId,ReferralOutcome,ReferredTo,BackReferralReceived) VALUES";
sql += "(@Visit.Id,@ReferralReason.Id,@ReferralOutcome,@ReferredTo,@BackReferralReceived)";
Dapper.SqlMapper.Execute(connection, sql, objReferral);
//Insert IndividualMember
IndividualMember individualMember = referral.Member;
sql = @"INSERT INTO IndividualMember (HouseholdId,VisitId,NextOfKinId,RelationshipStatusId,Name,DOB,Age,Gender,Tel,BirthWeight,ReceivingGrant,Head) VALUES";
sql += "(@Household.Id,@Visit.Id,@NextOfKin.Id,@RelationshipStatus.Id,@Name,@DOB,@Age,@Gender,@Tel,@BirthWeight,@ReceivingGrant,@Head)";
Dapper.SqlMapper.Execute(connection, sql, individualMember);
//Insert Question
foreach (var question in referral.Questions)
{
sql = @"INSERT INTO Questions (QuestionCategoryId,QuestionDescription,Active) VALUES";
sql += "(@QuestionCategory.Id,@QuestionDescription,@Active)";
Dapper.SqlMapper.Execute(connection, sql, question);
}
}
return(RedirectToAction("Index", "Home"));
}
catch
{
return(PartialView("_CreateReferralForm"));
}
}
