public GenericOperationResult <IEnumerable <Quiz> > GetAvailableQuies(string studentName, QuizGetType type)
{
GenericOperationResult <IEnumerable <Quiz> > result =
OperationResult.GetGenericResultObject <IEnumerable <Quiz> >();
// check student
User student = _userService.GetUser(studentName);
if (student == null)
{
result.AddMessage(_messagesService.GetErrorMessage(ErrorMessageKeys.UserNotFound));
return(result);
}
else
{
switch (type)
{
case QuizGetType.Pregenarated:
return(GetPredefinedQuizes(student));
break;
}
}
return(result);
}
public GenericOperationResult <bool> Register(RegisterDto register)
{
var result = new GenericOperationResult <bool>();
result = userService.RegisterUser(register);
return(result);
}
private GenericOperationResult <IEnumerable <Quiz> > GetPredefinedQuizes(User student)
{
GenericOperationResult <IEnumerable <Quiz> > result =
OperationResult.GetGenericResultObject <IEnumerable <Quiz> >();
try
{
// get all the tests information that the student has taken
var quizesStudentHasTaken = _studentQuizResultRepository.GetAllItems().ToList().Where(x => x.StudentId.Equals(student.UserID));
//get all the quizes
var allQuizes = _quizRepository.GetAllItems().Where(x => x.IsRandom == null || x.IsRandom == false);
//filter only non taken quizes
var takenQuizesIds = quizesStudentHasTaken.Select(x => x.QuizId).ToList();
var filteredQuizes = (from quiz in allQuizes let quizId = quiz.Id where !takenQuizesIds.Contains(quizId) select quiz).ToList();
//if everything goes well
result.SetData(filteredQuizes);
result.SetSuccess();
return(result);
}
catch (Exception e)
{
result.SetException();
result.AddExceptionMessage(e.Message);
}
return(result);
}
public bool CreateItem <T>(T item, ICrudRepository <T> repository, GenericOperationResult <T> or) where T : class, new()
{
if (item == null)
{
or.AddMessage(_localizedMessagesService.GetErrorMessage(ErrorMessageKeys.NullObjectReference));
or.SetFail();
return(false);
}
try
{
var success = repository.CreateItem(item);
if (success)
{
or.SetData(item);
return(true);
}
else
{
or.AddMessage(_localizedMessagesService.GetErrorMessage(ErrorMessageKeys.RepositoryError));
return(false);
}
}
catch (Exception e)
{
or.AddMessage(_localizedMessagesService.GetErrorMessage(ErrorMessageKeys.RepositoryError));
return(false);
}
}
public GenericOperationResult <IActionResult> AddFriend(string userName)
{
var result = new GenericOperationResult <IActionResult>();
try
{
int userId = int.Parse(httpContext.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier));
if (unitOfWork.Authentication.UserExists(userName) && userId != default)
{
var friend = unitOfWork.UserRepository.GetByUserName(userName);
var user = unitOfWork.UserRepository.GetById(userId);
UserFriends userFriend = new UserFriends
{
FriendId = friend.Id,
UserId = userId,
Friend = friend,
User = user
};
unitOfWork.UserFriendsRepository.Create(userFriend);
if (unitOfWork.SaveChanges())
{
result.Data = new OkResult();
result.Messages.Add("Your friend has been added");
result.Status = OperationResultStatusEnum.Succeeded;
return(result);
}
result.Data = new BadRequestResult();
result.Messages.Add("Insucessful process");
result.Status = OperationResultStatusEnum.Failed;
return(result);
}
}
catch (ArgumentNullException e)
{
throw new BusinessException("Argument is null ", e);
}
catch (SqlException e)
{
throw new BusinessException("Database error ", e);
}
catch (NullReferenceException e)
{
throw new BusinessException("Object Refrence is null ", e);
}
catch (Exception e)
{
throw new BusinessException("error Occured ", e);
}
result.Data = new BadRequestResult();
result.Messages.Add("Friend userName doesn't exist");
result.Status = OperationResultStatusEnum.Failed;
return(result);
}
public bool GetItems <T>(ICrudRepository <T> repository, GenericOperationResult <IEnumerable <T> > or)
{
try
{
var items = repository.GetAllItems();
or.SetData(items);
return(true);
}
catch (Exception e)
{
or.AddMessage(_localizedMessagesService.GetErrorMessage(ErrorMessageKeys.RepositoryError));
return(false);
}
}
public GenericOperationResult <List <Post> > GetUserPosts()
{
var result = new GenericOperationResult <List <Post> >();
try
{
return(postService.GetPosts());
}
catch (BusinessException ex)
{
Logger.Error(ex, "Error occured during getting posts");
result.Messages.Add("Bad Data");
result.Status = OperationResultStatusEnum.Failed;
return(result);
}
}
public GenericOperationResult <LoginReturnDto> LoginUser(LoginDto user)
{
var result = new GenericOperationResult <LoginReturnDto>();
var loginValidator = new LoginValidator();
var valid = loginValidator.Validate(user);
if (!valid.IsValid)
{
result.Messages = valid.Errors.Select(e => e.ErrorMessage).ToList();
result.Status = OperationResultStatusEnum.Validation;
return(result);
}
var loggedUser = unitOfWork.Authentication.Login(user.UserName, user.Password);
if (loggedUser == null)
{
result.Messages.Add("Username or password are incorrect");
result.Status = OperationResultStatusEnum.Exception;
return(result);
}
var claims = new List <Claim>
{
new Claim(ClaimTypes.NameIdentifier, loggedUser.Id.ToString()),
new Claim(ClaimTypes.Name, loggedUser.UserName),
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration.GetSection("Token:Secrete").Value));
var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(2),
SigningCredentials = credentials
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
result.Data = new LoginReturnDto {
Token = tokenHandler.WriteToken(token)
};
result.Status = OperationResultStatusEnum.Succeeded;
return(result);
;
}
public GenericOperationResult<List<Post>> GetPosts()
{
try
{
GenericOperationResult<List<Post>> result = new GenericOperationResult<List<Post>>();
int userId = int.Parse(httpContext.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier));
var userFriends = unitOfWork.UserFriendsRepository.Get().Where(u => u.UserId == userId);
List<Post> posts = new List<Post>();
foreach (var userfriend in userFriends)
{
var friendPosts = unitOfWork.PostRepository.Get().Where(u => u.UserId == userfriend.FriendId).ToList();
foreach (var post in friendPosts)
{
posts.Add(post);
}
}
if (posts.Count > 0)
{
result.Data = posts;
result.Messages.Add("Posts retrieved successfully");
result.Status = OperationResultStatusEnum.Succeeded;
return result;
}
result.Messages.Add("there's no posts");
result.Status = OperationResultStatusEnum.Succeeded;
return result;
}
catch (NullReferenceException nullEx)
{
throw new BusinessException("Null Refrence exception", nullEx);
}
catch (SqlException sqlEx)
{
throw new BusinessException("Sql Exception exception", sqlEx);
}
catch (Exception e)
{
throw new BusinessException("error Occured ", e);
}
}
public GenericOperationResult<bool> DeletePost(int postId)
{
try
{
var result = new GenericOperationResult<bool>();
int userId = int.Parse(httpContext.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier));
var post = unitOfWork.PostRepository.GetById(postId);
if (post != null && checkPostOwner(userId, post))
{
unitOfWork.PostRepository.Delete(postId);
if (unitOfWork.SaveChanges())
{
result.Data = true;
result.Status = OperationResultStatusEnum.Succeeded;
result.Messages.Add("Your post has been deleted");
return result;
}
result.Data = false;
result.Status = OperationResultStatusEnum.Failed;
return result;
}
result.Data = false;
result.Status = OperationResultStatusEnum.Failed;
result.Messages.Add("Bad Data");
return result;
}
catch (NullReferenceException nullEx)
{
throw new BusinessException("Null Refrence exception", nullEx);
}
catch (SqlException sqlEx)
{
throw new BusinessException("Sql Exception exception", sqlEx);
}
catch (Exception e)
{
throw new BusinessException("error Occured ", e);
}
}
public bool GetItem <T>(int id, ICrudRepository <T> repository, GenericOperationResult <T> or) where T : class, new()
{
if (id == 0)
{
or.AddMessage(_localizedMessagesService.GetErrorMessage(ErrorMessageKeys.InvalidId));
return(false);
}
try
{
var item = repository.GetItem(id);
or.SetData(item);
return(true);
}
catch (Exception e)
{
or.AddMessage(_localizedMessagesService.GetErrorMessage(ErrorMessageKeys.RepositoryError));
return(false);
}
}
public async Task <GenericOperationResult <bool> > AddPost([FromForm] PostDto post)
{
GenericOperationResult <bool> result = new GenericOperationResult <bool>();
try
{
var host = Request.Scheme + "://" + Request.Host;
result = await postService.AddPost(post, host);
return(result);
}
catch (BusinessException ex)
{
Logger.Error(ex, "Error occured during adding new post");
result.Data = false;
result.Messages.Add("Bad Data");
result.Status = OperationResultStatusEnum.Failed;
return(result);
}
}
public GenericOperationResult <bool> DeletePost(PostModel post)
{
GenericOperationResult <bool> result = new GenericOperationResult <bool>();
if (post.PostId != null)
{
try
{
return(postService.DeletePost(int.Parse(post.PostId)));
}
catch (BusinessException ex)
{
Logger.Error(ex, "Error occured during deleting new post");
result.Data = false;
result.Messages.Add("Bad Data");
result.Status = OperationResultStatusEnum.Failed;
return(result);
}
}
result.Messages.Add("Invalid post id input");
result.Status = OperationResultStatusEnum.Failed;
return(result);
}
public GenericOperationResult <IActionResult> AddFriend(AddFriendModel addFriend)
{
var result = new GenericOperationResult <IActionResult>();
if (addFriend.UserName != "" || addFriend.UserName != null)
{
try
{
return(userService.AddFriend(addFriend.UserName));
}
catch (BusinessException ex)
{
Logger.Error(ex, "error occured during adding friend");
result.Data = new BadRequestResult();
result.Messages.Add("Bad data can;t add friend try again ");
result.Status = OperationResultStatusEnum.Failed;
return(result);
}
}
result.Data = new BadRequestResult();
result.Status = OperationResultStatusEnum.Failed;
result.Messages.Add("userName can't be empty");
return(result);
}
public GenericOperationResult <bool> RegisterUser(RegisterDto user)
{
var registerValidator = new RegisterValidator();
var res = registerValidator.Validate(user);
var result = new GenericOperationResult <bool>();
if (res.IsValid)
{
try
{
if (!unitOfWork.Authentication.UserExists(user.UserName, user.PhoneNumber))
{
var registerUser = MapUser(user);
User registeredUser = new User();
registeredUser = unitOfWork.Authentication.Register(registerUser, user.Password);
VerifyUserModel model = new VerifyUserModel
{
User = registeredUser,
Password = user.Password
};
if (registeredUser != null)
{
httpContext.HttpContext.Session.SetString(user.PhoneNumber, JsonConvert.SerializeObject(model));
MessageModel messageModel = new MessageModel
{
From = new PhoneNumber("+12284564506"),
//Twilio license
To = new PhoneNumber("+201121736295"),
Body = "Verification code of your account is: 0000"
};
var message = SendMessage(messageModel);
//ObjectCache cache = MemoryCache.Default;
//cache.Add("CachedValueKey", "Some value to cache", new CacheItemPolicy());
//cache.Add(user.PhoneNumber, user.Password, new CacheItemPolicy());
result.Status = OperationResultStatusEnum.Succeeded;
result.Messages.Add("Suceeded");
return(result);
}
result.Status = OperationResultStatusEnum.Failed;
result.Messages.Add("Failed");
return(result);
}
else
{
result.Status = OperationResultStatusEnum.Failed;
result.Messages.Add("User already exists");
return(result);
}
}
catch (ArgumentNullException e)
{
throw new BusinessException("Argument is null ", e);
}
catch (SqlException e)
{
throw new BusinessException("Database error ", e);
}
catch (NullReferenceException e)
{
throw new BusinessException("Object Refrence is null ", e);
}
catch (Exception e)
{
throw new BusinessException("error Occured ", e);
}
}
result.Messages = res.Errors.Select(e => e.ErrorMessage).ToList();
result.Status = OperationResultStatusEnum.Validation;
return(result);
}
public GenericOperationResult <LoginReturnDto> VerifyUserPhone(VerifyMobileModel model)
{
var result = new GenericOperationResult <LoginReturnDto>();
var validator = new VerifyMobileValidator();
var valid = validator.Validate(model);
if (!valid.IsValid)
{
result.Messages = valid.Errors.Select(e => e.ErrorMessage).ToList();
result.Status = OperationResultStatusEnum.Validation;
return(result);
}
if (model.OTP == "0000")
{
try
{
if (httpContext.HttpContext.Session.GetString(model.PhoneNumber) == null)
{
result.Messages.Add("Invalid phone number Input");
result.Status = OperationResultStatusEnum.Exception;
return(result);
}
var user = httpContext.HttpContext.Session.GetString(model.PhoneNumber);
var myUser = JsonConvert.DeserializeObject <VerifyUserModel>(user);
if (myUser != null)
{
LoginDto loginData = new LoginDto
{
UserName = myUser.User.UserName,
Password = myUser.Password
};
httpContext.HttpContext.Session.Remove(model.PhoneNumber);
unitOfWork.UserRepository.Create(myUser.User);
unitOfWork.SaveChanges();
var res = LoginUser(loginData);
result.Data = new LoginReturnDto {
Token = res.Data.Token
};
result.Status = OperationResultStatusEnum.Succeeded;
return(result);
}
result.Status = OperationResultStatusEnum.Failed;
return(result);
}
catch (ArgumentNullException e)
{
throw new BusinessException("Argument is null ", e);
}
catch (SqlException e)
{
throw new BusinessException("Database error ", e);
}
catch (NullReferenceException e)
{
throw new BusinessException("Object Refrence is null ", e);
}
catch (Exception e)
{
throw new BusinessException("error Occured ", e);
}
}
result.Status = OperationResultStatusEnum.Failed;
result.Messages.Add("Invalid OTP");
return(result);
}
public GenericOperationResult <LoginReturnDto> VerifyPhoneNumber(VerifyMobileModel model)
{
var result = new GenericOperationResult <LoginReturnDto>();
return(userService.VerifyUserPhone(model));
}
public async Task<GenericOperationResult<bool>> AddPost(PostDto postDto, string host)
{
//Validate model
var result = new GenericOperationResult<bool>();
var postValidator = new PostValidator();
var res = postValidator.Validate(postDto);
if (res.IsValid)
{
try
{
int userId = int.Parse(httpContext.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier));
if (postDto.Image != null)
{
var path = await uploadFile.UploadImage(postDto.Image, host);
if (path != null)
{
postDto.ImageUrl = path;
}
else
{
result.Messages.Add("Invalid image type");
result.Status = OperationResultStatusEnum.Exception;
return result;
}
}
Post createPost = MapPost(postDto);
createPost.UserId = userId;
unitOfWork.PostRepository.Create(createPost);
if (unitOfWork.SaveChanges())
{
result.Data = true;
result.Messages.Add("your post has been added ");
result.Status = OperationResultStatusEnum.Succeeded;
return result;
}
else
{
result.Data = false;
result.Messages.Add("Sorry your post couldn't be uploaded try again!!");
result.Status = OperationResultStatusEnum.Failed;
return result;
}
}
catch (NullReferenceException nullEx)
{
throw new BusinessException("Null Refrence exception", nullEx);
}
catch (IndexOutOfRangeException outOfRangeEx)
{
throw new BusinessException("Out of range exception exception", outOfRangeEx);
}
catch (SqlException sqlEx)
{
throw new BusinessException("Sql Exception exception", sqlEx);
}
catch (Exception e)
{
throw new BusinessException("error Occured ", e);
}
}
result.Data = false;
result.Messages = res.Errors.Select(e => e.ErrorMessage).ToList();
result.Status = OperationResultStatusEnum.Failed;
return result;
}
