public async Task <IActionResult> AddInstituteAsync([FromBody] AddInstituteAc addInstitute)
        {
            if (ModelState.IsValid)
            {
                if (!await _iMSDbContext.Institutes.AnyAsync(x => x.Code.ToLowerInvariant() == addInstitute.Code.ToLowerInvariant()))
                {
                    if (!await _iMSDbContext.Institutes.AnyAsync(x => x.Name.ToLowerInvariant() == addInstitute.InstituteName.ToLowerInvariant()))
                    {
                        await _instituteManagementRepository.AddInstituteAsync(addInstitute);

                        return(Ok(new InstituteResponseAc()
                        {
                            HasError = false, Message = "Added Successfully"
                        }));
                    }
                    else
                    {
                        return(Ok(new InstituteResponseAc {
                            ErrorType = InstituteResponseType.InstituteName, HasError = true, Message = "Institute with same name already exist"
                        }));
                    }
                }
                else
                {
                    return(Ok(new InstituteResponseAc {
                        ErrorType = InstituteResponseType.Code, HasError = true, Message = "Institute with same code already exist"
                    }));
                }
            }
            else
            {
                if (string.IsNullOrEmpty(addInstitute.InstituteName.Trim()))
                {
                    return(Ok(new InstituteResponseAc()
                    {
                        ErrorType = InstituteResponseType.InstituteName, HasError = true, Message = "Institute name can't be empty"
                    }));
                }
                else if (string.IsNullOrEmpty(addInstitute.Code.Trim()))
                {
                    return(Ok(new InstituteResponseAc()
                    {
                        ErrorType = InstituteResponseType.Code, HasError = true, Message = "Institute code can't be empty"
                    }));
                }
                else
                {
                    return(Ok(new InstituteResponseAc()
                    {
                        ErrorType = InstituteResponseType.InstituteAdminEmail, HasError = true, Message = "Email address can't be empty"
                    }));
                }
            }
        }
        /// <summary>
        /// Method to add institute - SS
        /// </summary>
        /// <param name="addInstitute">institute information</param>
        public async Task AddInstituteAsync(AddInstituteAc addInstitute)
        {
            var user = await _userManager.FindByEmailAsync(addInstitute.InstituteAdminEmail);

            var isUserExist    = (user != null);
            var randomPassword = RandomString();
            var superAdmin     = await _userManager.FindByEmailAsync(_superAdmin.Email);

            if (!isUserExist)
            {
                user = new ApplicationUser()
                {
                    CreatedOn = DateTime.UtcNow,
                    UpdatedOn = DateTime.UtcNow,
                    CreatedBy = superAdmin.Id,
                    UpdatedBy = superAdmin.Id,
                    Name      = "Admin",
                    Email     = addInstitute.InstituteAdminEmail,
                    UserName  = addInstitute.InstituteAdminEmail
                };
                await _userManager.CreateAsync(user, randomPassword);
            }
            await _userManager.AddToRoleAsync(user, "Admin");

            var institute = new Institute()
            {
                CreatedOn = DateTime.UtcNow,
                Name      = addInstitute.InstituteName,
                Address   = addInstitute.Address,
                Code      = addInstitute.Code,
                Location  = addInstitute.Location,
                AdminId   = user.Id,
                Latitude  = addInstitute.Latitude,
                Longitude = addInstitute.Longitude
            };

            _iMSDbContext.Institutes.Add(institute);
            await _iMSDbContext.SaveChangesAsync();

            #region User Institute Mapping
            var userInstituteMapping = new UserInstituteMapping()
            {
                CreatedOn   = DateTime.UtcNow,
                InstituteId = institute.Id,
                UserId      = user.Id,
                IsActive    = false
            };
            _iMSDbContext.UserInstituteMappings.Add(userInstituteMapping);
            await _iMSDbContext.SaveChangesAsync();

            List <UserInstituteMapping> users = new List <UserInstituteMapping>();
            foreach (var userId in addInstitute.Users)
            {
                if (!await _iMSDbContext.UserInstituteMappings.AnyAsync(x => x.InstituteId == institute.Id && x.UserId == userId))
                {
                    var userEmail = (await _iMSDbContext.Users.FirstAsync(x => x.Id == userId)).Email;
                    users.Add(new UserInstituteMapping()
                    {
                        CreatedOn   = DateTime.UtcNow,
                        InstituteId = institute.Id,
                        IsActive    = false,
                        UserId      = userId
                    });
                    if (!string.IsNullOrEmpty(userEmail))
                    {
                        await SendMailForExistingUser(new WelcomeMailToAdminAc()
                        {
                            Password = randomPassword, InstituteName = institute.Name
                        }, userEmail, institute.Id);
                    }
                }
            }
            _iMSDbContext.UserInstituteMappings.AddRange(users);
            await _iMSDbContext.SaveChangesAsync();

            #endregion
            var mapping = new List <InstituteBccCcEmailMapping>();
            addInstitute.Bcc.ForEach(x =>
            {
                mapping.Add(new InstituteBccCcEmailMapping()
                {
                    CreatedOn   = DateTime.UtcNow,
                    Email       = x,
                    InstituteId = institute.Id,
                    IsBcc       = true
                });
            });
            addInstitute.Cc.ForEach(x =>
            {
                mapping.Add(new InstituteBccCcEmailMapping()
                {
                    CreatedOn   = DateTime.UtcNow,
                    Email       = x,
                    InstituteId = institute.Id,
                    IsBcc       = false
                });
            });
            if (mapping.Count != 0)
            {
                _iMSDbContext.InstituteBccCcEmailMappings.AddRange(mapping);
                await _iMSDbContext.SaveChangesAsync();
            }
            await _teachingStaffManagementRepository.SeedTeachingStaffAsync(institute.Id);

            await _rolePermissionSeed.SeedPermissionAsync(institute.Id);

            await _disciplinaryStatusManagementRepository.SeedDisciplinaryStatusAsync(institute.Id);

            var adminUserGroup = await _iMSDbContext.UserGroups.FirstAsync(x => x.Code == "Admin");

            _iMSDbContext.UserGroupMapping.Add(new UserGroupMapping()
            {
                CreatedOn = DateTime.UtcNow, UserGroupId = adminUserGroup.Id, UserId = user.Id
            });
            await _iMSDbContext.SaveChangesAsync();

            if (!isUserExist)
            {
                await SendMailForNewUser(new WelcomeMailToAdminAc()
                {
                    Password = randomPassword, InstituteName = institute.Name
                }, addInstitute.InstituteAdminEmail, institute.Id);
            }
            else
            {
                await SendMailForExistingUser(new WelcomeMailToAdminAc()
                {
                    Password = randomPassword, InstituteName = institute.Name
                }, addInstitute.InstituteAdminEmail, institute.Id);
            }
        }