public ActionResult Print(string id)
{
var intId = 0;
int.TryParse(id, out intId);
PrintPrescriptionModels viewModel = null;
try
{
IDiagnosisRepository diagnosisRepository = new DiagnosisRepository();
DTODiagnosis dtoDiagnosis = diagnosisRepository.GetDTODiagnosisById(intId);
ViewData["PatientTel"] = dtoDiagnosis.Patient_Tel;
IEnumerable <vMedicineDiagnosis> medicineRecords = objPrescription.GetPrescriptionDiagnosis(intId);
if (dtoDiagnosis == null)
{
return(RedirectToAction("Error404", "Error"));
}
viewModel = new PrintPrescriptionModels
{
dtoDiagnosis = dtoDiagnosis,
medicineRecords = medicineRecords
};
}
catch (Exception ex)
{
log.Error(ex);
ModelState.AddModelError("error", Translator.UnexpectedError);
}
return(View("Print", "_LayoutPrint", viewModel));
}
public ActionResult Detail(string id)
{
var intId = 0;
int.TryParse(id, out intId);
IEnumerable <DTODiagnosis> listDiagnosis = null;
try
{
IDiagnosisRepository diagnosisRepository = new DiagnosisRepository();
Patient patient = patientRepository.GetPatientById(intId);
if (patient == null)
{
return(RedirectToAction("Error404", "Error"));
}
else
{
listDiagnosis = diagnosisRepository.GetListDiagnosisByPatientId(intId);
var path = "/Uploads/default.jpg";
var fileName = patient.Id + ".jpg";
var savePath = Server.MapPath("~/Uploads/Patient/") + patient.Id;
// Check for Directory, If exist
if (Directory.Exists(savePath))
{
path = "/Uploads/Patient/" + patient.Id + "/" + fileName;
}
patient.Image = Common.ConcatHost(path);
patientModel = new PatientModels
{
patient = patient,
listDiagnosis = listDiagnosis
};
}
}
catch (Exception ex)
{
log.Error(ex);
ModelState.AddModelError("error", Translator.UnexpectedError);
}
return(View(patientModel));
}
public ActionResult Add()
{
var objSessionDiagnosis = Session["diagnosis"] as MyClinic.Infrastructure.Diagnosis;
if (objSessionDiagnosis == null)
{
return(RedirectToAction("Index", "Home"));
}
Patient patient = patientRepository.GetPatientById(objSessionDiagnosis.PatientId);
Disease disease = diseaseRepository.GetDiseaseById(objSessionDiagnosis.DiseaseId);
var itemAdd = new PrescriptionAdd();
IDiagnosisRepository diagnosisRepository = new DiagnosisRepository();
IMedicineTypeRepository objMedicineType = new MedicineTypeRepository();
//IEnumerable<MedicineType> medicineTypeRecords = null;
IMedicineTypeRepository medicineTypeRepository = new MedicineTypeRepository();
var usageSelectBox = medicineTypeRepository.GetUsageSelectBox();
ViewData["usageSelectBox"] = usageSelectBox;
PrescriptionModels viewModel = null;
try
{
IEnumerable <MedicineType> medicineTypeRecords = objMedicineType.Get();
viewModel = new PrescriptionModels
{
validAdd = itemAdd,
checkPost = false,
patient = patient,
disease = disease,
medicineTypeRecords = medicineTypeRecords
};
}
catch (Exception ex)
{
log.Error(ex);
ModelState.AddModelError("error", Translator.UnexpectedError);
}
return(View(viewModel));
}
public ActionResult Edit(string id)
{
var itemAdd = new PrescriptionAdd();
IDiagnosisRepository diagnosisRepository = new DiagnosisRepository();
IMedicineTypeRepository objMedicineType = new MedicineTypeRepository();
PrescriptionModels viewModel = null;
try
{
int intId = 0;
int.TryParse(id, out intId);
IEnumerable <MedicineType> medicineTypeRecords = objMedicineType.Get();
IEnumerable <Usage> usageRecords = objMedicineType.GetUsage();
DTODiagnosis dtoDiagnosis = diagnosisRepository.GetDTODiagnosisById(intId);
IEnumerable <vMedicineDiagnosis> medicineRecords = objPrescription.GetPrescriptionDiagnosis(intId);
IMedicineTypeRepository medicineTypeRepository = new MedicineTypeRepository();
var usageSelectBox = medicineTypeRepository.GetUsageSelectBox();
ViewData["usageSelectBox"] = usageSelectBox;
viewModel = new PrescriptionModels
{
validAdd = itemAdd,
checkPost = false,
dtoDiagnosis = dtoDiagnosis,
medicineTypeRecords = medicineTypeRecords,
medicineRecords = medicineRecords,
usageRecords = usageRecords,
};
}
catch (Exception ex)
{
log.Error(ex);
ModelState.AddModelError("error", Translator.UnexpectedError);
}
return(View(viewModel));
}
public DiagnosisService(DiagnosisRepository diagnosisRepository)
{
_diagnosisRepository = diagnosisRepository;
}
private void LoadRepositories()
{
userRepository = new UserRepository(new CSVStream <User>(userFile, new UserConverter()), new ComplexSequencer());
// USER OK
roomRepository = new RoomRepository(new CSVStream <Room>(roomFile, new RoomConverter()), new LongSequencer());
// ROOM OK
inventoryItemRepository = new InventoryItemRepository(new CSVStream <InventoryItem>(inventoryItemFile, new InventoryItemConverter()), new LongSequencer(), roomRepository);
timeTableRepository = new TimeTableRepository(new CSVStream <TimeTable>(timeTableFile, new TimeTableConverter()), new LongSequencer());
// TIMETABLE OK
hospitalRepository = new HospitalRepository(new CSVStream <Hospital>(hospitalFile, new HospitalConverter()), new LongSequencer(), roomRepository);
// HOSPITAL OK
secretaryRepository = new SecretaryRepository(new CSVStream <Secretary>(secretaryFile, new SecretaryConverter()), new ComplexSequencer(), timeTableRepository, hospitalRepository, userRepository);
// SECRETARY OK
managerRepository = new ManagerRepository(new CSVStream <Manager>(managerFile, new ManagerConverter()), new ComplexSequencer(), timeTableRepository, hospitalRepository, userRepository);
// MANAGER OK
doctorRepository = new DoctorRepository(new CSVStream <Doctor>(doctorFile, new DoctorConverter()), new ComplexSequencer(), timeTableRepository, hospitalRepository, roomRepository, userRepository);
// DOCTOR OK
patientRepository = new PatientRepository(new CSVStream <Patient>(patientFile, new PatientConverter()), new ComplexSequencer(), doctorRepository, userRepository);
// PATIENT OK
hospitalRepository.DoctorRepository = doctorRepository;
hospitalRepository.ManagerRepository = managerRepository;
hospitalRepository.SecretaryRepository = secretaryRepository;
//Misc repositories
locationRepository = new LocationRepository(new CSVStream <Location>(locationFile, new LocationConverter()), new LongSequencer());
// LOCATION OK
notificationRepository = new NotificationRepository(new CSVStream <Notification>(notificationFile, new NotificationConverter()), new LongSequencer(), patientRepository, doctorRepository, managerRepository, secretaryRepository);
// NOTIFICATION OK
messageRepository = new MessageRepository(new CSVStream <Message>(messageFile, new MessageConverter()), new LongSequencer(), patientRepository, doctorRepository, managerRepository, secretaryRepository);
// MESSAGE OK
articleRepository = new ArticleRepository(new CSVStream <Article>(articleFile, new ArticleConverter()), new LongSequencer(), doctorRepository, managerRepository, secretaryRepository);
//ARTICLE OK
questionRepository = new QuestionRepository(new CSVStream <Question>(questionFile, new QuestionConverter()), new LongSequencer());
// QUESTION OK
doctorQuestionRepository = new QuestionRepository(new CSVStream <Question>(doctorQuestionFile, new QuestionConverter()), new LongSequencer());
//DOCTOR QUESTION OK
feedbackRepository = new FeedbackRepository(new CSVStream <Feedback>(feedbackFile, new FeedbackConverter()), new LongSequencer(), questionRepository, patientRepository, doctorRepository, managerRepository, secretaryRepository);
doctorFeedbackRepository = new DoctorFeedbackRepository(new CSVStream <DoctorFeedback>(doctorFeedbackFile, new DoctorFeedbackConverter()), new LongSequencer(), doctorQuestionRepository, patientRepository, doctorRepository);
//Hospital management repositories
symptomRepository = new SymptomRepository(new CSVStream <Symptom>(symptomsFile, new SymptomConverter()), new LongSequencer());
//SYMPTOM REPO OK
diseaseRepository = new DiseaseRepository(new CSVStream <Disease>(diseaseFile, new DiseaseConverter()), new LongSequencer(), medicineRepository, symptomRepository);
//DISEASE REPO OK
ingredientRepository = new IngredientRepository(new CSVStream <Ingredient>(ingredientFile, new IngredientConverter()), new LongSequencer());
//INGREDIENT REPO OK
medicineRepository = new MedicineRepository(new CSVStream <Medicine>(medicineFile, new MedicineConverter()), new LongSequencer(), ingredientRepository, diseaseRepository);
//MEDICINE REPO OK
prescriptionRepository = new PrescriptionRepository(new CSVStream <Prescription>(prescriptionFile, new PrescriptionConverter()), new LongSequencer(), doctorRepository, medicineRepository);
//PRESCRIPTION REPO OK
//Medical repositories
allergyRepository = new AllergyRepository(new CSVStream <Allergy>(allergyFile, new AllergyConverter()), new LongSequencer(), ingredientRepository, symptomRepository);
//ALLERGY REPO OK
appointmentRepository = new AppointmentRepository(new CSVStream <Appointment>(appointmentsFile, new AppointmentConverter()), new LongSequencer(), patientRepository, doctorRepository, roomRepository);
//GERGO REPO OK?
therapyRepository = new TherapyRepository(new CSVStream <Therapy>(therapyFile, new TherapyConverter()), new LongSequencer(), medicalRecordRepository, medicalRecordRepository, prescriptionRepository, diagnosisRepository);
//med record
medicalRecordRepository = new MedicalRecordRepository(new CSVStream <MedicalRecord>(medicalRecordFile, new MedicalRecordConverter()), new LongSequencer(), patientRepository, diagnosisRepository, allergyRepository);
//u medical record moras da set diagnosis repo
diagnosisRepository = new DiagnosisRepository(new CSVStream <Diagnosis>(diagnosisFile, new DiagnosisConverter()), new LongSequencer(), therapyRepository, diseaseRepository, medicalRecordRepository);
//therapy
// therapyRepository = new TherapyRepository(new CSVStream<Therapy>(therapyFile,new TherapyConverter()),new LongSequencer(),medicalRecordRepository, )
diseaseRepository.MedicineEagerCSVRepository = medicineRepository;
medicineRepository.DiseaseRepository = diseaseRepository;
medicalRecordRepository.DiagnosisRepository = diagnosisRepository;
diagnosisRepository.MedicalRecordRepository = medicalRecordRepository;
diagnosisRepository.TherapyEagerCSVRepository = therapyRepository;
therapyRepository.DiagnosisCSVRepository = diagnosisRepository;
therapyRepository.MedicalRecordRepository = medicalRecordRepository;
therapyRepository.MedicalRecordEagerCSVRepository = medicalRecordRepository;
//ODAVDDE RADITI OSTALE
doctorStatisticRepository = new DoctorStatisticRepository(new CSVStream <StatsDoctor>(doctorStatisticsFile, new DoctorStatisticsConverter(",")), new LongSequencer(), doctorRepository);
// Doc Stats OK
inventoryStatisticRepository = new InventoryStatisticsRepository(new CSVStream <StatsInventory>(inventoryStatisticsFile, new InventoryStatisticsConverter(",")), new LongSequencer(), medicineRepository, inventoryItemRepository);
// InventoryStats OK
roomStatisticRepository = new RoomStatisticsRepository(new CSVStream <StatsRoom>(roomStatisticsFile, new RoomStatisticsConverter(",")), new LongSequencer(), roomRepository);
// RoomStats OK
inventoryRepository = new InventoryRepository(new CSVStream <Inventory>(inventoryFile, new InventoryConverter(",", ";")), new LongSequencer(), inventoryItemRepository, medicineRepository);
}
public App()
{
var medicationRepository = new MedicationRepository(new Stream <Medication>(MEDICATION_FILE));
var diagnosisRepository = new DiagnosisRepository(new Stream <Diagnosis>(DIAGNOSIS_FILE));
var allergenRepository = new AllergensRepository(new Stream <Allergens>(ALLERGEN_FILE));
var categoryRepository = new MedicationCategoryRepository(new Stream <MedicationCategory>(CATEGORY_FILE));
var symptomsRepository = new SymptomsRepository(new Stream <Symptoms>(SYMPTOMS_FILE));
var ingredientsRepository = new MedicationIngredientRepository(new Stream <MedicationIngredient>(INGREDIENTS_FILE));
var specializationRepository = new SpecializationRepository(new Stream <Specialization>(SPECIALIZATION_FILE));
var cityRepository = new CityRepository(new Stream <City>(CITY_FILE));
var addressRepository = new AddressRepository(new Stream <Address>(ADDRESS_FILE), cityRepository);
var stateRepository = new StateRepository(new Stream <State>(STATE_FILE));
var hospitalRepository = new HospitalRepository(new Stream <Hospital>(HOSPITAL_FILE));
var departmentRepository = new DepartmentRepository(hospitalRepository, new Stream <Department>(DEPARTMENT_FILE));
var roomRepository = new RoomRepository(departmentRepository, new Stream <Room>(ROOM_FILE));
var userRepository = new UserRepository(new Stream <RegisteredUser>(USER_FILE), cityRepository, addressRepository, departmentRepository, roomRepository);
var renovationRepository = new RenovationRepository(roomRepository, new Stream <Renovation>(RENOVATION_FILE));
var medicalRecordRepository = new MedicalRecordRepository(new Stream <MedicalRecord>(RECORD_FILE), diagnosisRepository, medicationRepository, userRepository);
var bedRepository = new BedRepository(roomRepository, medicalRecordRepository, new Stream <Bed>(BED_FILE));
var equipmentTypeRepository = new EquipmentTypeRepository(new Stream <EquipmentType>(EQUIPMENT_TYPE_FILE));
var equipmentRepository = new HospitalEquipmentRepository(new Stream <HospitalEquipment>(EQUIPMENT_FILE));
var treatmentsRepository = new TreatmentRepository(medicationRepository, departmentRepository, new Stream <Treatment>(TREATMENTS_FILE));
var examinationSurgeryRepository = new ExaminationSurgeryRepository(treatmentsRepository, medicalRecordRepository, userRepository, new Stream <ExaminationSurgery>(EXAMINATION_SURGERY_FILE));
var emergencyRequestRepository = new EmergencyRequestRepository(medicalRecordRepository, new Stream <EmergencyRequest>(EMERGENCY_REQUEST_FILE));
var vaccinesRepository = new VaccinesRepository(new Stream <Vaccines>(VACCINES_FILE));
var notificationRepository = new NotificationRepository(userRepository, new Stream <Notification>(NOTIFICATION_FILE));
var articleRepository = new ArticleRepository(userRepository, new Stream <Article>(ARTICLE_FILE));
var questionRepository = new QuestionRepository(userRepository, new Stream <Question>(QUESTIONS_FILE));
var doctorReviewsRepository = new DoctorReviewRepository(userRepository, new Stream <DoctorReview>(DOCTOR_REVIEWS_FILE));
var feedbackRepository = new FeedbackRepository(userRepository, new Stream <Feedback>(FEEDBACK_FILE));
var surveyRepository = new SurveyRepository(userRepository, new Stream <Survey>(SURVEY_FILE));
var appointmentsRepository = new AppointmentRepository(userRepository, medicalRecordRepository, roomRepository, new Stream <Appointment>(APPOINTMENTS_FILE));
var workDayRepository = new WorkDayRepository(userRepository, new Stream <WorkDay>(WORK_DAY_FILE));
var vacationRequestRepository = new VacationRequestRepository(userRepository, new Stream <VacationRequest>(VACATION_REQUEST_FILE));
var reportsRepository = new ReportRepository(new Stream <Report>(REPORTS_FILE));
var labTestTypeRepository = new LabTestTypeRepository(new Stream <LabTestType>(LAB_TEST_TYPE_FILE));
var validationMedicationRepository = new ValidationMedicationRepository(new Stream <ValidationMed>(VALIDATION_FILE), userRepository, medicationRepository);
var equipmentTypeService = new EquipmentTypeService(equipmentTypeRepository);
var medicationService = new MedicationService(medicationRepository, validationMedicationRepository);
var diagnosisService = new DiagnosisService(diagnosisRepository);
var allergenService = new AllergensService(allergenRepository);
var categoryService = new MedicationCategoryService(categoryRepository);
var symptomsService = new SymptomsService(symptomsRepository);
var ingredientsService = new MedicationIngredientService(ingredientsRepository);
var specializationService = new SpecializationService(specializationRepository);
var cityService = new CityService(cityRepository);
var stateService = new StateService(stateRepository);
var addressService = new AddressService(addressRepository);
var notificationService = new NotificationService(notificationRepository, userRepository, medicalRecordRepository);
var validationMedicationService = new ValidationMedicationService(validationMedicationRepository, notificationService);
var hospitalService = new HospitalService(hospitalRepository);
var departmentService = new DepartmentService(departmentRepository);
var bedService = new BedService(bedRepository);
var medicalRecordService = new MedicalRecordService(medicalRecordRepository);
var treatmentService = new TreatmentService(treatmentsRepository, notificationService);
var examiantionSurgeryService = new ExaminationSurgeryService(examinationSurgeryRepository);
var emergencyRequestService = new EmergencyRequestService(emergencyRequestRepository, notificationService);
var vaccinesService = new VaccinesService(vaccinesRepository);
var articleService = new ArticleService(articleRepository);
var questionService = new QuestionService(questionRepository, notificationService);
var doctorsReviewService = new DoctorReviewService(doctorReviewsRepository);
var feedbackService = new FeedbackService(feedbackRepository);
var surveyService = new SurveyService(surveyRepository);
var userService = new UserService(userRepository, medicalRecordService);
var workDayService = new WorkDayService(workDayRepository, MAX_HOURS_PER_WEEK);
var appointmentService = new AppointmentService(appointmentsRepository, workDayService, notificationService, VALID_HOURS_FOR_SCHEDULING, APPOINTMENT_LENGTH_IN_MINUTES,
SURGERY_LENGTH_IN_MINUTES, START_WORKING_HOURS, END_WORKING_HOURS);
var vacationRequestService = new VacationRequestService(vacationRequestRepository, notificationService, NUMBER_OF_ALLOWED_VACAY_REQUESTS);
var reportsService = new ReportService(reportsRepository, treatmentsRepository, medicationRepository, examinationSurgeryRepository, roomRepository);
var labTestTypeService = new LabTestTypeService(labTestTypeRepository);
var roomService = new RoomService(roomRepository, appointmentsRepository);
var hospitalEquipmentService = new HospitalEquipmentService(equipmentRepository);
var renovationService = new RenovationService(renovationRepository, roomService, appointmentsRepository, hospitalEquipmentService, notificationService, RENOVATION_DAYS_RESTRICTION, RENOVATION_DAYS_RESTRICTION);
var availableAppointmentService = new AvailableAppointmentService(appointmentsRepository, workDayService, VALID_HOURS_FOR_SCHEDULING,
APPOINTMENT_LENGTH_IN_MINUTES, SURGERY_LENGTH_IN_MINUTES, START_WORKING_HOURS, END_WORKING_HOURS);
equipmentTypeController = new EquipmentTypeController(equipmentTypeService);
medicationController = new MedicationController(medicationService);
userController = new UserController(userService);
diagnosisController = new DiagnosisController(diagnosisService);
symptomsController = new SymptomsController(symptomsService);
categoryController = new MedicationCategoryController(categoryService);
allergensController = new AllergensController(allergenService);
vaccinesController = new VaccinesController(vaccinesService);
labTestTypeController = new LabTestTypeController(labTestTypeService);
medicationIngredientController = new MedicationIngredientController(ingredientsService);
cityController = new CityController(cityService);
specializationController = new SpecializationController(specializationService);
addressController = new AddressController(addressService);
stateController = new StateController(stateService);
departmentController = new DepartmentController(departmentService);
hospitalController = new HospitalController(hospitalService);
roomController = new RoomController(roomService);
renovationController = new RenovationController(renovationService);
hospitalEquipmentController = new HospitalEquipmentController(hospitalEquipmentService);
medicalRecordController = new MedicalRecordController(medicalRecordService);
treatmentController = new TreatmentController(treatmentService);
examinationSurgeryController = new ExaminationSurgeryController(examiantionSurgeryService);
articleController = new ArticleController(articleService);
questionController = new QuestionController(questionService);
doctorReviewController = new DoctorReviewController(doctorsReviewService);
surveyController = new SurveyController(surveyService);
feedbackController = new FeedbackController(feedbackService);
workDayController = new WorkDayController(workDayService);
reportController = new ReportController(reportsService);
validationMedicationController = new ValidationMedicationController(validationMedicationService);
vacationRequestController = new VacationRequestController(vacationRequestService);
bedController = new BedController(bedService);
emergencyRequestController = new EmergencyRequestController(emergencyRequestService);
appointmentController = new AppointmentController(appointmentService);
notificationController = new NotificationController(notificationService);
availableAppointmentController = new AvailableAppointmentController(availableAppointmentService);
validations = new Validations(UNDERAGE_RESTRICTION);
}
public ActionResult Edit(MyClinic.Infrastructure.PrescriptionAdd itemAdd)
{
this.GetUserProfile();
bool checkError = true;
PrescriptionModels viewModel = null;
DTODiagnosis dtoDiagnosis = null;
IEnumerable <MedicineType> medicineTypeRecords = null;
IEnumerable <vMedicineDiagnosis> medicineRecords = null;
string diffString = "";
try
{
IMedicineTypeRepository objMedicineType = new MedicineTypeRepository();
IDiagnosisRepository diagnosisRepository = new DiagnosisRepository();
dtoDiagnosis = diagnosisRepository.GetDTODiagnosisById(itemAdd.DiagnosisId);
medicineRecords = objPrescription.GetPrescriptionDiagnosis(itemAdd.DiagnosisId);
if (ModelState.IsValid)
{
var intTotal = 0;
if (itemAdd.MedicineId != null)
{
intTotal = itemAdd.MedicineId.Count();
}
foreach (var record in medicineRecords)
{
bool blnFound = false;
for (int intIndex = 0; intIndex < intTotal; intIndex++)
{
var intId = 0;
if (int.TryParse(itemAdd.Id[intIndex], out intId))
{
if (intId == record.Id)
{
blnFound = true;
Prescription itemOld = new Prescription();
itemOld.DiagnosisId = record.DiagnosisId;
itemOld.Id = record.Id;
itemOld.MedicineId = record.MedicineId;
itemOld.Qty = record.Qty;
//itemOld.MedicineType = record.MedicineType;
itemOld.Morning = record.Morning;
itemOld.Noon = record.Noon;
itemOld.Night = record.Night;
itemOld.Remark = record.Remark;
itemOld.UsageId = record.UsageId;
Prescription itemNew = new Prescription();
int itemId = 0;
int.TryParse(itemAdd.Id[intIndex], out itemId);
itemNew.DiagnosisId = record.DiagnosisId;
itemNew.Id = itemId;
int MedicineId = 0;
int.TryParse(itemAdd.MedicineId[intIndex], out MedicineId);
itemNew.MedicineId = MedicineId;
itemNew.Qty = itemAdd.Qty[intIndex];
//itemNew.MedicineType = itemAdd.MedicineType[intIndex];
itemNew.Morning = itemAdd.Morning[intIndex];
itemNew.Noon = itemAdd.Noon[intIndex];
itemNew.Night = itemAdd.Night[intIndex];
itemNew.Remark = itemAdd.Remark[intIndex];
itemNew.UsageId = int.Parse(itemAdd.UsageId[intIndex]);
itemNew.Status = record.Status;
diffString = diffString + itemOld.EnumeratePropertyDifferencesInString(itemNew);
objPrescription.Update(itemNew);
}
}
}
if (blnFound == false)
{
objPrescription.Delete(record.Id);
}
}
for (int intIndex = 0; intIndex < intTotal; intIndex++)
{
int itemId = 0;
int.TryParse(itemAdd.Id[intIndex], out itemId);
if (itemId == 0)
{
Prescription itemGet = new Prescription();
itemGet.DiagnosisId = itemAdd.DiagnosisId;
int MedicineId = 0;
int.TryParse(itemAdd.MedicineId[intIndex], out MedicineId);
itemGet.MedicineId = MedicineId;
itemGet.Qty = itemAdd.Qty[intIndex];
//itemGet.MedicineType = itemAdd.MedicineType[intIndex];
itemGet.Morning = itemAdd.Morning[intIndex];
itemGet.Noon = itemAdd.Noon[intIndex];
itemGet.Night = itemAdd.Night[intIndex];
itemGet.Remark = itemAdd.Remark[intIndex];
itemGet.UsageId = int.Parse(itemAdd.UsageId[intIndex]);
itemGet.Status = (int)MyClinic.Core.Enums.RecordStatus.Active;
objPrescription.Add(itemGet);
}
}
/*For Add New Record to LogTable*/
logTran.UserId = this.objProfile.UserId;
logTran.ProcessType = "Edit Prescription";
logTran.Description = "Edit Prescription value as follow: " + diffString;
logTran.LogDate = DateTime.Now;
logRepository.Add(logTran);
return(RedirectToAction("Detail", "Prescription", new { id = itemAdd.DiagnosisId }));
checkError = false;
}
medicineTypeRecords = objMedicineType.Get();
}
catch (Exception ex)
{
log.Error(ex);
ModelState.AddModelError("error", Translator.UnexpectedError);
}
if (checkError == true)
{
viewModel = new PrescriptionModels
{
validAdd = itemAdd,
checkPost = true,
checkError = checkError,
dtoDiagnosis = dtoDiagnosis,
medicineTypeRecords = medicineTypeRecords,
medicineRecords = medicineRecords
};
return(View(viewModel));
}
else
{
return(RedirectToAction("Index", "Diagnosis"));
}
}
public ActionResult Add(MyClinic.Infrastructure.PrescriptionAdd itemAdd)
{
Prescription itemGet = new Prescription();
var objSessionDiagnosis = Session["diagnosis"] as MyClinic.Infrastructure.Diagnosis;
this.GetUserProfile();
bool checkError = true;
PrescriptionModels viewModel = null;
DTODiagnosis dtoDiagnosis = null;
IEnumerable <MedicineType> medicineTypeRecords = null;
try
{
IMedicineTypeRepository objMedicineType = new MedicineTypeRepository();
IDiagnosisRepository diagnosisRepository = new DiagnosisRepository();
dtoDiagnosis = diagnosisRepository.GetDTODiagnosisById(itemAdd.DiagnosisId);
/*For Add Diagnosis to Table */
diagnosisRepository.Add(objSessionDiagnosis);
itemGet.DiagnosisId = objSessionDiagnosis.Id;
//Save Image
SaveUploadImge(Session.SessionID, objSessionDiagnosis.Id);
if (ModelState.IsValid)
{
var intTotal = 0;
if (itemAdd.MedicineId != null)
{
intTotal = itemAdd.MedicineId.Count();
}
for (int intIndex = 0; intIndex < intTotal; intIndex++)
{
int MedicineId = 0;
int.TryParse(itemAdd.MedicineId[intIndex], out MedicineId);
itemGet.MedicineId = MedicineId;
itemGet.Qty = itemAdd.Qty[intIndex];
//itemGet.MedicineType = itemAdd.MedicineType[intIndex];
itemGet.Morning = itemAdd.Morning[intIndex];
itemGet.Noon = itemAdd.Noon[intIndex];
itemGet.Night = itemAdd.Night[intIndex];
itemGet.Remark = itemAdd.Remark[intIndex];
itemGet.UsageId = int.Parse(itemAdd.UsageId[intIndex]);
itemGet.Status = (int)MyClinic.Core.Enums.RecordStatus.Active;
objPrescription.Add(itemGet);
}
Session["diagnosis"] = null;
/*For Add New Record to LogTable*/
logTran.UserId = this.objProfile.UserId;
logTran.ProcessType = "Add Prescription";
logTran.Description = "Add Prescription";
logTran.LogDate = DateTime.Now;
logRepository.Add(logTran);
/*this.GetUserProfile();
* var test = this.objProfile;*/
return(RedirectToAction("Detail", "Prescription", new { id = itemGet.DiagnosisId }));
//checkError = false;
}
medicineTypeRecords = objMedicineType.Get();
}
catch (Exception ex)
{
log.Error(ex);
ModelState.AddModelError("error", Translator.UnexpectedError);
}
if (checkError == true)
{
viewModel = new PrescriptionModels
{
validAdd = itemAdd,
checkPost = true,
checkError = checkError,
dtoDiagnosis = dtoDiagnosis,
medicineTypeRecords = medicineTypeRecords
};
return(View(viewModel));
}
else
{
return(RedirectToAction("Index", "User"));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DiagnosisController" /> class.
/// </summary>
/// <param name="diagnosisRepository">The diagnosis repository.</param>
internal DiagnosisController(DiagnosisRepository diagnosisRepository)
{
this.diagnosisReposity = diagnosisRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="DiagnosisController" /> class.
/// </summary>
public DiagnosisController()
{
this.diagnosisReposity = new DiagnosisRepository();
}
