/// <summary>
/// Création d'un nouvel utilisateur.
/// </summary>
/// <param name="utilisateur">L'objet utilisateur.</param>
/// <returns>Retourne un objet Utilisateur.</returns>
public async Task <User> Create(ShortUser user)
{
try
{
if (_wargameContext.User.SingleOrDefault(x => x.Email == user.Email) != null)
{
throw new Exception("Email already exist. Try with another or login with your nickname.");
}
if (_wargameContext.User.SingleOrDefault(x => x.Nickname == user.Nickname) != null)
{
throw new Exception("Nickname already exist. Choose another one or login with your account.");
}
// Create user.
User newUser = new User()
{
Email = user.Email,
Nickname = user.Nickname,
Password = GenericService.EncryptText(user.Password, "SHA1"),
Points = 0,
};
// Create user.
await _wargameContext.AddAsync(newUser);
await _wargameContext.SaveChangesAsync();
return(newUser);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
// GET: AllUserViewModels
public async Task <IActionResult> Index(string Id)
{
var users = await userManager.Users.ToListAsync();
List <ShortUser> ListUser = new List <ShortUser>();
foreach (var User in users)
{
ShortUser u = new ShortUser
{
id = User.Id,
Username = User.UserName,
urlIMG = User.IMG_url
};
var checkF = _context.Friends.FirstOrDefault(opts => opts.IdFriend == u.id && opts.IdUser == Id);
if (u.id != Id && checkF != null)
{
ListUser.Add(u);
}
//ko phải người dùng và không có trong list bạn
}
ChatHubViewModel a = new ChatHubViewModel
{
shortUsers = ListUser
};
return(View("../ChatHub/ChatHub", a));
}
public async Task <IHttpActionResult> GetCurrentUser()
{
var userId = User.Identity.GetUserId();
ShortUser result = await _userService.GetCurrentUser(userId);
return(Ok(result));
}
public async Task NewOrEditUserAsync(ShortUser shortUser, long nodeId = 0)
{
using (MessengerDbContext context = contextFactory.Create())
{
try
{
var user = await context.Users.FindAsync(shortUser.UserId).ConfigureAwait(false);
if (user == null)
{
user = new User
{
Id = shortUser.UserId,
NodeId = nodeId,
Confirmed = true
};
await context.Users.AddAsync(user).ConfigureAwait(false);
}
else
{
user.NodeId = nodeId;
user.Confirmed = true;
context.Update(user);
}
await context.SaveChangesAsync().ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
}
public CreateOrEditUsersNodeNotice(NodeNoticeCode noticeCode, ShortUser user, BlockSegmentVm blockSegment)
{
NoticeCode = noticeCode;
Users = new List <ShortUser> {
user
};
BlockSegments = new List <BlockSegmentVm> {
blockSegment
};
}
public async Task <IActionResult> Register([FromBody] ShortUser user)
{
try
{
return(Ok(await _userService.Create(user)));
}
catch (Exception e)
{
return(BadRequest(new { message = e.Message }));
}
}
public async void SendNewUsersNodeNoticeAsync(ShortUser user, BlockSegmentVm blockSegment)
{
try
{
CreateOrEditUsersNodeNotice notice = new CreateOrEditUsersNodeNotice(Enums.NodeNoticeCode.NewUsers, user, blockSegment);
await SendNoticeToNodesAsync(notice).ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
public async Task <IActionResult> Create([FromForm] CreateUserModel model)
{
if (ModelState.IsValid)
{
var result = await _createUsersService.CreateNewUserAsync(
new UserVm
{
NameFirst = model.NameFirst,
NameSecond = model.NameSecond,
Phones = !string.IsNullOrEmpty(model.PhoneNumber)
? new List <UserPhoneVm>
{
new UserPhoneVm
{
FullNumber = model.PhoneNumber,
IsMain = true
}
}
: null,
Emails = !string.IsNullOrEmpty(model.Email)
? new List <string> {
model.Email
}
: null
},
NodeSettings.Configs.Node.Id,
NodeSettings.Configs.ConfirmUsers,
model.Password).ConfigureAwait(false);
var segment = await BlockSegmentsService.Instance.CreateNewUserSegmentAsync(
result.FirstValue,
NodeSettings.Configs.Node.Id,
NodeData.Instance.NodeKeys.SignPrivateKey,
NodeData.Instance.NodeKeys.SymmetricKey,
NodeData.Instance.NodeKeys.Password,
NodeData.Instance.NodeKeys.KeyId).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
ShortUser shortUser = new ShortUser
{
UserId = result.FirstValue.Id.GetValueOrDefault(),
PrivateData = segment.PrivateData
};
_nodeNoticeService.SendNewUsersNodeNoticeAsync(shortUser, segment);
return(Redirect(nameof(Index)));
}
return(BadRequest());
}
public async Task <ShortUser> Authenticate(string nickname, string password)
{
var user = await Task.Run(() => _wargameContext.User.SingleOrDefault(x => x.Nickname == nickname && x.Password == GenericService.EncryptText(password, "SHA1")));
// return null if user not found
if (user == null)
{
return(null);
}
ShortUser returnedUser = new ShortUser()
{
Id = user.Id,
Nickname = user.Nickname,
Email = user.Email,
};
returnedUser.Token = GenerateJSONWebToken(user);
// authentication successful so return user details without password
return(returnedUser.WithoutPassword());
}
public async Task <Response> CreateResponseAsync()
{
UserVm editableUser = await updateUsersService.EditUserAsync(request.User, clientConnection.UserId.GetValueOrDefault()).ConfigureAwait(false);
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateEditUserSegmentAsync(
editableUser,
NodeSettings.Configs.Node.Id,
NodeData.Instance.NodeKeys.SignPrivateKey,
NodeData.Instance.NodeKeys.SymmetricKey,
NodeData.Instance.NodeKeys.Password,
NodeData.Instance.NodeKeys.KeyId).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
EditUserBlockData editBlockData = (EditUserBlockData)segment.PublicData;
ShortUser shortUser = new ShortUser
{
PrivateData = segment.PrivateData,
UserId = editBlockData.UserId
};
nodeNoticeService.SendEditUsersNodeNoticeAsync(shortUser, segment);
UsersConversationsCacheService.Instance.UserEditedUpdateUserDialogsAsync(editableUser);
return(new UserResponse(request.RequestId, editableUser));
}
public async Task <Response> CreateResponseAsync()
{
if (!NodeSettings.Configs.Node.UserRegistrationAllowed)
{
return(new ResultResponse(request.RequestId, "User registration is not allowed.", ErrorCode.PermissionDenied));
}
UserVm user = request.User;
try
{
VerificationCodeInfo verificationCode = null;
if (!request.User.Phones.IsNullOrEmpty() && request.User.Emails.IsNullOrEmpty())
{
if (NodeSettings.Configs.Node.RegistrationMethod == RegistrationMethod.EmailRequired)
{
var errorObject = new
{
Email = "Email required"
};
return(new ResultResponse(request.RequestId, ObjectSerializer.ObjectToJson(errorObject), ErrorCode.WrongArgumentError));
}
if (await loadUsersService.IsPhoneExistsAsync(request.User.Phones.FirstOrDefault().FullNumber).ConfigureAwait(false))
{
var errorObject = new
{
Phone = "Phone already exists"
};
return(new ResultResponse(request.RequestId, ObjectSerializer.ObjectToJson(errorObject), ErrorCode.WrongArgumentError));
}
verificationCode = await verificationCodesService.GetUserVerificationCodeAsync(request.User.Phones.FirstOrDefault().FullNumber).ConfigureAwait(false);
}
else if (request.User.Phones.IsNullOrEmpty() && !request.User.Emails.IsNullOrEmpty())
{
if (NodeSettings.Configs.Node.RegistrationMethod == RegistrationMethod.PhoneRequired)
{
var errorObject = new
{
Email = "Phone required"
};
return(new ResultResponse(request.RequestId, ObjectSerializer.ObjectToJson(errorObject), ErrorCode.WrongArgumentError));
}
if (await loadUsersService.IsEmailExistsAsync(request.User.Emails.FirstOrDefault()).ConfigureAwait(false))
{
var errorObject = new
{
Email = "Email already exists."
};
return(new ResultResponse(request.RequestId, ObjectSerializer.ObjectToJson(errorObject), ErrorCode.WrongArgumentError));
}
verificationCode = await verificationCodesService.GetUserVerificationCodeAsync(request.User.Emails.FirstOrDefault()).ConfigureAwait(false);
}
else
{
if (NodeSettings.Configs.Node.RegistrationMethod != RegistrationMethod.NothingRequired)
{
var errorObject = new
{
Email = "Email only or phone only",
Phone = "Email only or phone only"
};
return(new ResultResponse(request.RequestId, ObjectSerializer.ObjectToJson(errorObject), ErrorCode.WrongArgumentError));
}
}
if (verificationCode != null &&
verificationCode.VCode != request.VCode &&
(!request.User.Emails.IsNullOrEmpty() || !request.User.Phones.IsNullOrEmpty()))
{
var errorObject = new
{
VCode = "Wrong verification code"
};
return(new ResultResponse(request.RequestId, ObjectSerializer.ObjectToJson(errorObject), ErrorCode.WrongVerificationCode));
}
ValuePair <UserVm, string> userPasswordPair = await createUsersService.CreateNewUserAsync(user, NodeSettings.Configs.Node.Id, NodeSettings.Configs.ConfirmUsers).ConfigureAwait(false);
TokenVm tempTokens = await tokensService.CreateTokenPairByUserIdAsync(userPasswordPair.FirstValue.Id.GetValueOrDefault(), false, 30 * 60).ConfigureAwait(false);
clientConn.FileAccessToken = RandomExtensions.NextString(64);
BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateNewUserSegmentAsync(
userPasswordPair.FirstValue,
NodeSettings.Configs.Node.Id,
NodeData.Instance.NodeKeys.SignPrivateKey,
NodeData.Instance.NodeKeys.SymmetricKey,
NodeData.Instance.NodeKeys.Password,
NodeData.Instance.NodeKeys.KeyId).ConfigureAwait(false);
BlockGenerationHelper.Instance.AddSegment(segment);
ShortUser shortUser = new ShortUser
{
UserId = userPasswordPair.FirstValue.Id.GetValueOrDefault(),
PrivateData = segment.PrivateData
};
nodeNoticeService.SendNewUsersNodeNoticeAsync(shortUser, segment);
return(new TokensResponse(
request.RequestId,
userPasswordPair.FirstValue,
tempTokens.AccessToken,
tempTokens.RefreshToken,
clientConn.FileAccessToken,
userPasswordPair.SecondValue));
}
catch (CreateNewUserException ex)
{
Logger.WriteLog(ex, request);
return(new ResultResponse(request.RequestId, ex.Message, ErrorCode.UnknownError));
}
}
internal ContentShareWithSender(Api api, ContentShareModel model) : base(api, model)
{
Debug.Assert(model.Sender != null, "model.Sender != null");
Sender = new ShortUser(api, model.Sender);
}
