public async Task <User> Handle(Command request, CancellationToken cancellationToken)
            {
                if (await _context.Users.AnyAsync(x => x.Email == request.Email))
                {
                    throw new RestException(HttpStatusCode.BadRequest, new { Email = "Email already exists" });
                }

                if (await _context.Users.AnyAsync(x => x.UserName == request.Username))
                {
                    throw new RestException(HttpStatusCode.BadRequest, new { Username = "******" });
                }

                var user = new AppUser {
                    DisplayName = request.DisplayName,
                    Email       = request.Email,
                    UserName    = request.Username
                };

                var result = await _userManager.CreateAsync(user, request.Password);

                if (result.Succeeded)
                {
                    return(new User {
                        DisplayName = user.DisplayName,
                        Token = _jwtGenerator.CreatToken(user),
                        Username = user.UserName,
                        Image = user.Photos.FirstOrDefault(x => x.IsMain)?.Url
                    });
                }

                throw new Exception("Problem creating user");
            }
            public async Task <User> Handle(Query request, CancellationToken cancellationToken)
            {
                var user = await _userManager.FindByEmailAsync(request.Email);

                if (user == null)
                {
                    throw new RestException(HttpStatusCode.Unauthorized);
                }


                var result = await _signInManager.CheckPasswordSignInAsync(user, request.Password, false);

                if (result.Succeeded)
                {
                    //generate Token
                    return(new User
                    {
                        DisplayName = user.DisplayName,
                        Token = _jwtGenerator.CreatToken(user),
                        Username = user.UserName
                    });
                }

                throw new RestException(HttpStatusCode.Unauthorized);
            }
            public async Task <User> Handle(Query request, CancellationToken cancellationToken)
            {
                var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUsername());

                return(new User {
                    DisplayName = user.DisplayName,
                    Username = user.UserName,
                    Token = _jwtGenerator.CreatToken(user),
                    Image = user.Photos.FirstOrDefault(x => x.IsMain)?.Url
                });
            }
            public async Task <User> Handle(Query request, CancellationToken cancellationToken)
            {
                var user = await _userManager.FindByNameAsync(_useAccessor.GetCurrentUsername());

                return(new User
                {
                    DisplayName = user.DisplayName,
                    Username = user.UserName,
                    Status = user.Status,
                    Id = user.Id,
                    Token = _jwtGenerator.CreatToken(user)
                });
            }
            public async Task <User> Handle(Query request, CancellationToken cancellationToken)
            {
                var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUsername());

                if (user == null)
                {
                    throw new RestException(System.Net.HttpStatusCode.Unauthorized);
                }
                return(new User
                {
                    DisplayName = user.DisplayName,
                    Token = _jwtGenerator.CreatToken(user),
                    Username = user.UserName,
                    Image = null
                });

                throw new RestException(System.Net.HttpStatusCode.Unauthorized);
            }
            public async Task <User> Handle(Command request, CancellationToken cancellationToken)
            {
                var roles = new List <AppRole>
                {
                    new AppRole {
                        Name = "SudoAdmin"
                    },
                    new AppRole {
                        Name = "Admin"
                    },
                    new AppRole {
                        Name = "Client"
                    }
                };

                foreach (var role in roles)
                {
                    await _roleManager.CreateAsync(role);
                }

                if (await _context.Users.Where(x => x.Email == request.Email).AnyAsync())
                {
                    throw new RestException(HttpStatusCode.BadRequest, new { Email = "Email already exists" });
                }

                if (await _context.Users.Where(x => x.UserName == request.UserName).AnyAsync())
                {
                    throw new RestException(HttpStatusCode.BadRequest, new { Username = "******" });
                }


                var connectedUser = _useAccessor.GetCurrentUsername() != null;

                Boolean roleShouldBeSudoAdmin = _db.Users.ToList().Count == 0; //the first ever created user will be of role SudoAdmin

                Boolean roleShouldBeAdmin = connectedUser;                     //the user creating admin accounts should be logged in

                var user = new AppUser
                {
                    UserName    = request.UserName,
                    DisplayName = request.DisplayName,
                    Email       = request.Email,
                    Status      = roleShouldBeSudoAdmin ? "SudoAdmin" : roleShouldBeAdmin ? "Admin" : "Client"
                };

                var result = await _userManager.CreateAsync(user, request.Password);

                if (result.Succeeded)
                {
                    if (user.Status == "SudoAdmin")
                    {
                        await _userManager.AddToRoleAsync(user, roles[0].Name);
                    }
                    else if (user.Status == "Admin")
                    {
                        await _userManager.AddToRoleAsync(user, roles[1].Name);
                    }
                    else
                    {
                        await _userManager.AddToRoleAsync(user, roles[2].Name);
                    }

                    return(new User
                    {
                        DisplayName = user.DisplayName,
                        Username = user.UserName,
                        Token = _jwtGenerator.CreatToken(user)
                    });
                }


                throw new System.Exception("Problem creating user");
            }