/// <summary> /// Method for fetching the list of users /// </summary> /// <returns></returns> public async Task <List <UserAc> > GetAllUsersAsync(ApplicationUser currentUser) { int currentUserInstituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(currentUser.Id, true); List <ApplicationUser> usersList = await _iMSDbContext.Users.ToListAsync(); List <UserAc> usersAcList = new List <UserAc>(); foreach (ApplicationUser user in usersList) { List <UserGroupMapping> userGroupMappingsList = await _iMSDbContext.UserGroupMapping.Include(x => x.UserGroup).Where(x => x.UserId.Equals(user.Id)).ToListAsync(); Institute userInstitute = (await _iMSDbContext.UserInstituteMappings.Include(x => x.Institute).FirstOrDefaultAsync(x => x.UserId.Equals(user.Id) && x.InstituteId == currentUserInstituteId))?.Institute; if (userGroupMappingsList.Count > 0) { if (userInstitute != null) { usersAcList.Add(new UserAc { Id = user.Id, Name = user.Name, InstituteId = userInstitute.Id, Institute = userInstitute.Name, Email = user.Email, UserGroupIdList = userGroupMappingsList.Select(x => x.UserGroupId).ToList(), UserGroup = string.Join(", ", userGroupMappingsList.Select(x => x.UserGroup.Name)) }); } } } return(usersAcList); }
public async Task <IActionResult> AddNewUserGroupAsync([FromBody] AddUserGroupAc newUserGroupAc) { ApplicationUser currentUser = await _userManager.FindByNameAsync(User.Identity.Name); int currentUserInstituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(currentUser.Id, true); UserGroup existingUserGroup = await _iMSDbContext.UserGroups.FirstOrDefaultAsync(x => x.Code.Equals(newUserGroupAc.Code) && x.InstituteId == currentUserInstituteId); if (existingUserGroup != null) { return(Ok(new { Message = "User Role already exists with this code", HasError = true })); } if (ModelState.IsValid) { await _userGroupManagementRepository.AddNewUserGroupAsync(newUserGroupAc, currentUser); return(Ok(new { Message = "New User Role Added Successfully" })); } else { if (string.IsNullOrEmpty(newUserGroupAc.Code)) { return(Ok(new { Message = "User Role Code can't be empty", HasError = true })); } else { return(Ok(new { Message = "User Role Name can't be empty", HasError = true })); } } }
/// <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(); }
/// <summary> /// Method for fetching the list of all activities /// </summary> /// <param name="currentUser"></param> /// <returns></returns> public async Task <List <StaffPlannerAc> > GetAllStaffPlansAsync(ApplicationUser currentUser) { int currentUserInstituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(currentUser.Id, true); List <StaffPlanner> staffPlansList = await _imsDbContext.StaffPlanners .Include(x => x.Staff) .Where(x => x.InstituteId == currentUserInstituteId).ToListAsync(); List <StaffPlannerAc> staffPlansListAc = new List <StaffPlannerAc>(); foreach (StaffPlanner staffPlan in staffPlansList) { staffPlansListAc.Add(new StaffPlannerAc { Id = staffPlan.Id, Name = staffPlan.Name, Description = staffPlan.Description, DateOfPlan = staffPlan.DateOfPlan, IsActive = staffPlan.IsActive, StaffId = staffPlan.StaffId, StaffName = staffPlan.Staff.FirstName, InstituteId = staffPlan.InstituteId }); } return(staffPlansListAc); }
/// <summary> /// Method for fetching the list off holidays by selected academic year /// </summary> /// <param name="academicYearId"></param> /// <returns></returns> public async Task <List <InstituteHolidayAc> > GetHolidaysByAcademicYearIdAsync(int academicYearId, ApplicationUser currentUser) { int currentUserInstituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(currentUser.Id, true); List <Holiday> holidaysList = await _imsDbContext.Holidays.Where(x => x.InstitutionId == currentUserInstituteId && x.AcademicYearId == academicYearId).ToListAsync(); List <InstituteHolidayAc> holidaysListAc = new List <InstituteHolidayAc>(); foreach (Holiday holiday in holidaysList) { holidaysListAc.Add(new InstituteHolidayAc { Id = holiday.Id, AcademicYearId = holiday.AcademicYearId, InstitutionId = holiday.InstitutionId, HolidayDate = holiday.HolidayDate, HolidayToDate = holiday.HolidayToDate, Description = holiday.Description, OccuranceType = holiday.OccuranceType, OccuranceTypeString = EnumHelperService.GetDescription(holiday.OccuranceType) }); } return(holidaysListAc); }
/// <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 for fetching the list of all activities - RS /// </summary> /// <param name="currentUser"></param> /// <returns></returns> public async Task <List <StaffActivityAc> > GetAllActivitiesAsync(ApplicationUser currentUser) { int currentUserInstituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(currentUser.Id, true); List <StaffActivity> staffActivitiesList = await _imsDbContext.StaffActivities .Include(x => x.MeetingAgenda) .Include(x => x.ActivityStatus) .Where(x => x.InstituteId == currentUserInstituteId).ToListAsync(); List <StaffActivityAc> staffActivitiesListAc = new List <StaffActivityAc>(); foreach (StaffActivity staffActivity in staffActivitiesList) { staffActivitiesListAc.Add(new StaffActivityAc { Id = staffActivity.Id, Name = staffActivity.Name, Description = staffActivity.Description, StartDate = staffActivity.StartDate, EndDate = staffActivity.EndDate, IsActive = staffActivity.IsActive, InstituteId = staffActivity.InstituteId, ActivityStatusId = staffActivity.ActivityStatusId, ActivityStatusName = staffActivity.ActivityStatus.Name, MeetingAgendaId = staffActivity.MeetingAgendaId, MeetingAgendaName = staffActivity.MeetingAgenda.Name, StartTime = staffActivity.StartTime, EndTime = staffActivity.EndTime, Location = staffActivity.Location }); } return(staffActivitiesListAc); }
/// <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(); } }
public async Task <IActionResult> AddorUpdateSelectedAcademicYearAsync(int academicYearId) { var user = await _userManager.FindByNameAsync(User.Identity.Name); var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(user.Id, true); if (await _iMSDbContext.InstituteAcademicYears.AnyAsync(x => x.Id == academicYearId && x.InstituteId == instituteId)) { var selected = await _iMSDbContext.SelectedAcademicYears.FirstOrDefaultAsync(x => x.UserId == user.Id && x.AcademicYear.InstituteId == instituteId); if (selected == null) { selected = new SelectedAcademicYear() { AcademicYearId = academicYearId, CreatedOn = DateTime.UtcNow, UserId = user.Id }; _iMSDbContext.SelectedAcademicYears.Add(selected); } else { selected.AcademicYearId = academicYearId; _iMSDbContext.SelectedAcademicYears.Update(selected); } await _iMSDbContext.SaveChangesAsync(); return(Ok()); } else { return(Ok(new { Message = "Academic year not found" })); } }
/// <summary> /// Method to update student fee - SS /// </summary> /// <param name="studentFeeComponents">student fee components</param> /// <param name="studentFeeId">student fee id</param> /// <param name="loggedInUser">logged in user</param> /// <returns>response</returns> public async Task <StudentFeeResponse> UpdateStudentFeeAsync(List <StudentFeeComponent> studentFeeComponents, int studentFeeId, ApplicationUser loggedInUser) { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); var studentFee = await _iMSDbContext.StudentFees.FirstOrDefaultAsync(x => x.Id == studentFeeId && x.Student.InstituteId == instituteId); if (studentFee == null) { return new StudentFeeResponse() { HasError = true, Message = "Student not found" } } ; else { studentFee.UpdatedById = loggedInUser.Id; studentFee.UpdatedOn = DateTime.UtcNow; _iMSDbContext.StudentFees.Update(studentFee); _iMSDbContext.StudentFeeComponents.UpdateRange(studentFeeComponents); await _iMSDbContext.SaveChangesAsync(); return(new StudentFeeResponse() { HasError = false, Message = "Student fee detail updated successfully" }); } }
/// <summary> /// Method to add vehicle repair - SS /// </summary> /// <param name="addVehicleRepair">vehicle repair</param> /// <param name="loggedInUser">logged in user</param> /// <returns>response</returns> public async Task <VehicleRepairManagementResponse> AddVehicleRepairAsync(AddVehicleRepairManagementAc addVehicleRepair, ApplicationUser loggedInUser) { if (string.IsNullOrEmpty(addVehicleRepair.Code.Trim())) { return new VehicleRepairManagementResponse() { HasError = true, Message = "Code can't be empty", ErrorType = VehicleRepairManagementResponseType.Code } } ; else { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); if (!await _iMSDbContext.VehicleMasters.AnyAsync(x => x.Id == addVehicleRepair.VehicleId && x.InstituteId == instituteId)) { return new VehicleRepairManagementResponse() { HasError = true, Message = "Vehicle not found", ErrorType = VehicleRepairManagementResponseType.VehicleId } } ; else { if (await _iMSDbContext.VehicleRepairs.AnyAsync(x => x.Code.ToLowerInvariant() == addVehicleRepair.Code.ToLowerInvariant() && x.Vehicle.InstituteId == instituteId)) { return new VehicleRepairManagementResponse() { HasError = true, Message = "Vehicle repair code already exist, Please use unique one", ErrorType = VehicleRepairManagementResponseType.Code } } ; else { var repair = new VehicleRepair() { Code = addVehicleRepair.Code, CreatedOn = DateTime.UtcNow, Remarks = addVehicleRepair.Remarks, RepairCost = addVehicleRepair.RepairCost, RepairDate = addVehicleRepair.RepairDate, UpdatedById = loggedInUser.Id, UpdatedOn = DateTime.UtcNow, VehicleId = addVehicleRepair.VehicleId }; _iMSDbContext.VehicleRepairs.Add(repair); await _iMSDbContext.SaveChangesAsync(); return(new VehicleRepairManagementResponse() { HasError = false, Message = "Vehicle repair added successfully" }); } } } }
/// <summary> /// Method to get list of student leaves - SS /// </summary> /// <param name="loggedInUser">loggedInUser</param> /// <returns></returns> public async Task <List <StudentLeave> > GetStudentLeavesAsync(ApplicationUser loggedInUser) { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); var currentAcademicYear = await _iMSDbContext.SelectedAcademicYears.FirstAsync(x => x.UserId == loggedInUser.Id && x.AcademicYear.InstituteId == instituteId); return(await _iMSDbContext.StudentLeaves.Include(s => s.ApprovedBy).Include(s => s.LeaveStatus).Include(s => s.Student) .Include(s => s.LeaveType).Where(x => x.Student.InstituteId == instituteId && x.AcademicYearId == currentAcademicYear.AcademicYearId).ToListAsync()); }
public async Task <IActionResult> GetActivityInitialData() { ApplicationUser currentUser = await _userManager.FindByNameAsync(User.Identity.Name); int currentUserInstituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(currentUser.Id, true); // Activity Status List <ActivityStatus> activityStatusList = await _activityStatusManagementRepository.GetAllActivityStatusAsync(currentUserInstituteId, currentUser); // Meeting Agenda List <MeetingAgenda> meetingAgendaList = await _meetingAgendaManagementRepository.GetAllMeetingAgendasAsync(currentUserInstituteId); // Staffs (Attendee) List <StaffBasicPersonalInformation> staffsList = await _imsDbContext.StaffBasicPersonalInformation.Where(x => x.InstituteId == currentUserInstituteId).ToListAsync(); // Students (Attendee) List <StudentBasicInformation> studentsList = await _staffActivityManagementRepository.GetAttendeeStudentsListAsync(currentUserInstituteId); // System Users (Attendee) List <UserAc> systemUsersList = await _staffActivityManagementRepository.GetAttendeeSystemUsersListAsync(currentUserInstituteId); return(Ok(new { MeetingAgendaList = meetingAgendaList, ActivityStatusList = activityStatusList, StaffsList = staffsList, StudentsList = studentsList, SystemUsersList = systemUsersList })); }
public async Task <IActionResult> GetAcademicYearsListAsync() { ApplicationUser currentUser = await _userManager.FindByNameAsync(User.Identity.Name); int currentUserInstituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(currentUser.Id, true); return(Ok(await _instituteAcademicYearManagementRepository.GetAcademicYearsListAsync(currentUserInstituteId))); }
/// <summary> /// Method to add and update vehicle driver mapping - SS /// </summary> /// <param name="vehicleDriverMapping">vehicle driver detail</param> /// <param name="loggedInUser">logged in user</param> /// <returns>response</returns> public async Task <VehicleDriverMappingResponse> AddOrUpdateVehicleDriverMappingAsync(AddOrUpdateVehicleDriverMappingAc vehicleDriverMapping, ApplicationUser loggedInUser) { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); if (!await _iMSDbContext.VehicleMasters.AnyAsync(x => x.InstituteId == instituteId && x.Id == vehicleDriverMapping.VehicleId)) { return new VehicleDriverMappingResponse() { HasError = true, Message = "Vehicle not found", ErrorType = VehicleDriverMappingResponseType.VehicleId } } ; else { var driverIds = vehicleDriverMapping.Drivers.Select(x => x.DriverId).Distinct().ToList(); var studentCount = await _iMSDbContext.DriverMasters.CountAsync(x => x.InstituteId == instituteId && driverIds.Contains(x.Id)); if (driverIds.Count != studentCount) { return new VehicleDriverMappingResponse() { HasError = true, Message = "Driver not found", ErrorType = VehicleDriverMappingResponseType.DriverId } } ; else { var previous = await _iMSDbContext.VehicleDriverMappings.Where(x => x.VehicleId == vehicleDriverMapping.VehicleId).ToListAsync(); _iMSDbContext.VehicleDriverMappings.RemoveRange(previous); await _iMSDbContext.SaveChangesAsync(); List <DomainModel.Models.VehicleDriverMapping> vehicleDriverMappings = new List <DomainModel.Models.VehicleDriverMapping>(); foreach (var driver in vehicleDriverMapping.Drivers) { vehicleDriverMappings.Add(new DomainModel.Models.VehicleDriverMapping() { CreatedOn = DateTime.UtcNow, DriverId = driver.DriverId, IsPrimary = driver.IsPrimary, VehicleId = vehicleDriverMapping.VehicleId, UpdatedById = loggedInUser.Id }); } _iMSDbContext.VehicleDriverMappings.AddRange(vehicleDriverMappings); await _iMSDbContext.SaveChangesAsync(); return(new VehicleDriverMappingResponse() { HasError = false, Message = "Vehicle driver detail updated successfully" }); } } }
/// <summary> /// Method to add and update student route mapping - SS /// </summary> /// <param name="studentRouteMapping">student route detail</param> /// <param name="loggedInUser">logged in user</param> /// <returns>response</returns> public async Task <StudentRouteMappingResponse> AddOrUpdateStudentRouteMappingAsync(AddOrUpdateStudentRouteMappingAc studentRouteMapping, ApplicationUser loggedInUser) { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); if (!await _iMSDbContext.Routes.AnyAsync(x => x.InstituteId == instituteId && x.Id == studentRouteMapping.RouteId)) { return new StudentRouteMappingResponse() { HasError = true, Message = "Route not found", ErrorType = StudentRouteMappingResponseType.RouteId } } ; else { var studentIds = studentRouteMapping.StudentIds.Distinct().ToList(); var studentCount = await _iMSDbContext.StudentBasicInformation.CountAsync(x => x.InstituteId == instituteId && studentIds.Contains(x.Id)); if (studentIds.Count != studentCount) { return new StudentRouteMappingResponse() { HasError = true, Message = "Student not found", ErrorType = StudentRouteMappingResponseType.StudentId } } ; else { var previous = await _iMSDbContext.StudentRouteMappings.Where(x => x.RouteId == studentRouteMapping.RouteId).ToListAsync(); _iMSDbContext.StudentRouteMappings.RemoveRange(previous); await _iMSDbContext.SaveChangesAsync(); List <DomainModel.Models.StudentRouteMapping> studentRouteMappings = new List <DomainModel.Models.StudentRouteMapping>(); foreach (var student in studentRouteMapping.StudentIds) { studentRouteMappings.Add(new DomainModel.Models.StudentRouteMapping() { CreatedOn = DateTime.UtcNow, RouteId = studentRouteMapping.RouteId, StudentId = student, UpdatedById = loggedInUser.Id }); } _iMSDbContext.StudentRouteMappings.AddRange(studentRouteMappings); await _iMSDbContext.SaveChangesAsync(); return(new StudentRouteMappingResponse() { HasError = false, Message = "Student route detail updated successfully" }); } } }
/// <summary> /// Method to add vehicle break down - SS /// </summary> /// <param name="addVehicleBreakDown">vehicle break down</param> /// <param name="loggedInUser">logged in user</param> /// <returns>response</returns> public async Task<VehicleBreakDownManagementResponse> AddVehicleBreakDownAsync(AddVehicleBreakDownManagementAc addVehicleBreakDown, ApplicationUser loggedInUser) { if (string.IsNullOrEmpty(addVehicleBreakDown.Code.Trim())) return new VehicleBreakDownManagementResponse() { HasError = true, Message = "Code can't be empty", ErrorType = VehicleBreakDownManagementResponseType.Code }; else { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); if (!await _iMSDbContext.VehicleMasters.AnyAsync(x => x.Id == addVehicleBreakDown.VehicleId && x.InstituteId == instituteId)) return new VehicleBreakDownManagementResponse() { HasError = true, Message = "Vehicle not found", ErrorType = VehicleBreakDownManagementResponseType.VehicleId }; else { if (!await _iMSDbContext.DriverMasters.AnyAsync(x => x.Id == addVehicleBreakDown.DriverId && x.InstituteId == instituteId)) return new VehicleBreakDownManagementResponse() { HasError = true, Message = "Driver not found", ErrorType = VehicleBreakDownManagementResponseType.DriverId }; else { if (await _iMSDbContext.VehicleBreakDowns.AnyAsync(x => x.Code.ToLowerInvariant() == addVehicleBreakDown.Code.ToLowerInvariant() && x.Vehicle.InstituteId == instituteId)) return new VehicleBreakDownManagementResponse() { HasError = true, Message = "Vehicle break down code already exist. Please use unique one", ErrorType = VehicleBreakDownManagementResponseType.Code }; else { var BreakDown = new VehicleBreakDown() { BreakDownDate = addVehicleBreakDown.BreakDownDate, Address = addVehicleBreakDown.Address, Code = addVehicleBreakDown.Code, CreatedOn = DateTime.UtcNow, DriverId = addVehicleBreakDown.DriverId, BreakDownDuration = addVehicleBreakDown.BreakDownDuration, UpdatedById = loggedInUser.Id, UpdatedOn = DateTime.UtcNow, VehicleId = addVehicleBreakDown.VehicleId }; _iMSDbContext.VehicleBreakDowns.Add(BreakDown); await _iMSDbContext.SaveChangesAsync(); return new VehicleBreakDownManagementResponse() { HasError = false, Message = "Vehicle break down added successfully" }; } } } } }
/// <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 override void OnActionExecuting(ActionExecutingContext context) { _iMSDbContext = context.HttpContext.RequestServices.GetService <IMSDbContext>(); _userManager = context.HttpContext.RequestServices.GetService <UserManager <ApplicationUser> >(); _instituteUserMappingHelperService = context.HttpContext.RequestServices.GetService <IInstituteUserMappingHelperService>(); switch (context.HttpContext.Request.Method) { case "GET": ActionFilterType = ActionFilterType.View; break; case "POST": ActionFilterType = ActionFilterType.Add; break; case "PUT": ActionFilterType = ActionFilterType.Edit; break; case "DELETE": ActionFilterType = ActionFilterType.Delete; break; } ; var instituteId = _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(context.HttpContext.User.Identity.Name, false).Result; var userId = (_userManager.FindByNameAsync(context.HttpContext.User.Identity.Name).Result).Id; var userGroups = (_iMSDbContext.UserGroupMapping.Where(x => x.UserId == userId).Select(x => x.UserGroup.Id).ToListAsync()).Result; var permissions = _iMSDbContext.UserGroupFeatures.Where(x => userGroups.Contains(x.UserGroupId)).ToList(); var permission = permissions.FirstOrDefault(x => x.UserGroupFeatureChild == UserGroupFeatureChild); if (permission == null) { context.HttpContext.Response.StatusCode = 401; context.HttpContext.Response.Headers.Clear(); var wrongResult = new { Error = "UnAuthorized" }; context.Result = new JsonResult(wrongResult); } else { var isAllowed = false; switch (context.HttpContext.Request.Method) { case "GET": isAllowed = permission.CanView; break; case "POST": isAllowed = permission.CanAdd; break; case "PUT": isAllowed = permission.CanEdit; break; case "DELETE": isAllowed = permission.CanDelete; break; } ; if (!isAllowed) { context.HttpContext.Response.StatusCode = 401; context.HttpContext.Response.Headers.Clear(); var wrongResult = new { Error = "UnAuthorized" }; context.Result = new JsonResult(wrongResult); } } }
/// <summary> /// Method for fetching the list of all mother tongues /// </summary> /// <param name="currentUser"></param> /// <returns></returns> public async Task <List <MotherTongueAc> > GetAllMotherTonguesAsync(ApplicationUser currentUser) { int currentUserInstituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(currentUser.Id, true); List <MotherTongue> motherTonguesList = await _imsDbContext.MotherTongues.Where(x => x.InstituteId == currentUserInstituteId).ToListAsync(); List <MotherTongueAc> motherTonguesListAc = new List <MotherTongueAc>(); foreach (MotherTongue motherTongue in motherTonguesList) { motherTonguesListAc.Add(new MotherTongueAc { Id = motherTongue.Id, Name = motherTongue.Language, Code = motherTongue.Code, Description = motherTongue.Description, Status = motherTongue.Status, CreatedOn = motherTongue.CreatedOn }); } return(motherTonguesListAc); }
/// <summary> /// Method for fetching the week offs by academic year id /// </summary> /// <param name="academicYearId"></param> /// <returns></returns> public async Task <List <InstituteWeekOffAc> > GetWeekOffsByAcademicYearIdAsync(int academicYearId, ApplicationUser currentUser) { int currentUserInstituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(currentUser.Id, true); List <WeekOff> weekOffsList = await _imsDbContext.WeekOffs.Where(x => x.AcademicYearId == academicYearId && x.InstitutionId == currentUserInstituteId).ToListAsync(); List <WeekDaysEnum> weekDaysEnumList = EnumHelperService.GetEnumValuesList <WeekDaysEnum>(); List <InstituteWeekOffAc> weekOffsListAc = new List <InstituteWeekOffAc>(); foreach (WeekDaysEnum weekDay in weekDaysEnumList) { weekOffsListAc.Add(new InstituteWeekOffAc { AcademicYearId = academicYearId, InstitutionId = currentUserInstituteId, WeekDay = weekDay, WeekDayString = EnumHelperService.GetDescription(weekDay), IsWeekOff = weekOffsList.Any(x => x.WeekDay == weekDay) }); } return(weekOffsListAc); }
/// <summary> /// Method for fetching the class-subject mappings by class id /// </summary> /// <param name="classId"></param> /// <param name="currentUser"></param> /// <returns></returns> public async Task <Tuple <List <StaffBasicPersonalInformation>, List <ClassSubjectMappingAc> > > GetClassSubjectMappingByClassIdAsync(int classId, ApplicationUser currentUser) { int currentUserInstituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(currentUser.Id, true); List <ClassSubjectMappingAc> classSubjectMappingListAc = new List <ClassSubjectMappingAc>(); InstituteClass instituteClass = await _imsDbContext.InstituteClasses.FirstAsync(x => x.Id == classId); List <InstituteClassSubjectMapping> classSubjectMappingsList = await _imsDbContext.InstituteClassSubjectMappings .Include(x => x.InstituteClass) .Include(x => x.InstituteSubject) .Include(x => x.Faculty.User) .Include(x => x.AlternateFaculty.User) .Where(x => x.ClassId == classId && x.InstituteClass.InstituteId == currentUserInstituteId && x.InstituteSubject.InstituteId == currentUserInstituteId).ToListAsync(); List <InstituteSubject> subjectsList = await _instituteSubjectManagementRepository.GetAllInstituteSubjectsAsync(currentUserInstituteId); List <StaffBasicPersonalInformation> facultiesList = await _imsDbContext.StaffBasicPersonalInformation .Where(x => x.InstituteId == currentUserInstituteId && x.IsTeachingStaff) .ToListAsync(); // Find mappings foreach (InstituteSubject subject in subjectsList) { ClassSubjectMappingAc classSubjectMappingAc = new ClassSubjectMappingAc { ClassId = classId, ClassName = instituteClass.Name, SubjectId = subject.Id, SubjectName = subject.Name, IsMapped = classSubjectMappingsList.Any(x => x.ClassId == classId && x.SubjectId == subject.Id) }; if (classSubjectMappingAc.IsMapped) { InstituteClassSubjectMapping classSubjectMapping = classSubjectMappingsList.First(x => x.ClassId == classId && x.SubjectId == subject.Id); classSubjectMappingAc.Id = classSubjectMapping.Id; classSubjectMappingAc.FacultyId = classSubjectMapping.FacultyId; classSubjectMappingAc.AlternateFacultyId = classSubjectMapping.AlternateFacultyId; classSubjectMappingAc.FacultyName = classSubjectMapping.Faculty.FirstName; classSubjectMappingAc.AlternateFacultyName = classSubjectMapping.AlternateFaculty.FirstName; } classSubjectMappingListAc.Add(classSubjectMappingAc); } return(new Tuple <List <StaffBasicPersonalInformation>, List <ClassSubjectMappingAc> >(facultiesList, classSubjectMappingListAc)); }
/// <summary> /// Method to get list of student promotion - SS /// </summary> /// <param name="loggedInUser">loggedInUser</param> /// <returns>list of promoted student</returns> public async Task <List <StudentPromotionMapping> > GetAllStudentPromotionAsync(ApplicationUser loggedInUser) { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); var academicYear = await _iMSDbContext.SelectedAcademicYears.FirstOrDefaultAsync(x => x.UserId == loggedInUser.Id && x.AcademicYear.InstituteId == instituteId); var list = (await _iMSDbContext.StudentPromotionMappings.Include(a => a.Student).Include(a => a.CurrentClass) .Include(a => a.CurrentSection).Include(a => a.PromotedToClass).Include(a => a.PromotedToSection) .Where(x => x.Student.InstituteId == instituteId).ToListAsync()); if (academicYear != null) { list = list.Where(x => x.Student.CurrentAcademicYearId == academicYear.AcademicYearId).ToList(); } return(list); }
/// <summary> /// Method to add or update homework - SS /// </summary> /// <param name="homeWork">home work</param> /// <param name="loggedInUser">logged in user</param> /// <returns>response</returns> public async Task <HomeworkManagementResponse> AddOrUpdateHomeworkAsync(AddHomeworkManagementAc homeWork, ApplicationUser loggedInUser) { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); if (!await _iMSDbContext.StaffBasicPersonalInformation.AnyAsync(x => x.Id == homeWork.StaffId && x.InstituteId == instituteId)) { return new HomeworkManagementResponse() { Message = "Staff not found", HasError = true, ErrorType = HomeworkManagementReponseType.StaffId } } ; else if (!await _iMSDbContext.InstituteClasses.AnyAsync(x => x.Id == homeWork.ClassId && x.InstituteId == instituteId)) { return new HomeworkManagementResponse() { Message = "Class not found", HasError = true, ErrorType = HomeworkManagementReponseType.ClassId } } ; else if (!await _iMSDbContext.Sections.AnyAsync(x => x.Id == homeWork.SectionId && x.InstituteId == instituteId)) { return new HomeworkManagementResponse() { Message = "Section not found", HasError = true, ErrorType = HomeworkManagementReponseType.SectionId } } ; else { var subjectIds = homeWork.HomeworkSubjectMappings.Select(x => x.SubjectId).Distinct().ToList(); var subjectCount = await _iMSDbContext.InstituteClassSubjectMappings.CountAsync(x => subjectIds.Contains(x.SubjectId) && x.ClassId == homeWork.ClassId && x.FacultyId == homeWork.StaffId || x.AlternateFacultyId == homeWork.StaffId); if (subjectIds.Count != subjectCount) { return new HomeworkManagementResponse() { Message = "Subject not found", HasError = true, ErrorType = HomeworkManagementReponseType.SubjectId } } ; else { var homeworkTexts = homeWork.HomeworkSubjectMappings.Select(x => x.HomeworkData).ToList(); if (homeworkTexts.Any(x => string.IsNullOrEmpty(x.Trim()))) { return new HomeworkManagementResponse() { Message = "Home can't be empty", HasError = true, ErrorType = HomeworkManagementReponseType.HomeworkData } } ; else { var homework = await _iMSDbContext.Homeworks.FirstOrDefaultAsync(x => x.ClassId == homeWork.ClassId && x.StaffId == homeWork.StaffId && x.SectionId == homeWork.SectionId && x.HomeworkDate == homeWork.HomeworkDate); if (homework == null) { homework = new Homework() { ClassId = homeWork.ClassId, CreatedOn = DateTime.UtcNow, HomeworkDate = homeWork.HomeworkDate, SectionId = homeWork.SectionId, StaffId = homeWork.StaffId, UpdatedById = loggedInUser.Id, UpdatedOn = DateTime.UtcNow }; _iMSDbContext.Homeworks.Add(homework); await _iMSDbContext.SaveChangesAsync(); } else { homework.UpdatedById = loggedInUser.Id; homework.UpdatedOn = DateTime.UtcNow; _iMSDbContext.Homeworks.Update(homework); await _iMSDbContext.SaveChangesAsync(); var previousHomeWorkSubjects = await _iMSDbContext.HomeworkSubjectMappings.Where(x => x.HomeworkId == homework.Id).ToListAsync(); if (previousHomeWorkSubjects.Count != 0) { using (var db = await _iMSDbContext.Database.BeginTransactionAsync()) { await _iMSDbContext.BulkDeleteAsync(previousHomeWorkSubjects); db.Commit(); } } } List <HomeworkSubjectMapping> homeworkSubjects = new List <HomeworkSubjectMapping>(); foreach (var homeworkSubject in homeWork.HomeworkSubjectMappings) { homeworkSubjects.Add(new HomeworkSubjectMapping() { CreatedOn = DateTime.UtcNow, HomeworkData = homeworkSubject.HomeworkData, HomeworkId = homework.Id, IsSelected = homeworkSubject.IsSelected, SubjectId = homeworkSubject.SubjectId }); } using (var db = await _iMSDbContext.Database.BeginTransactionAsync()) { await _iMSDbContext.BulkInsertAsync(homeworkSubjects); db.Commit(); } // Set bell notification await SendBellNotificationOnHomewordCreation(homeWork, loggedInUser, instituteId); return(new HomeworkManagementResponse() { HasError = false, Message = "Homework updated successfully", Data = new { Id = homework.Id } }); } } } }
/// <summary> /// Method for fetching the details of an academic year by id /// </summary> /// <param name="id"></param> /// <returns></returns> public async Task <InstituteAcademicYear> GetAcademicYearByIdAsync(int id, ApplicationUser currentUser) { int currentUserInstituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(currentUser.Id, true); return(await _imsDbContext.InstituteAcademicYears.FirstOrDefaultAsync(x => x.Id == id && x.InstituteId == currentUserInstituteId)); }
/// <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 add disciplinary - SS /// </summary> /// <param name="addDisciplinary">disciplinary</param> /// <param name="loggedInUser">logged in user</param> /// <returns>response</returns> public async Task <DisciplinaryManagementResponse> AddDisciplinaryAsync(AddDisciplinaryManagementAc addDisciplinary, ApplicationUser loggedInUser) { if (string.IsNullOrEmpty(addDisciplinary.Subject.Trim())) { return new DisciplinaryManagementResponse() { HasError = true, Message = "Subject can't be empty", ErrorType = DisciplinaryManagementResponseType.Subject } } ; else if (string.IsNullOrEmpty(addDisciplinary.Description.Trim())) { return new DisciplinaryManagementResponse() { HasError = true, Message = "Description can't be empty", ErrorType = DisciplinaryManagementResponseType.Description } } ; else { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); var studentsCount = await _iMSDbContext.StudentBasicInformation.CountAsync(x => addDisciplinary.StudentIds .Contains(x.Id) && x.InstituteId == instituteId); if (studentsCount != addDisciplinary.StudentIds.Count) { return new DisciplinaryManagementResponse() { HasError = true, Message = "Student not found", ErrorType = DisciplinaryManagementResponseType.StudentId } } ; else { if (!await _iMSDbContext.DisciplinaryStatuses.AnyAsync(x => x.InstituteId == instituteId && x.Id == addDisciplinary.StatusId)) { return new DisciplinaryManagementResponse() { HasError = true, Message = "Status not found", ErrorType = DisciplinaryManagementResponseType.StatusId } } ; else { List <Disciplinary> disciplinaries = new List <Disciplinary>(); foreach (var studentId in addDisciplinary.StudentIds) { disciplinaries.Add(new Disciplinary() { CreatedOn = DateTime.UtcNow, Date = addDisciplinary.Date, Description = addDisciplinary.Description, Remarks = addDisciplinary.Remarks, StatusId = addDisciplinary.StatusId, StudentId = studentId, Subject = addDisciplinary.Subject, UpdatedById = loggedInUser.Id, UpdatedOn = DateTime.UtcNow }); } using (var db = await _iMSDbContext.Database.BeginTransactionAsync()) { await _iMSDbContext.BulkInsertAsync(disciplinaries); db.Commit(); } return(new DisciplinaryManagementResponse() { HasError = false, Message = "Disciplinary added successfully", Data = disciplinaries.Select(s => s.Id) }); } } } }
/// <summary> /// Method to add fee refund - SS /// </summary> /// <param name="addFeeRefund">fee refund</param> /// <param name="loggedInUser">logged in user</param> /// <returns>response</returns> public async Task <FeeRefundManagementResponse> AddFeeRefundAsync(AddFeeRefundManagementAc addFeeRefund, ApplicationUser loggedInUser) { await semaphore.WaitAsync(); try { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); if (!await _iMSDbContext.StudentBasicInformation.AnyAsync(x => x.Id == addFeeRefund.StudentId && x.InstituteId == instituteId)) { return new FeeRefundManagementResponse() { HasError = true, Message = "Student not found", ErrorType = FeeRefundManagementErrorType.StudentId } } ; else if (!await _iMSDbContext.UserInstituteMappings.AnyAsync(x => x.InstituteId == instituteId && x.UserId == addFeeRefund.IssuedById)) { return new FeeRefundManagementResponse() { HasError = true, Message = "Issued-by user not found", ErrorType = FeeRefundManagementErrorType.IssuedById } } ; else { if (string.IsNullOrEmpty(addFeeRefund.RefundNumber.Trim())) { return new FeeRefundManagementResponse() { HasError = true, Message = "Refund number can't be empty", ErrorType = FeeRefundManagementErrorType.RefundNumber } } ; else if (string.IsNullOrEmpty(addFeeRefund.ChallanNumber.Trim())) { return new FeeRefundManagementResponse() { HasError = true, Message = "Challan number can't be empty", ErrorType = FeeRefundManagementErrorType.ChallanNumber } } ; else if (string.IsNullOrEmpty(addFeeRefund.ChequeNumber.Trim())) { return new FeeRefundManagementResponse() { HasError = true, Message = "Cheque number can't be empty", ErrorType = FeeRefundManagementErrorType.ChequeNumber } } ; else if (string.IsNullOrEmpty(addFeeRefund.BankName.Trim())) { return new FeeRefundManagementResponse() { HasError = true, Message = "Bank name can't be empty", ErrorType = FeeRefundManagementErrorType.BankName } } ; else if (double.IsNaN(addFeeRefund.Amount)) { return new FeeRefundManagementResponse() { HasError = true, Message = "Amount number can't be empty and should be number", ErrorType = FeeRefundManagementErrorType.Amount } } ; else { if (await _iMSDbContext.FeeRefunds.AnyAsync(x => x.RefundNumber.ToLowerInvariant() == addFeeRefund.RefundNumber.ToLowerInvariant())) { var autoSequence = await _iMSDbContext.AutoSequenceGenerators.Include(s => s.AutoSequenceGeneratorDataTypes) .Include(d => d.Institute).FirstOrDefaultAsync(x => x.InstituteId == instituteId && x.AutoSequenceGeneratorType == AutoSequenceGeneratorTypeEnum.RefundNumber); if (autoSequence == null) { return new FeeRefundManagementResponse() { Message = "Refund number already exist. Please use unique id", HasError = true, ErrorType = FeeRefundManagementErrorType.RefundNumber } } ; else { addFeeRefund.RefundNumber = await GenerateRefundNumberAsync(autoSequence); } } var refund = new FeeRefund() { Amount = addFeeRefund.Amount, BankName = addFeeRefund.BankName, ChallanNumber = addFeeRefund.ChallanNumber, ChequeDate = addFeeRefund.ChequeDate, ChequeNumber = addFeeRefund.ChequeNumber, CreatedOn = DateTime.UtcNow, IssuedById = addFeeRefund.IssuedById, RefundDate = addFeeRefund.RefundDate, RefundNumber = addFeeRefund.RefundNumber, Remark = addFeeRefund.Remark, StudentId = addFeeRefund.StudentId, UpdatedById = loggedInUser.Id, UpdatedOn = DateTime.UtcNow }; _iMSDbContext.FeeRefunds.Add(refund); await _iMSDbContext.SaveChangesAsync(); return(new FeeRefundManagementResponse() { HasError = false, Message = "Fee refund detail added successfully" }); } } } finally { semaphore.Release(); } }
/// <summary> /// Method to add class exam - SS /// </summary> /// <param name="addClassExam">class exam</param> /// <param name="loggedInUser">logged in user</param> /// <returns>response</returns> public async Task <ClassExamResponse> AddClassExamAsync(AddClassExamAc addClassExam, ApplicationUser loggedInUser) { var instituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(loggedInUser.Id, true); if (!await _iMSDbContext.InstituteClasses.AnyAsync(x => x.Id == addClassExam.ClassId && x.InstituteId == instituteId)) { return new ClassExamResponse() { HasError = true, Message = "Class not found", ErrorType = ClassExamResponseType.ClassId } } ; else if (!await _iMSDbContext.Sections.AnyAsync(x => x.Id == addClassExam.SectionId && x.InstituteId == instituteId)) { return new ClassExamResponse() { HasError = true, Message = "Section not found", ErrorType = ClassExamResponseType.SectionId } } ; else if (!await _iMSDbContext.ExamDefinitions.AnyAsync(x => x.Id == addClassExam.ExamId && x.InstituteId == instituteId)) { return new ClassExamResponse() { HasError = true, Message = "Exam not found", ErrorType = ClassExamResponseType.ExamId } } ; else { var subjectIds = addClassExam.ClassExamSubjectMappings.Select(x => x.SubjectId).Distinct().ToList(); var subjectCount = await _iMSDbContext.InstituteSubjects.CountAsync(x => subjectIds.Contains(x.Id)); if (subjectIds.Count != subjectCount) { return new ClassExamResponse() { HasError = true, Message = "Subject not found", ErrorType = ClassExamResponseType.SubjectId } } ; else { var classExam = new ClassExam() { ClassId = addClassExam.ClassId, CreatedOn = DateTime.UtcNow, ExamId = addClassExam.ExamId, SectionId = addClassExam.SectionId, TotalAttendanceDays = addClassExam.TotalAttendanceDays, UpdatedById = loggedInUser.Id, UpdatedOn = DateTime.UtcNow }; _iMSDbContext.ClassExams.Add(classExam); await _iMSDbContext.SaveChangesAsync(); List <ClassExamSubjectMapping> classExamSubjects = new List <ClassExamSubjectMapping>(); foreach (var subject in addClassExam.ClassExamSubjectMappings) { classExamSubjects.Add(new ClassExamSubjectMapping() { ClassExamId = classExam.Id, Content = subject.Content, CreatedOn = DateTime.UtcNow, EndTime = subject.EndTime, MaxScore = subject.MaxScore, MinScore = subject.MinScore, Remark = subject.Remark, StartDate = subject.StartDate, StartTime = subject.StartTime, SubjectId = subject.SubjectId }); } _iMSDbContext.ClassExamSubjectMappings.AddRange(classExamSubjects); await _iMSDbContext.SaveChangesAsync(); return(new ClassExamResponse() { HasError = false, Message = "Class exam detail added successfully" }); } } }
/// <summary> /// Method for fetching the list of all designations /// </summary> /// <param name="currentUser"></param> /// <returns></returns> public async Task <List <Designation> > GetAllDesignationsAsync(ApplicationUser currentUser) { int currentUserInstituteId = await _instituteUserMappingHelperService.GetUserCurrentSelectedInstituteIdAsync(currentUser.Id, true); return(await _imsDbContext.Designations.Where(x => x.InstituteId == currentUserInstituteId).ToListAsync()); }