/// <summary> /// Method to update auto sequence - SS /// </summary> /// <param name="updateAutoSequence">auto sequence</param> /// <param name="loggedInUser">logged in user detail</param> /// <returns>response</returns> public async Task <AutoSequenceGeneratorManagementResponse> UpdateAutoSequenceGeneratorAsync(UpdateAutoSequenceGeneratorManagementAc updateAutoSequence, ApplicationUser loggedInUser) { await semaphore.WaitAsync(); try { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); var autoSequence = await _iMSDbContext.AutoSequenceGenerators.FirstOrDefaultAsync(x => x.Id == updateAutoSequence.Id && x.InstituteId == instituteId); if (autoSequence != null) { if (updateAutoSequence.AutoSequenceGeneratorDataTypes.Any(x => x.IsSelected && x.Name == "Text")) { if (string.IsNullOrEmpty(updateAutoSequence.CustomText)) { return new AutoSequenceGeneratorManagementResponse() { HasError = true, Message = "Please add text in custom text." } } ; } autoSequence.CustomText = updateAutoSequence.CustomText; autoSequence.Seperator = EnumHelperService.GetValueFromDescription <AutoSequenceGeneratorSeperatorEnum>(updateAutoSequence.SeperatorDescription); autoSequence.UpdateById = loggedInUser.Id; autoSequence.UpdateDate = DateTime.UtcNow; autoSequence.AutoSequenceGeneratorDataTypes = null; _iMSDbContext.AutoSequenceGenerators.Update(autoSequence); await _iMSDbContext.SaveChangesAsync(); var types = await _iMSDbContext.AutoSequenceGeneratorDataTypes.Where(x => x.AutoSequenceGeneratorId == autoSequence.Id).ToListAsync(); _iMSDbContext.AutoSequenceGeneratorDataTypes.RemoveRange(types); await _iMSDbContext.SaveChangesAsync(); updateAutoSequence.AutoSequenceGeneratorDataTypes.ForEach(x => x.Id = 0); _iMSDbContext.AutoSequenceGeneratorDataTypes.AddRange(updateAutoSequence.AutoSequenceGeneratorDataTypes); await _iMSDbContext.SaveChangesAsync(); return(new AutoSequenceGeneratorManagementResponse() { HasError = false, Message = "Auto sequence updated successfully" }); } else { return new AutoSequenceGeneratorManagementResponse() { HasError = true, Message = "Auto sequence not found" } }; } finally { semaphore.Release(); } }
/// <summary> /// Method to add or update attendance - SS /// </summary> /// <param name="staffAttendances">Staff attendance detail</param> /// <param name="loggedInUser">logged in user</param> public async Task AddStaffAttendanceAsync(List <AddStaffAttendanceManagementWrapperAc> staffAttendances, ApplicationUser loggedInUser) { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); var academicYear = await _iMSDbContext.InstituteAcademicYears.FirstOrDefaultAsync(x => x.InstituteId == instituteId && x.IsActive); List <StaffAttendance> toBeDeleted = new List <StaffAttendance>(); List <StaffAttendance> toBeAdded = new List <StaffAttendance>(); foreach (var attendance in staffAttendances) { toBeDeleted.AddRange(await _iMSDbContext.StaffAttendances.Where(x => x.StaffId == attendance.StaffId && x.AttendanceDate >= attendance.AttendanceDates.First() && x.AttendanceDate <= attendance.AttendanceDates.Last()).ToListAsync()); for (int i = 0; i < attendance.AttendanceDates.Count; i++) { toBeAdded.Add(new StaffAttendance() { AttendanceDate = attendance.AttendanceDates[i], AttendanceType = EnumHelperService.GetValueFromDescription <AttendanceType>(attendance.AttendanceType[i]), CreatedOn = DateTime.UtcNow, StaffId = attendance.StaffId, UpdatedById = loggedInUser.Id, UpdatedOn = DateTime.UtcNow, AcademicYearId = academicYear?.Id }); } } _iMSDbContext.StaffAttendances.RemoveRange(toBeDeleted); _iMSDbContext.StaffAttendances.AddRange(toBeAdded); await _iMSDbContext.SaveChangesAsync(); }
public async Task <IActionResult> UpdateDocumentDataAsync([FromBody] List <AddStudentDocumentMappingAc> studentDocuments, int studentId) { var documents = await _iMSDbContext.StudentDocumentMappings.Where(x => x.StudentId == studentId).ToListAsync(); _iMSDbContext.StudentDocumentMappings.RemoveRange(documents); await _iMSDbContext.SaveChangesAsync(); List <StudentDocumentMapping> studentDocumentMappings = new List <StudentDocumentMapping>(); foreach (var doc in studentDocuments) { studentDocumentMappings.Add(new StudentDocumentMapping() { CreatedOn = DateTime.UtcNow, ExpiredDate = doc.ExpiredDate, FileType = EnumHelperService.GetValueFromDescription <FileTypeEnum>(doc.FileType), FileUrl = doc.FileUrl, MetaData = doc.MetaData, Name = doc.Name, StudentId = studentId }); } _iMSDbContext.StudentDocumentMappings.AddRange(studentDocumentMappings); await _iMSDbContext.SaveChangesAsync(); return(Ok()); }
/// <summary> /// Method to add bulk student relieving details /// </summary> /// <param name="addStudentRelievings">student detail</param> /// <param name="loggedInUser">logged in user</param> /// <returns>response</returns> public async Task <StudentRelievingManagementResponse> AddStudentRelievingAsync(List <AddStudentRelievingManagementAc> addStudentRelievings, ApplicationUser loggedInUser) { List <StudentRelievingMapping> studentRelievingMappings = new List <StudentRelievingMapping>(); foreach (var addStudentRelieving in addStudentRelievings) { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); studentRelievingMappings.Add(new StudentRelievingMapping() { CreatedOn = DateTime.UtcNow, Reason = addStudentRelieving.Reason, RelievingDate = addStudentRelieving.RelievingDate, StudentId = addStudentRelieving.StudentId, StudentRelieving = EnumHelperService.GetValueFromDescription <StudentRelievingEnum>(addStudentRelieving.StudentRelieving), UpdatedById = loggedInUser.Id, UpdatedOn = DateTime.UtcNow }); } _iMSDbContext.StudentRelievingMappings.AddRange(studentRelievingMappings); await _iMSDbContext.SaveChangesAsync(); return(new StudentRelievingManagementResponse() { Message = "Student details updated successfully", HasError = false }); }
/// <summary> /// Method to update student relieving detail - SS /// </summary> /// <param name="updateStudentRelievings">updated detail</param> /// <param name="loggedInUser">logged in user</param> /// <returns>response</returns> public async Task <StudentRelievingManagementResponse> UpdateStudentRelievingAsync(UpdateStudentRelievingManagementAc updateStudentRelievings, ApplicationUser loggedInUser) { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); var student = await _iMSDbContext.StudentRelievingMappings.FirstOrDefaultAsync(x => x.Id == updateStudentRelievings.Id && x.Student.InstituteId == instituteId); if (student == null) { return new StudentRelievingManagementResponse() { HasError = true, ErrorType = StudentRelievingManagementResponseType.StudentId, Message = "Student not found" } } ; else { student.Reason = updateStudentRelievings.Reason; student.RelievingDate = updateStudentRelievings.RelievingDate; student.StudentRelieving = EnumHelperService.GetValueFromDescription <StudentRelievingEnum>(updateStudentRelievings.StudentRelieving); student.UpdatedOn = DateTime.UtcNow; student.UpdatedById = loggedInUser.Id; _iMSDbContext.StudentRelievingMappings.Update(student); await _iMSDbContext.SaveChangesAsync(); return(new StudentRelievingManagementResponse() { HasError = false, Message = "Student details updated successfully" }); } }
/// <summary> /// Method to add or update Vehicle document - SS /// </summary> /// <param name="files">image files</param> /// <param name="vehicleId">Vehicle id</param> /// <param name="loggedInUser">logged in user</param> /// <param name="addVehicleDocuments">documnets details</param> public async Task AddOrUpdateVehicleDocumentsAsync(IFormFileCollection files, int vehicleId, ApplicationUser loggedInUser, List <AddVehicleDocumentMappingAc> addVehicleDocuments) { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); var instituteName = (await _iMSDbContext.Institutes.FirstAsync(x => x.Id == instituteId)).Name; var images = await _imageStorageHelperService.UploadBlobDataAsync(files, instituteName, "Document"); if (images.Count != 0) { var gallery = new List <VehicleDocumentMapping>(); for (int i = 0; i < images.Count; i++) { gallery.Add(new VehicleDocumentMapping() { CreatedOn = DateTime.UtcNow, ExpiredDate = addVehicleDocuments[i].ExpiredDate, FileType = EnumHelperService.GetValueFromDescription <FileTypeEnum>(addVehicleDocuments[i].FileType), FileUrl = images[i], MetaData = addVehicleDocuments[i].MetaData, VehicleId = vehicleId, Name = addVehicleDocuments[i].Name }); } _iMSDbContext.VehicleDocumentMappings.AddRange(gallery); await _iMSDbContext.SaveChangesAsync(); } }
public async Task <IActionResult> GetAutoSequenceNumberByTypeAndInstituteIdAsync(string typeEnum) { var instituteId = await GetUserCurrentSelectedInstituteIdAsync(); var generatorTypeEnum = EnumHelperService.GetValueFromDescription <AutoSequenceGeneratorTypeEnum>(typeEnum); return(Ok(await _autoSequenceGeneratorManagementRepository.GetAutoSequenceNumberByTypeAndInstituteIdAsync(instituteId, generatorTypeEnum))); }
public async Task <IActionResult> GetSequenceGeneratorsAsync(string generatorType) { var loggedInUser = await _userManager.FindByNameAsync(User.Identity.Name); var generatorTypeEnum = EnumHelperService.GetValueFromDescription <AutoSequenceGeneratorTypeEnum>(generatorType); return(Ok(await _autoSequenceGeneratorManagementRepository.GetSequenceGeneratorsAsync(loggedInUser, generatorTypeEnum))); }
/// <summary> /// Method to get template - SS /// </summary> /// <param name="getTemplate">query params</param> /// <param name="instituteId">institute id</param> /// <returns></returns> public async Task <Template> GetTemplateAsync(GetTemplateAc getTemplate, int instituteId) { var template = await _iMSDbContext.Templates.FirstOrDefaultAsync(x => x.TemplateFormat == EnumHelperService.GetValueFromDescription <TemplateFormatEnum>(getTemplate.TemplateFormat) && x.InstituteId == instituteId && x.TemplateFeatureType == EnumHelperService.GetValueFromDescription <TemplateFeatureEnum>(getTemplate.TemplateFeatureType) && x.TemplateType == EnumHelperService.GetValueFromDescription <TemplateTypeEnum>(getTemplate.TemplateType)); return(template); }
/// <summary> /// Method for adding a new template - RS /// </summary> /// <param name="addedTemplate"></param> /// <param name="currentUser"></param> /// <returns></returns> public async Task <dynamic> AddOrUpdateTemplateAsync(AddTemplateAc addedTemplate, ApplicationUser currentUser) { if (string.IsNullOrEmpty(addedTemplate.Name.Trim())) { return new { HasError = true, Message = "Name can't be empty" } } ; else if (string.IsNullOrEmpty(addedTemplate.Format.Trim())) { return new { HasError = true, Message = "Format can't be empty" } } ; else { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(currentUser.Id, true); var template = await _iMSDbContext.Templates.FirstOrDefaultAsync(x => x.TemplateFormat == EnumHelperService.GetValueFromDescription <TemplateFormatEnum>(addedTemplate.TemplateFormat) && x.InstituteId == instituteId && x.TemplateFeatureType == EnumHelperService.GetValueFromDescription <TemplateFeatureEnum>(addedTemplate.TemplateFeatureType) && x.TemplateType == EnumHelperService.GetValueFromDescription <TemplateTypeEnum>(addedTemplate.TemplateType)); if (template == null) { template = new Template { CreatedOn = DateTime.UtcNow, EmailBcc = addedTemplate.EmailBcc, EmailSubject = addedTemplate.EmailSubject, To = addedTemplate.To, Name = addedTemplate.Name, TemplateFormat = EnumHelperService.GetValueFromDescription <TemplateFormatEnum>(addedTemplate.TemplateFormat), TemplateFeatureType = EnumHelperService.GetValueFromDescription <TemplateFeatureEnum>(addedTemplate.TemplateFeatureType), TemplateType = EnumHelperService.GetValueFromDescription <TemplateTypeEnum>(addedTemplate.TemplateType), Format = addedTemplate.Format, InstituteId = instituteId }; _iMSDbContext.Templates.Add(template); await _iMSDbContext.SaveChangesAsync(); } else { template.EmailBcc = addedTemplate.EmailBcc; template.EmailSubject = addedTemplate.EmailSubject; template.To = addedTemplate.To; template.Name = addedTemplate.Name; template.Format = addedTemplate.Format; _iMSDbContext.Templates.Add(template); await _iMSDbContext.SaveChangesAsync(); } return(new { HasError = false, Message = "Template updated successfully" }); } }
public async Task <IActionResult> UpdateFeeReceiptAsync([FromBody] FeeReceipt feeReceipt) { var instituteId = await GetUserCurrentSelectedInstituteIdAsync(); if (await _imsDbContext.FeeReceipts.AnyAsync(x => x.Id == feeReceipt.Id && x.Student.InstituteId == instituteId)) { var user = await _userManager.FindByNameAsync(User.Identity.Name); feeReceipt.UpdatedById = user.Id; feeReceipt.ReceiptType = EnumHelperService.GetValueFromDescription <ReceiptTypeEnum>(feeReceipt.ReceiptTypeDescription); feeReceipt.UpdatedOn = DateTime.UtcNow; _imsDbContext.FeeReceipts.Update(feeReceipt); await _imsDbContext.SaveChangesAsync(); return(Ok(new { HasError = false, Message = "Fee receipt updated successfully" })); } else { return(Ok(new { HasError = true, Message = "Fee receipt not found" })); } }
/// <summary> /// Method to add Leave type - SS /// </summary> /// <param name="addLeaveType">leave type</param> /// <param name="loggedInUser">logged in user</param> /// <returns>response</returns> public async Task <LeaveTypeManagementResponse> AddLeaveType(AddLeaveTypeManagementAc addLeaveType, ApplicationUser loggedInUser) { if (string.IsNullOrEmpty(addLeaveType.Code.Trim())) { return new LeaveTypeManagementResponse() { HasError = true, Message = "Code can't be empty", ErrorType = LeaveTypeManagementResponseType.Code } } ; else if (string.IsNullOrEmpty(addLeaveType.Name.Trim())) { return new LeaveTypeManagementResponse() { HasError = true, Message = "Code can't be empty", ErrorType = LeaveTypeManagementResponseType.Name } } ; else { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); var assignedToCount = await _iMSDbContext.UserInstituteMappings.CountAsync(x => addLeaveType.LeaveAssignedTos.Contains(x.UserId) && x.InstituteId == instituteId); if (assignedToCount != addLeaveType.LeaveAssignedTos.Count) { return new LeaveTypeManagementResponse() { HasError = true, Message = "User not found", ErrorType = LeaveTypeManagementResponseType.LeaveAssignedTos } } ; else { if (await _iMSDbContext.LeaveTypes.AnyAsync(x => x.InstituteId == instituteId && x.Code.ToLowerInvariant() == addLeaveType.Code.ToLowerInvariant())) { return new LeaveTypeManagementResponse() { HasError = true, Message = "Leave type with same code already exist. Please use unique one", ErrorType = LeaveTypeManagementResponseType.Code } } ; else { var leaveType = new LeaveType() { Code = addLeaveType.Code, CreatedOn = DateTime.UtcNow, Description = addLeaveType.Description, InstituteId = instituteId, LeaveAssignedTypeEnum = EnumHelperService.GetValueFromDescription <LeaveAssignedTypeEnum>(addLeaveType.LeaveAssignedTypeEnumDescription), Name = addLeaveType.Name, NumberOfAllowedLeave = addLeaveType.NumberOfAllowedLeave, UpdatedById = loggedInUser.Id, UpdatedOn = DateTime.UtcNow }; _iMSDbContext.LeaveTypes.Add(leaveType); await _iMSDbContext.SaveChangesAsync(); List <LeaveAssignedTo> assignedTos = new List <LeaveAssignedTo>(); foreach (var user in addLeaveType.LeaveAssignedTos) { assignedTos.Add(new LeaveAssignedTo() { CreatedOn = DateTime.UtcNow, LeaveTypeId = leaveType.Id, UserId = user }); } using (var db = await _iMSDbContext.Database.BeginTransactionAsync()) { await _iMSDbContext.BulkInsertAsync(assignedTos); db.Commit(); } return(new LeaveTypeManagementResponse() { HasError = false, Message = "Leave type added succesfully" }); } } } }
/// <summary> /// Method to update Leave type - SS /// </summary> /// <param name="updateLeaveType">leave type</param> /// <param name="loggedInUser">logged in user</param> /// <returns>response</returns> public async Task <LeaveTypeManagementResponse> UpdateLeaveType(UpdateLeaveTypeManagementAc updateLeaveType, ApplicationUser loggedInUser) { if (string.IsNullOrEmpty(updateLeaveType.Code.Trim())) { return new LeaveTypeManagementResponse() { HasError = true, Message = "Code can't be empty", ErrorType = LeaveTypeManagementResponseType.Code } } ; else if (string.IsNullOrEmpty(updateLeaveType.Name.Trim())) { return new LeaveTypeManagementResponse() { HasError = true, Message = "Code can't be empty", ErrorType = LeaveTypeManagementResponseType.Name } } ; else { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); var assignedToCount = await _iMSDbContext.UserInstituteMappings.CountAsync(x => updateLeaveType.LeaveAssignedTos.Contains(x.UserId) && x.InstituteId == instituteId); if (assignedToCount != updateLeaveType.LeaveAssignedTos.Count) { return new LeaveTypeManagementResponse() { HasError = true, Message = "User not found", ErrorType = LeaveTypeManagementResponseType.LeaveAssignedTos } } ; else { var types = await _iMSDbContext.LeaveTypes.Where(x => x.InstituteId == instituteId && x.Id != updateLeaveType.Id).ToListAsync(); if (types.Any(x => x.Code.ToLowerInvariant() == updateLeaveType.Code.ToLowerInvariant())) { return new LeaveTypeManagementResponse() { HasError = true, Message = "Leave type with same code already exist. Please use unique one", ErrorType = LeaveTypeManagementResponseType.Code } } ; else { var leaveType = await _iMSDbContext.LeaveTypes.FirstOrDefaultAsync(x => x.Id == updateLeaveType.Id && x.InstituteId == instituteId); if (leaveType == null) { return new LeaveTypeManagementResponse() { HasError = true, Message = "Leave type not found", ErrorType = LeaveTypeManagementResponseType.Id } } ; else { leaveType.Code = updateLeaveType.Code; leaveType.Description = updateLeaveType.Description; leaveType.LeaveAssignedTypeEnum = EnumHelperService.GetValueFromDescription <LeaveAssignedTypeEnum>(updateLeaveType.LeaveAssignedTypeEnumDescription); leaveType.Name = updateLeaveType.Name; leaveType.NumberOfAllowedLeave = updateLeaveType.NumberOfAllowedLeave; leaveType.UpdatedById = loggedInUser.Id; leaveType.UpdatedOn = DateTime.UtcNow; _iMSDbContext.LeaveTypes.Update(leaveType); await _iMSDbContext.SaveChangesAsync(); var previous = await _iMSDbContext.LeaveAssignedTos.Where(x => x.LeaveTypeId == leaveType.Id).ToListAsync(); using (var db = await _iMSDbContext.Database.BeginTransactionAsync()) { await _iMSDbContext.BulkDeleteAsync(previous); db.Commit(); } List <LeaveAssignedTo> assignedTos = new List <LeaveAssignedTo>(); foreach (var user in updateLeaveType.LeaveAssignedTos) { assignedTos.Add(new LeaveAssignedTo() { CreatedOn = DateTime.UtcNow, LeaveTypeId = leaveType.Id, UserId = user }); } using (var db = await _iMSDbContext.Database.BeginTransactionAsync()) { await _iMSDbContext.BulkInsertAsync(assignedTos); db.Commit(); } return(new LeaveTypeManagementResponse() { HasError = false, Message = "Leave type updated succesfully" }); } } } } }
/// <summary> /// Method to add fee receipts - SS /// </summary> /// <param name="addFeeReceipts">fee receipts</param> /// <param name="loggedInUser">logged in user</param> /// <returns>response</returns> public async Task <FeeReceiptManagementResponse> AddFeeReceiptAsync(List <AddFeeReceiptManagementAc> addFeeReceipts, ApplicationUser loggedInUser) { await semaphore.WaitAsync(); try { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); List <FeeReceiptComponent> feeReceiptComponents = new List <FeeReceiptComponent>(); int orderId = 0; foreach (var receipt in addFeeReceipts) { if (string.IsNullOrEmpty(receipt.ReceiptNumber.Trim())) { return new FeeReceiptManagementResponse() { HasError = true, OrderId = orderId, Message = "Receipt number can't be empty", ErrorType = FeeReceiptManagementType.ReceiptNumber } } ; else if (string.IsNullOrEmpty(receipt.ChallanNumber.Trim())) { return new FeeReceiptManagementResponse() { HasError = true, OrderId = orderId, Message = "Challan number can't be empty", ErrorType = FeeReceiptManagementType.ChallanNumber } } ; else { if (await _iMSDbContext.FeeReceipts.AnyAsync(x => x.ReceiptNumber == receipt.ReceiptNumber)) { var autoSequence = await _iMSDbContext.AutoSequenceGenerators.Include(s => s.AutoSequenceGeneratorDataTypes) .Include(d => d.Institute).FirstOrDefaultAsync(x => x.InstituteId == instituteId && x.AutoSequenceGeneratorType == AutoSequenceGeneratorTypeEnum.ReceiptNumber); if (autoSequence == null) { return new FeeReceiptManagementResponse() { HasError = true, OrderId = orderId, Message = "Duplicate receipt number. Please choose unique number", ErrorType = FeeReceiptManagementType.ReceiptNumber } } ; else { receipt.ReceiptNumber = await GenerateFeeReceiptNumberAsync(autoSequence); } } var feeReceipt = new FeeReceipt() { Amount = receipt.Amount, BankName = receipt.BankName, ChallanNumber = receipt.ChallanNumber, ChequeDate = receipt.ChequeDate, ChequeNumber = receipt.ChequeNumber, ClassId = receipt.ClassId, CreatedOn = DateTime.UtcNow, IsNewAdmission = receipt.IsNewAdmission, LateFee = receipt.LateFee, PreviousAmountPaid = receipt.PreviousAmountPaid, ReceiptDate = receipt.ReceiptDate, ReceiptNumber = receipt.ReceiptNumber, ReceiptType = EnumHelperService.GetValueFromDescription <ReceiptTypeEnum>(receipt.ReceiptType), StudentId = receipt.StudentId, Total = receipt.Total, UpdatedById = loggedInUser.Id, UpdatedOn = DateTime.UtcNow, Term = receipt.Term }; _iMSDbContext.FeeReceipts.AddRange(feeReceipt); await _iMSDbContext.SaveChangesAsync(); #region Send Mail/Message feeReceipt = await _iMSDbContext.FeeReceipts.Include(s => s.Student).FirstAsync(s => s.Id == feeReceipt.Id); await _templateManagementRepository.TriggerMailOrMessageAsync(instituteId, TemplateTypeEnum.FeePaymentAdd, TemplateFormatEnum.Email, feeReceipt); await _templateManagementRepository.TriggerMailOrMessageAsync(instituteId, TemplateTypeEnum.FeePaymentAdd, TemplateFormatEnum.Sms, feeReceipt); #endregion for (int i = 0; i < receipt.FeeReceiptComponents.Count; i++) { feeReceiptComponents.Add(new FeeReceiptComponent() { Amount = receipt.FeeReceiptComponents[i].Amount, CreatedOn = DateTime.UtcNow, FeeReciptId = feeReceipt.Id, Name = receipt.FeeReceiptComponents[i].Name, OrderId = i, }); } } orderId++; } _iMSDbContext.FeeReceiptComponents.AddRange(feeReceiptComponents); await _iMSDbContext.SaveChangesAsync(); return(new FeeReceiptManagementResponse() { HasError = false, Message = "Fee receipt added successfully" }); } finally { semaphore.Release(); } }
/// <summary> /// Method to add vehicle master - SS /// </summary> /// <param name="addVehicleMaster">vehicle detail</param> /// <param name="loggedInUser">logged in user</param> /// <returns>response</returns> public async Task <VehicleMasterManagementResponse> AddVehicleMasterAsync(AddVehicleMasterManagementAc addVehicleMaster, ApplicationUser loggedInUser) { if (string.IsNullOrEmpty(addVehicleMaster.VehicleCode) && string.IsNullOrEmpty(addVehicleMaster.VehicleCode.Trim())) { return new VehicleMasterManagementResponse() { HasError = true, Message = "Vehicle code can't be empty", ErrorType = VehicleMasterManagementResponseType.VehicleCode } } ; else if (string.IsNullOrEmpty(addVehicleMaster.VehicleType) && string.IsNullOrEmpty(addVehicleMaster.VehicleType.Trim())) { return new VehicleMasterManagementResponse() { HasError = true, Message = "Vehicle type can't be empty", ErrorType = VehicleMasterManagementResponseType.VehicleType } } ; else if (string.IsNullOrEmpty(addVehicleMaster.FuelType) && string.IsNullOrEmpty(addVehicleMaster.FuelType.Trim())) { return new VehicleMasterManagementResponse() { HasError = true, Message = "Fuel type can't be empty", ErrorType = VehicleMasterManagementResponseType.FuelType } } ; else if (string.IsNullOrEmpty(addVehicleMaster.VehicleRegistrationNumber) && string.IsNullOrEmpty(addVehicleMaster.VehicleRegistrationNumber.Trim())) { return new VehicleMasterManagementResponse() { HasError = true, Message = "Vehicle registration number can't be empty", ErrorType = VehicleMasterManagementResponseType.VehicleRegistrationNumber } } ; else if (string.IsNullOrEmpty(addVehicleMaster.EngineNumber) && string.IsNullOrEmpty(addVehicleMaster.EngineNumber.Trim())) { return new VehicleMasterManagementResponse() { HasError = true, Message = "Engine number can't be empty", ErrorType = VehicleMasterManagementResponseType.EngineNumber } } ; else { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); if (await _iMSDbContext.VehicleMasters.AnyAsync(x => x.InstituteId == instituteId && x.VehicleCode.ToLowerInvariant() == addVehicleMaster.VehicleCode.ToLowerInvariant())) { return new VehicleMasterManagementResponse() { HasError = true, Message = "Vehicle code already exist. Please use unique one", ErrorType = VehicleMasterManagementResponseType.VehicleCode } } ; else { var vehicle = new VehicleMaster() { AverageKMPL = addVehicleMaster.AverageKMPL, ChasisNumber = addVehicleMaster.ChasisNumber, CreatedOn = DateTime.UtcNow, EngineNumber = addVehicleMaster.EngineNumber, ExtraFittings = addVehicleMaster.ExtraFittings, FitnessExpDate = addVehicleMaster.FitnessExpDate, FuelType = EnumHelperService.GetValueFromDescription <VehicleMasterFuelTypeEnum>(addVehicleMaster.FuelType), InstituteId = instituteId, InsuranceDate = addVehicleMaster.InsuranceDate, InsuranceExpDate = addVehicleMaster.InsuranceExpDate, InsuranceNumber = addVehicleMaster.InsuranceNumber, NextMaintenanceDate = addVehicleMaster.NextMaintenanceDate, PermitValidityDate = addVehicleMaster.PermitValidityDate, UpdatedById = loggedInUser.Id, UpdatedOn = DateTime.UtcNow, VehicleCode = addVehicleMaster.VehicleCode, VehicleRegistrationNumber = addVehicleMaster.VehicleRegistrationNumber, VehicleType = EnumHelperService.GetValueFromDescription <VehicleMasterTypeEnum>(addVehicleMaster.VehicleType) }; _iMSDbContext.VehicleMasters.Add(vehicle); await _iMSDbContext.SaveChangesAsync(); return(new VehicleMasterManagementResponse() { HasError = false, Message = "Vehicle added successfully", Data = new { Id = vehicle.Id } }); } } }
/// <summary> /// Method to update vehicle master - SS /// </summary> /// <param name="updateVehicleMaster">vehicle detail</param> /// <param name="loggedInUser">logged in user</param> /// <returns>response</returns> public async Task <VehicleMasterManagementResponse> UpdateVehicleMasterAsync(UpdateVehicleMasterManagementAc updateVehicleMaster, ApplicationUser loggedInUser) { if (string.IsNullOrEmpty(updateVehicleMaster.VehicleCode) && string.IsNullOrEmpty(updateVehicleMaster.VehicleCode.Trim())) { return new VehicleMasterManagementResponse() { HasError = true, Message = "Vehicle code can't be empty", ErrorType = VehicleMasterManagementResponseType.VehicleCode } } ; else if (string.IsNullOrEmpty(updateVehicleMaster.VehicleType) && string.IsNullOrEmpty(updateVehicleMaster.VehicleType.Trim())) { return new VehicleMasterManagementResponse() { HasError = true, Message = "Vehicle type can't be empty", ErrorType = VehicleMasterManagementResponseType.VehicleType } } ; else if (string.IsNullOrEmpty(updateVehicleMaster.FuelType) && string.IsNullOrEmpty(updateVehicleMaster.FuelType.Trim())) { return new VehicleMasterManagementResponse() { HasError = true, Message = "Fuel type can't be empty", ErrorType = VehicleMasterManagementResponseType.FuelType } } ; else if (string.IsNullOrEmpty(updateVehicleMaster.VehicleRegistrationNumber) && string.IsNullOrEmpty(updateVehicleMaster.VehicleRegistrationNumber.Trim())) { return new VehicleMasterManagementResponse() { HasError = true, Message = "Vehicle registration number can't be empty", ErrorType = VehicleMasterManagementResponseType.VehicleRegistrationNumber } } ; else if (string.IsNullOrEmpty(updateVehicleMaster.EngineNumber) && string.IsNullOrEmpty(updateVehicleMaster.EngineNumber.Trim())) { return new VehicleMasterManagementResponse() { HasError = true, Message = "Engine number can't be empty", ErrorType = VehicleMasterManagementResponseType.EngineNumber } } ; else { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); var vehicles = await _iMSDbContext.VehicleMasters.Where(x => x.InstituteId == instituteId && x.Id != updateVehicleMaster.Id).ToListAsync(); if (vehicles.Any(x => x.VehicleCode.ToLowerInvariant() == updateVehicleMaster.VehicleCode.ToLowerInvariant())) { return new VehicleMasterManagementResponse() { HasError = true, Message = "Vehicle code already exist. Please use unique one", ErrorType = VehicleMasterManagementResponseType.VehicleCode } } ; else { var vehicle = await _iMSDbContext.VehicleMasters.FirstOrDefaultAsync(x => x.Id == updateVehicleMaster.Id); if (vehicle == null) { return new VehicleMasterManagementResponse() { HasError = true, Message = "Vehicle not found", ErrorType = VehicleMasterManagementResponseType.Id } } ; else { vehicle.AverageKMPL = updateVehicleMaster.AverageKMPL; vehicle.ChasisNumber = updateVehicleMaster.ChasisNumber; vehicle.EngineNumber = updateVehicleMaster.EngineNumber; vehicle.ExtraFittings = updateVehicleMaster.ExtraFittings; vehicle.FitnessExpDate = updateVehicleMaster.FitnessExpDate; vehicle.FuelType = EnumHelperService.GetValueFromDescription <VehicleMasterFuelTypeEnum>(updateVehicleMaster.FuelType); vehicle.InsuranceDate = updateVehicleMaster.InsuranceDate; vehicle.InsuranceExpDate = updateVehicleMaster.InsuranceExpDate; vehicle.InsuranceNumber = updateVehicleMaster.InsuranceNumber; vehicle.NextMaintenanceDate = updateVehicleMaster.NextMaintenanceDate; vehicle.PermitValidityDate = updateVehicleMaster.PermitValidityDate; vehicle.UpdatedById = loggedInUser.Id; vehicle.UpdatedOn = DateTime.UtcNow; vehicle.VehicleCode = updateVehicleMaster.VehicleCode; vehicle.VehicleRegistrationNumber = updateVehicleMaster.VehicleRegistrationNumber; vehicle.VehicleType = EnumHelperService.GetValueFromDescription <VehicleMasterTypeEnum>(updateVehicleMaster.VehicleType); _iMSDbContext.VehicleMasters.Update(vehicle); await _iMSDbContext.SaveChangesAsync(); return(new VehicleMasterManagementResponse() { HasError = false, Message = "Vehicle updated successfully" }); } } } }