public async Task <ActionResult <User> > Post(User User)
        {
            if (User.RoleId == 4)
            {
                User.IsDisabled = true;
            }
            EmailService email      = new EmailService(_db);
            SMSService   sms        = new SMSService(_db);
            var          verifyUser = await _db.Users.Where(x => x.Email_Address == User.Email_Address || x.Contact_Number == User.Contact_Number).FirstOrDefaultAsync();

            if (verifyUser != null)
            {
                if (verifyUser.IsVerified != true)
                {
                    sms.sendCodeSMS(verifyUser.Code, verifyUser.Contact_Number);
                    email.sendCodeEmail(verifyUser.Code, verifyUser.Email_Address);
                    return(StatusCode(404, "unverified-" + verifyUser.Id));
                }
                return(StatusCode(404, "Email or Mobile Number  Already Exist"));
            }
            else
            {
                Random random = new Random();
                User.Code       = random.Next(9999);
                User.IsVerified = false;
                _db.Users.Update(User);
                await _db.SaveChangesAsync();

                sms.sendCodeSMS(User.Code, User.Contact_Number);
                var superadmin = await _db.Users.Where(x => x.RoleId == 1).FirstOrDefaultAsync();

                if (User.RoleId == 4)
                {
                    sms.sendRiderAddSMS(superadmin.Contact_Number);  // send sms to admin
                }
                if (User.RoleId == 2)
                {
                    sms.sendShopOwnerAddSMS(superadmin.Contact_Number);
                }
                email.sendCodeEmail(User.Code, User.Email_Address);
                return(CreatedAtAction(nameof(GetSingle), new { id = User.Id }, User));
            }
        }
        public async Task <ActionResult <User> > resendCode(long id)
        {
            var          dbUser = _db.Users.Where(x => x.Id == id).FirstOrDefault();
            EmailService email  = new EmailService(_db);
            SMSService   sms    = new SMSService(_db);

            sms.sendCodeSMS(dbUser.Code, dbUser.Contact_Number);
            email.sendCodeEmail(dbUser.Code, dbUser.Email_Address);

            return(NoContent());
        }
        public async Task <long> ForgetPassword([FromBody] string mobile)
        {
            User dbuser = await _db.Users.FirstOrDefaultAsync(x => x.Contact_Number == mobile || x.Email_Address == mobile);

            EmailService emails = new EmailService(_db);

            emails.sendCodeEmail(dbuser.Code, dbuser.Email_Address);
            SMSService sms = new SMSService(_db);

            sms.sendCodeSMS(dbuser.Code, dbuser.Contact_Number);
            return(dbuser.Id);
        }
        public async Task <ActionResult <User> > Login(User postedUser)
        {
            var Token = "";

            string[] Roles  = new string[] { "role", "SuperAdmin", "ShopOwner", "Customer", "Rider" };
            var      dbUser = _db.Users.Where(x => (x.Email_Address == postedUser.Email_Address || x.Contact_Number == postedUser.Contact_Number) && x.Password == postedUser.Password).FirstOrDefault();

            if (dbUser != null)
            {
                if (dbUser.IsVerified != true)
                {
                    EmailService email = new EmailService(_db);
                    SMSService   sms   = new SMSService(_db);
                    sms.sendCodeSMS(dbUser.Code, dbUser.Contact_Number);
                    email.sendCodeEmail(dbUser.Code, dbUser.Email_Address);
                    return(StatusCode(404, "unverified-" + dbUser.Id));
                }

                if (dbUser.IsDisabled == true && dbUser.RoleId != 4)
                {
                    return(StatusCode(404, "your account is disabled"));
                }
            }
            if (dbUser != null)
            {
                //Token
                var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["Jwt:key"]));
                var Credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);
                var claims      = new[] {
                    new Claim(JwtRegisteredClaimNames.Sid, dbUser.Id.ToString()),
                    new Claim("FirstName", dbUser.FirstName),
                    new Claim("LastName", dbUser.LastName),
                    new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
                    new Claim("RoleName", Roles[dbUser.RoleId]),
                    new Claim("UserImage", dbUser.UserImage == null || dbUser.UserImage == ""?"":dbUser.UserImage),
                    new Claim("Address", dbUser.Address),
                    new Claim("Contact", dbUser.Contact_Number),
                    new Claim("Email", dbUser.Email_Address),
                    new Claim("IsVerified", dbUser.IsVerified.ToString())

                    //new Claim(ClaimTypes.Role, dbUser.RoleId.ToString()),
                };
                // if (users.Role.RoleName != null) { new Claim("roles", users.Role.RoleName); }

                var _Token = new JwtSecurityToken(
                    issuer: Configuration["Jwt:Issuer"],
                    audience: Configuration["Jwt:Issuer"],
                    claims,
                    expires: DateTime.Now.AddMinutes(120),
                    signingCredentials: Credentials

                    );
                Token = new JwtSecurityTokenHandler().WriteToken(_Token);
                return(Ok(new { Token = Token }));;
            }

            else
            {
                return(NotFound(new { message = "Invalid Email or Password." }));
            }
        }