public async Task <Avatar> Create(int userId, Avatar avatar)
        {
            using (var context = new TradePMREntities())
            {
                var user = await context.Users.FindAsync(userId);

                if (user == null)
                {
                    throw new ApplicationException($"User with id {userId} not found");
                }
                if (user.AvatarId != null)
                {
                    throw new ApplicationException("User already has an avatar");
                }
                avatar.Users.Add(user);
                var avatarCreated = context.Avatars.Add(avatar);
                var created       = await context.SaveChangesAsync();

                if (created == 0)
                {
                    return(null);
                }
                return(avatarCreated);
            }
        }
        public async Task <User> Get(int userId)
        {
            using (var context = new TradePMREntities())
            {
                var user = await context.Users.FindAsync(userId);

                return(user);
            }
        }
        public async Task <List <User> > GetAll()
        {
            using (var context = new TradePMREntities())
            {
                var users = await context.Users.ToListAsync();

                return(users);
            }
        }
        public async Task <Avatar> Get(int avatarId)
        {
            using (var context = new TradePMREntities())
            {
                var avatar = await context.Avatars.FindAsync(avatarId);

                return(avatar);
            }
        }
        public async Task <User> Create(User user)
        {
            using (var context = new TradePMREntities())
            {
                var userCreated = context.Users.Add(user);
                var created     = await context.SaveChangesAsync();

                if (created == 0)
                {
                    return(null);
                }
                return(userCreated);
            }
        }
        public async Task <User> Update(User user)
        {
            using (var context = new TradePMREntities())
            {
                var result = await context.Users.FindAsync(user.Id);

                if (result == null)
                {
                    return(null);
                }
                context.Entry(result).CurrentValues.SetValues(user);
                context.Entry(result).State = EntityState.Modified;
                var updated = await context.SaveChangesAsync();

                if (updated == 0)
                {
                    return(null);
                }
                return(user);
            }
        }
        public async Task <Avatar> Update(int userId, Avatar avatar)
        {
            using (var context = new TradePMREntities())
            {
                var user = await context.Users.FindAsync(userId);

                if (user == null)
                {
                    throw new ApplicationException($"User with id {userId} not found");
                }

                if (user.AvatarId == null)
                {
                    avatar.Users.Add(user);
                    context.Avatars.Add(avatar);
                }
                else
                {
                    var result = await context.Avatars.FindAsync(user.AvatarId);

                    if (result == null)
                    {
                        return(null);
                    }
                    avatar.Id = result.Id;
                    context.Entry(result).CurrentValues.SetValues(avatar);
                    context.Entry(result).State = EntityState.Modified;
                }

                var updated = await context.SaveChangesAsync();

                if (updated == 0)
                {
                    return(null);
                }
                return(avatar);
            }
        }
        public async Task <bool> Delete(User user)
        {
            using (var context = new TradePMREntities())
            {
                var result = await context.Users.FindAsync(user.Id);

                if (result == null)
                {
                    return(false);
                }
                if (result.Avatar != null)
                {
                    context.Entry(result.Avatar).State = EntityState.Deleted;
                }
                context.Entry(result).State = EntityState.Deleted;
                var deleted = await context.SaveChangesAsync();

                if (deleted == 0)
                {
                    return(false);
                }
                return(true);
            }
        }
        public async Task <bool> Delete(int avatarId)
        {
            using (var context = new TradePMREntities())
            {
                var result = await context.Avatars.FindAsync(avatarId);

                if (result == null)
                {
                    return(false);
                }
                foreach (var user in result.Users)
                {
                    context.Entry(user).Entity.AvatarId = null;
                }
                context.Entry(result).State = EntityState.Deleted;
                var deleted = await context.SaveChangesAsync();

                if (deleted == 0)
                {
                    return(false);
                }
                return(true);
            }
        }