public async Task <IActionResult> AddEmployee(RegistrationViewModel userRegVM)
        {
            try
            {
                //Check Email first
                var emailToCheck = userRegVM.Email;
                var emailVal     = _unitOfWork.Employee.GetSingleOrDefault(e => e.Email == emailToCheck);
                if (emailVal == null)
                {
                    string tempPassword   = DateTime.Now.ToString("ffff");
                    string userName       = userRegVM.FirstName.Substring(0, 1).ToLower() + userRegVM.MiddleName.Substring(0, 1).ToLower() + userRegVM.LastName.Replace(" ", "").ToLower();
                    int    iUserNameCount = _unitOfWork.Employee.Find(u => u.UserName.Contains(userName)).ToList().Count();
                    if (iUserNameCount > 0)
                    {
                        iUserNameCount += 1;
                        userName       += iUserNameCount.ToString();
                    }

                    tempPassword = userName + tempPassword;

                    userRegVM.CustomUserName = userName;
                    userRegVM.Password       = tempPassword;
                    userRegVM.PasswordRaw    = tempPassword;
                    userRegVM.IsEnabled      = true;

                    //Create User
                    userRegVM.DOB = Utilities.FormatDateTimeByZone(userRegVM.DOB.Value);
                    userRegVM.DOJ = Utilities.FormatDateTimeByZone(userRegVM.DOJ.Value);
                    var userIdentity = mapper.Map <RegistrationViewModel, AppUser>(userRegVM);
                    userIdentity.Id = Guid.NewGuid().ToString();
                    var result = await _userManager.CreateAsync(userIdentity, tempPassword);

                    if (!result.Succeeded)
                    {
                        return(new BadRequestObjectResult(Errors.AddError(result.ToString(), ModelState)));
                    }

                    //Get user to add roles to user
                    var user = await _userManager.FindByIdAsync(userIdentity.Id);

                    //Add Roles to user
                    IdentityRole adminUserRole = null;
                    if (userRegVM.Roles.RoleName.ToLower().Equals(Permissions.Roles.USER))
                    {
                        //User: Data in Roles Table
                        adminUserRole = await _roleManager.FindByNameAsync(Permissions.Roles.USER);

                        if (adminUserRole == null)
                        {
                            adminUserRole = new IdentityRole(Permissions.Roles.USER);
                            await _roleManager.CreateAsync(adminUserRole);
                        }

                        //Add Claims to user
                        for (int i = 0; i <= userRegVM.Roles.RoleClaims.Length - 1; i++)
                        {
                            string roleClaims = userRegVM.Roles.RoleClaims[i].ToString();
                            switch (roleClaims)
                            {
                            case Permissions.RolePermission.Add:
                            {
                                await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.Add));

                                break;
                            }

                            case Permissions.RolePermission.Edit:
                            {
                                await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.Edit));

                                break;
                            }

                            case Permissions.RolePermission.View:
                            {
                                await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.View));

                                break;
                            }

                            case Permissions.RolePermission.Delete:
                            {
                                await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.Delete));

                                break;
                            }

                            default:
                            {
                                break;
                            }
                            }
                        }
                    }
                    else
                    {
                        //Admin: Data in Roles Table
                        adminUserRole = await _roleManager.FindByNameAsync(Permissions.Roles.ADMIN);

                        if (adminUserRole == null)
                        {
                            adminUserRole = new IdentityRole(Permissions.Roles.ADMIN);
                            await _roleManager.CreateAsync(adminUserRole);
                        }

                        //Add Claims to Admin
                        await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Admins.CRUD));
                    }

                    //Add Roles to user
                    if (!await _userManager.IsInRoleAsync(user, adminUserRole.Name))
                    {
                        await _userManager.AddToRoleAsync(user, adminUserRole.Name);
                    }

                    //Add Contact
                    ContactResourseViewModel contactVM = userRegVM.Contact;
                    var empContact = mapper.Map <ContactResourseViewModel, Data.ContactResourse>(contactVM);
                    empContact.Id         = Guid.NewGuid().ToString();
                    empContact.RefTableId = userIdentity.Id;
                    _unitOfWork.ContactResource.Add(empContact);

                    //Add Region according to UserID and HQ
                    HQRegionViewModel HQRegionVM = null;
                    foreach (var rgn in userRegVM.Region)
                    {
                        HQRegionVM = new HQRegionViewModel
                        {
                            HQID     = userRegVM.HQ,
                            UserID   = userIdentity.Id,
                            RegionID = rgn
                        };

                        var empHQRegion = mapper.Map <HQRegionViewModel, Data.Hqregion>(HQRegionVM);
                        _unitOfWork.HQRegion.Add(empHQRegion);
                    }

                    await _unitOfWork.CompleteAsync();
                }
                else
                {
                    return(BadRequest(Errors.AddError("Email Already Exists.", ModelState)));
                }
            }
            catch (Exception Ex)
            {
                return(new BadRequestObjectResult(Errors.AddError(Ex, ModelState)));
            }
            return(new OkObjectResult(userRegVM));
        }
        public async Task <IActionResult> EditEmployee(RegistrationViewModel userRegVM)
        {
            try
            {
                var origionalData = _unitOfWork.Employee.GetSingleOrDefault(e => e.Id == userRegVM.ID);
                if (origionalData != null)
                {
                    //update AspNetusers Table
                    origionalData.DOB          = Utilities.FormatDateTimeByZone(userRegVM.DOB.Value);
                    origionalData.DOJ          = Utilities.FormatDateTimeByZone(userRegVM.DOJ.Value);
                    origionalData.Department   = (int)userRegVM.Department;
                    origionalData.Desigination = (int)userRegVM.Desigination;
                    origionalData.Grade        = (int)userRegVM.Grade;
                    origionalData.HQ           = (int)userRegVM.HQ;
                    origionalData.Pancard      = userRegVM.Pancard;

                    _unitOfWork.Employee.Update(origionalData);

                    //Get user
                    var user = await _userManager.FindByIdAsync(userRegVM.ID);

                    //Get claims & Remove it
                    var userClaims = await _userManager.GetClaimsAsync(user);

                    foreach (Claim claim in userClaims)
                    {
                        await _userManager.RemoveClaimAsync(user, claim);
                    }

                    //Get Roles & Remove it
                    var userRole = await _userManager.GetRolesAsync(user);

                    foreach (var role in userRole)
                    {
                        await _userManager.RemoveFromRoleAsync(user, role);
                    }


                    //Add Roles to user
                    IdentityRole adminUserRole = null;
                    if (userRegVM.Roles.RoleName.ToLower().Equals(Permissions.Roles.USER))
                    {
                        //User: Data in Roles Table
                        adminUserRole = await _roleManager.FindByNameAsync(Permissions.Roles.USER);

                        if (adminUserRole == null)
                        {
                            adminUserRole = new IdentityRole(Permissions.Roles.USER);
                            await _roleManager.CreateAsync(adminUserRole);
                        }

                        //Add Claims to user
                        for (int i = 0; i <= userRegVM.Roles.RoleClaims.Length - 1; i++)
                        {
                            string roleClaims = userRegVM.Roles.RoleClaims[i].ToString();
                            switch (roleClaims)
                            {
                            case Permissions.RolePermission.Add:
                            {
                                await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.Add));

                                break;
                            }

                            case Permissions.RolePermission.Edit:
                            {
                                await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.Edit));

                                break;
                            }

                            case Permissions.RolePermission.View:
                            {
                                await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.View));

                                break;
                            }

                            case Permissions.RolePermission.Delete:
                            {
                                await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Users.Delete));

                                break;
                            }

                            default:
                            {
                                break;
                            }
                            }
                        }
                    }
                    else
                    {
                        //Admin: Data in Roles Table
                        adminUserRole = await _roleManager.FindByNameAsync(Permissions.Roles.ADMIN);

                        if (adminUserRole == null)
                        {
                            adminUserRole = new IdentityRole(Permissions.Roles.ADMIN);
                            await _roleManager.CreateAsync(adminUserRole);
                        }

                        //Add Claims to Admin
                        await _userManager.AddClaimAsync(user, new Claim(CustomClaimTypes.Permission, Permissions.Admins.CRUD));
                    }

                    //Add Roles to user
                    if (!await _userManager.IsInRoleAsync(user, adminUserRole.Name))
                    {
                        await _userManager.AddToRoleAsync(user, adminUserRole.Name);
                    }

                    //Update Contact
                    var origionalContactData = _unitOfWork.ContactResource.GetSingleOrDefault(
                        c => c.RefTableId == userRegVM.ID &&
                        c.RefTableName == Constants.ReferenceTableNames.EMPLOYEE);

                    ContactResourseViewModel contactVM = userRegVM.Contact;

                    origionalContactData.RefTableId      = contactVM.RefTableId;
                    origionalContactData.RefTableName    = contactVM.RefTableName;
                    origionalContactData.Address         = contactVM.Address;
                    origionalContactData.State           = contactVM.State;
                    origionalContactData.City            = contactVM.City;
                    origionalContactData.PinCode         = contactVM.PinCode;
                    origionalContactData.MobileNumber    = contactVM.MobileNumber;
                    origionalContactData.ResidenceNumber = contactVM.ResidenceNumber;

                    _unitOfWork.ContactResource.Update(origionalContactData);

                    //Delete Existing Region
                    var HQRegionData = _unitOfWork.HQRegion.GetAll()
                                       .Where(r => r.Hqid == userRegVM.HQ && r.UserId == userRegVM.ID);

                    if (HQRegionData != null)
                    {
                        _unitOfWork.HQRegion.RemoveRange(HQRegionData);
                    }

                    // Add Region according to UserID and HQ
                    HQRegionViewModel HQRegionVM = null;
                    foreach (var rgn in userRegVM.Region)
                    {
                        HQRegionVM = new HQRegionViewModel
                        {
                            HQID     = userRegVM.HQ,
                            UserID   = userRegVM.ID,
                            RegionID = rgn
                        };

                        var empHQRegion = mapper.Map <HQRegionViewModel, Data.Hqregion>(HQRegionVM);
                        _unitOfWork.HQRegion.Add(empHQRegion);
                    }

                    await _unitOfWork.CompleteAsync();
                }
            }
            catch (Exception Ex)
            {
                return(new BadRequestObjectResult(Errors.AddError(Ex, ModelState)));
            }

            return(Ok(userRegVM));
        }