/// <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"
});
}
}
}
}
