public void GenerateUpdateNameNackTest()
{
string sender = "Tommy Two Tone";
string receiver = "Server";
string contents = "New Name";
IMessageHandler handler = new MessageHandler();
IMessage response = null;
Mock <IConnectionHandler> connectionHandlerMock = new Mock <IConnectionHandler>();
connectionHandlerMock.Setup(connectionHandler => connectionHandler.Name).Returns(contents);
connectionHandlerMock.Setup(connectionHandler => connectionHandler.SendMessage(It.IsAny <IMessage>()))
.Callback((IMessage message) =>
{
response = message;
});
ConcurrentDictionary <string, IConnectionHandler> connectionHandlers = new ConcurrentDictionary <string, IConnectionHandler>();
connectionHandlers.TryAdd(connectionHandlerMock.Object.Name, connectionHandlerMock.Object);
IRequest updateRequest = new UpdateNameRequest(sender, receiver, contents);
updateRequest.ProcessMessage(connectionHandlerMock.Object, connectionHandlers, handler);
Assert.IsNotNull(response);
Assert.AreEqual(response.Command, MessageCommand.UpdateNack);
}
public async Task <IActionResult> UpdateNameAsync(
[FromBody] UpdateNameRequest model, CancellationToken token)
{
var command = new UpdateNameCommand(model.UserId, model.FirstName, model.LastName);
await _commandBus.DispatchAsync(command, token);
return(Ok());
}
/// <summary>
/// Gets the A clone.
/// </summary>
/// <returns>a new instance with same value</returns>
public UpdateNameRequest GetAClone()
{
UpdateNameRequest cloned = new UpdateNameRequest();
cloned.m_Id = m_Id;
cloned.m_Name = m_Name;
return(cloned);
}
public async Task <ActionResult <string> > UpdateName([FromBody] UpdateNameRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(new JsonResult(
Mapper.Map <UserViewModel>(
await UserService.UpdateNameAsync(request))));
}
public async Task <User> UpdateNameAsync(UpdateNameRequest request)
{
var user = await UserRepository.GetByIdAsync(request.Id);
if (user == null)
{
throw new NotFoundException("Пользователь не найден");
}
user.FirstName = request.FirstName;
user.LastName = request.LastName;
return(await UserRepository.UpdateAsync(user));
}
public override async Task <Reply> UpdateName(UpdateNameRequest request, ServerCallContext context)
{
var reply = new Reply();
if (!PwdEncryptor.ValidateUserName(request.NewName))
{
reply.Error = Error.InvalidArguments;
return(reply);
}
var user = await _loginUserService.GetUser(context.GetHttpContext());
if (user == null || user.Adm)
{
reply.Error = Error.InvalidOperation;
return(reply);
}
var userEntity = await _usersService.All().FirstOrDefaultAsync(u => u.Id == user.Id);
if (userEntity == null)
{
reply.Error = Error.InvalidOperation;
return(reply);
}
if (userEntity.Id == request.NewName)
{
return(reply);
}
var existed = await _usersService.All().FirstOrDefaultAsync(u => u.Id == request.NewName);
if (existed != null)
{
reply.Error = Error.InvalidOperation;
return(reply);
}
userEntity.Id = request.NewName;
await _usersService.Update(userEntity);
user.Id = request.NewName;
await _loginUserService.SetUser(context.GetHttpContext(), user);
return(reply);
}
public IActionResult UpdateName([FromBody] UpdateNameRequest request)
{
var user = this.GetUserAuthorize();
if (user == null)
{
return(Unauthorized());
}
var success = UserLogic.Instance.UpdateName(user, request.Name);
if (success)
{
return(Ok());
}
else
{
return(Forbid());
}
}
public override async Task <FileReply> UpdateName(UpdateNameRequest request, ServerCallContext context)
{
var reply = new FileReply();
var user = await _userService.GetUser(context.GetHttpContext());
if (user == null)
{
reply.Error = Error.NeedLogin;
return(reply);
}
if (!user.HasWritePermission())
{
reply.Error = Error.NoPermission;
return(reply);
}
if (!ValidateFileName(request.Name))
{
reply.Error = Error.InvalidArguments;
return(reply);
}
if (!Guid.TryParse(request.Id, out var id))
{
reply.Error = Error.InvalidArguments;
return(reply);
}
var item = await _service.All().Where(i => i.Id == id).FirstOrDefaultAsync();
if (item == null)
{
reply.Error = Error.NoSuchEntity;
return(reply);
}
using (var trans = _service.Context.BeginTransaction())
{
var childrenPathSuffix = item.Path + PathSep;
item.Name = request.Name;
item.Path = JoinPath(GetParentPath(item.Path), item.Name);
item = await _service.Update(item);
var children = _service.All()
.Where(n => n.Path !.StartsWith(childrenPathSuffix));
if (children.Any())
{
foreach (var sub in children)
{
sub.Path = JoinPath(item.Path, sub.Path !.Substring(childrenPathSuffix.Length));
}
await _service.UpdateRange(children);
}
await trans.Commit();
}
reply.File = Converter(item);
if (item.Type == (int)FileType.Folder)
{
await ClearFolderVersionsCache();
}
if (item.Type == (int)FileType.Normal || item.Type == (int)FileType.Folder)
{
await ClearFileWeightsCache(item.Path);
}
return(reply);
}
