public void AddUser(AddUserMessage newUser)
{
var user = ConvertToUser(newUser);
_db.Users.Add(user);
_db.SaveChanges();
}
public void Create_PostAndModelStateIsValid_AddMessage()
{
var createUserMessage = new AddUserMessage();
controller.Create(createUserMessage);
commandMock.Verify(u => u.Execute(It.IsAny<CreateUserCommand>()));
}
public void Create_PostWithInvalidModelState_ReturnsViewWithPassedMessage()
{
controller.ModelState.AddModelError("fel", "felet");
var createUserMessage = new AddUserMessage();
var result = (ViewResult)controller.Create(createUserMessage);
Assert.That(result.ViewName, Is.EqualTo(""));
Assert.That(result.Model, Is.SameAs(createUserMessage));
}
private StoreContext.User ConvertToUser(AddUserMessage newUserMessage)
{
return(new StoreContext.User
{
Id = Guid.NewGuid().ToString(),
Level = newUserMessage.Level,
Password = MD5Helper.CalculateMD5Hash(newUserMessage.Password),
UserName = newUserMessage.Username
});
}
public override Task <AddUserResposne> AddUser(AddUserMessage request, ServerCallContext context)
{
Guid id = Guid.NewGuid();
_repository.Add(new UserEntry
{
Id = id,
Username = request.Username
});
return(Task.FromResult(new AddUserResposne {
Id = id.ToString()
}));
}
private async void OnAddUserMessage(AddUserMessage message)
{
IsLoading = true;
if (_projectQueryService.Project.ProjectMembersNotInRepository != null &&
_projectQueryService.Project.ProjectMembersNotInRepository.Contains(message.UserToBeAdded))
{
IsLoading = false;
return;
}
AddUserFromProject(message.UserToBeAdded);
_projectQueryService.AddUser(message.UserToBeAdded);
IsLoading = false;
await _projectQueryService.SaveChanges();
}
public ActionResult Create(AddUserMessage message)
{
if(!ModelState.IsValid)
{
return View(message);
}
var result = commands.Execute(new CreateUserCommand(message));
if (result.IsSuccess())
{
authenticator.SetAuthCookie(result.ReturnValue.Username, true);
}
else
{
ModelState.AddModelError("", result.CombinedErrors());
return View(message);
}
return RedirectToAction("Index", "Home");
}
public void Start()
{
var returnedData = NodeCommunicationClient.Send(
_configuration.ConfigurationToolAddress,
_configuration.User,
_configuration.Password,
new SingleValueMessage {
Value = CONFIG
},
Command.REQ,
nameof(ConfigurationTool));
var name = MessagePackSerializer.Deserialize <SingleValueMessage>(returnedData.Content).Value;
name = name.Substring(0, name.Length - 4);
while (true)
{
Console.Write($"{name}> ");
var command = Console.ReadLine();
var msgCommand = Command.UNKNOWN;
IMessage content = null;
//Local commands
if (clear.IsMatch(command))
{
Console.Clear();
continue;
}
//Add user
if (addUser.IsMatch(command))
{
var groups = addUser.Match(command).Groups.Select(a => a.Value).ToList();
msgCommand = Command.CONF_ADD_USER;
var addUserMsg = new AddUserMessage
{
Level = int.Parse(groups[3]),
Username = groups[1],
Password = groups[2]
};
content = addUserMsg;
}
//Set user level
else if (setUserLevel.IsMatch(command))
{
var groups = setUserLevel.Match(command).Groups.Select(a => a.Value).ToList();
msgCommand = Command.CONF_SET_USER_LEVEL;
var setUserLevelMsg = new SetUserLevelMessage
{
User = groups[1],
NewLevel = int.Parse(groups[2])
};
content = setUserLevelMsg;
}
//Remove user
else if (removeUser.IsMatch(command))
{
var userName = removeUser.Match(command).Groups[1].Value;
msgCommand = Command.CONF_REMOVE_USER;
var removeUserMsg = new SingleValueMessage {
Value = userName
};
content = removeUserMsg;
}
//Upload file
else if (putProgram.IsMatch(command) || putPipeline.IsMatch(command))
{
var isProgram = putProgram.IsMatch(command);
var groups = isProgram
? putProgram.Match(command).Groups.Select(a => a.Value).ToList()
: putPipeline.Match(command).Groups.Select(a => a.Value).ToList();
msgCommand = isProgram ? Command.CONF_PUT_PROGRAM : Command.CONF_PUT_PIPELINE;
var putMsg = new PutMessage
{
TargetName = groups[2],
TargetType = isProgram ? TargetTypes.PROGRAM : TargetTypes.PIPELINE,
Content = File.ReadAllBytes(groups[1]),
Runtime = groups[3]
};
content = putMsg;
}
//Distribute program/pipeline to child
else if (distribute.IsMatch(command))
{
var groups = distribute.Match(command).Groups.Select(a => a.Value).ToList();
msgCommand = Command.CONF_DISTRIBUTE;
var distributeMsg = new DistributeMessage
{
File = groups[1],
Target = groups[2]
};
content = distributeMsg;
}
//Get status
else if (getStatus.IsMatch(command))
{
var groups = getStatus.Match(command).Groups.Select(a => a.Value).ToList();
msgCommand = Command.CONF_GET_STATUS;
var statusTarget = StatusTarget.All;
switch (groups[1].First().ToString().ToUpper())
{
case "A":
statusTarget = StatusTarget.All;
break;
case "N":
statusTarget = StatusTarget.Nodes;
break;
case "S":
statusTarget = StatusTarget.Self;
break;
}
var getStatusMsg = new GetStatusMessage
{
Target = statusTarget,
StatusInfo = new List <Status>()
};
content = getStatusMsg;
}
//Ok?
else if (ok.IsMatch(command))
{
msgCommand = Command.OK;
var okMsg = new EmptyMessage();
content = okMsg;
}
//Fail!
else if (fail.IsMatch(command))
{
msgCommand = Command.FAIL;
var failMsg = new EmptyMessage();
content = failMsg;
}
if (msgCommand != Command.UNKNOWN)
{
var response = NodeCommunicationClient.Send(
_configuration.ConfigurationToolAddress,
_configuration.User,
_configuration.Password,
content,
msgCommand,
CONFIG);
if (response.Message.Command == Command.OK)
{
switch (msgCommand)
{
case Command.CONF_GET_STATUS:
var statusMessage =
MessagePackSerializer.Deserialize <GetStatusMessage>(response.Content);
Console.WriteLine();
statusMessage.StatusInfo.ForEach(stat =>
{
Console.WriteLine($"{stat.Name}");
Console.WriteLine($"{stat.Name} - " + (stat.Up ? "UP" : "DOWN") + "\n",
stat.Up ? Log.Green : Log.Red);
});
break;
case Command.OK:
Console.WriteLine("Ok!", Log.Green);
break;
case Command.FAIL:
Console.WriteLine(":(", Log.Red);
break;
}
}
else
{
Console.WriteLine(
$"Execution at node failed!:\n{MessagePackSerializer.Deserialize<SingleValueMessage>(response.Content).Value}",
Log.Red);
}
}
else
{
Console.WriteLine($"Unknown command: {command}!", Log.Red);
}
}
}
private void _ProcessMessage(object rawMessage, object tag)
{
User user = tag as User;
if (user == null)
{
return;
}
try
{
if (!(rawMessage is RemoteControlSystem.ClientMessage.PingMessage))
{
if (rawMessage is LoginMessage)
{
LoginMessage loginMessage = rawMessage as LoginMessage;
if (user.IsValid)
{
throw new ArgumentException("Cannot login twice - " + loginMessage.Account);
}
this.Login(user, loginMessage.Account, loginMessage.Password);
}
else if (rawMessage is NotifyMessage)
{
this.CheckAuthority(user, Authority.Supervisor);
this.NotifyMessage(user, rawMessage as NotifyMessage);
}
else if (rawMessage is ChangeMyPasswordMessage)
{
this.CheckAuthority(user, Authority.UserMonitor);
ChangeMyPasswordMessage changeMyPasswordMessage = rawMessage as ChangeMyPasswordMessage;
this.ChangeMyPassword(user, changeMyPasswordMessage.OldPassword, changeMyPasswordMessage.NewPassword);
}
else if (rawMessage is GetUserListMessage)
{
this.CheckAuthority(user, Authority.Supervisor);
this.GetUserList(user);
}
else if (rawMessage is AddUserMessage)
{
this.CheckAuthority(user, Authority.Supervisor);
AddUserMessage addUserMessage = rawMessage as AddUserMessage;
this.AddUser(user, addUserMessage.Account, addUserMessage.Password, addUserMessage.Authority);
}
else if (rawMessage is RemoveUserMessage)
{
this.CheckAuthority(user, Authority.Supervisor);
RemoveUserMessage removeUserMessage = rawMessage as RemoveUserMessage;
this.RemoveUser(user, removeUserMessage.Account);
}
else if (rawMessage is ChangePasswordMessage)
{
this.CheckAuthority(user, Authority.Supervisor);
ChangePasswordMessage changePasswordMessage = rawMessage as ChangePasswordMessage;
this.ChangePassword(user, changePasswordMessage.Account, changePasswordMessage.NewPassword);
}
else if (rawMessage is ChangeAuthorityMessage)
{
this.CheckAuthority(user, Authority.Supervisor);
ChangeAuthorityMessage changeAuthorityMessage = rawMessage as ChangeAuthorityMessage;
this.ChangeAuthority(user, changeAuthorityMessage.Account, changeAuthorityMessage.Authority);
}
else if (rawMessage is GetUserAuthMesssage)
{
this.CheckAuthority(user, Authority.UserWatcher);
this.GetUserAuthority(user, rawMessage as GetUserAuthMesssage);
}
else if (rawMessage is ControlEnterMessage)
{
this.CheckAuthority(user, Authority.ChiefGM);
this.ControlEnter(user);
}
else if (rawMessage is ControlFinishMessage)
{
this.CheckMutex(user);
this.ControlFinish(user);
}
else if (rawMessage is ControlRequestMessage)
{
this.CheckAuthority(user, Authority.UserKicker);
ControlRequestMessage controlRequestMessage = rawMessage as ControlRequestMessage;
this.SendControlProtocol(user, controlRequestMessage.Packet, controlRequestMessage.IDs);
}
else if (rawMessage is WorkGroupChangeMessage)
{
this.CheckMutex(user);
WorkGroupChangeMessage workGroupChangeMessage = rawMessage as WorkGroupChangeMessage;
this.WorkGroupChange(user, workGroupChangeMessage.WorkGroup);
}
else if (rawMessage is ServerGroupChangeMessage)
{
this.CheckMutex(user);
ServerGroupChangeMessage serverGroupChangeMessage = rawMessage as ServerGroupChangeMessage;
this.ServerGroupChange(user, serverGroupChangeMessage.ServerGroup);
}
else if (rawMessage is TemplateChangeMessage)
{
this.CheckMutex(user);
TemplateChangeMessage templateChangeMessage = rawMessage as TemplateChangeMessage;
this.TemplateChange(user, templateChangeMessage.Template);
}
else if (rawMessage is ChildProcessLogRequestMessage)
{
ChildProcessLogRequestMessage childProcessLogRequestMessage = rawMessage as ChildProcessLogRequestMessage;
this.SendFunctionProtocol(user, SerializeWriter.ToBinary <ChildProcessLogRequestMessage>(childProcessLogRequestMessage).Bytes, childProcessLogRequestMessage.ClientID);
}
else if (rawMessage is ChildProcessLogListRequestMessage)
{
ChildProcessLogListRequestMessage childProcessLogListRequestMessage = rawMessage as ChildProcessLogListRequestMessage;
this.SendFunctionProtocol(user, SerializeWriter.ToBinary <ChildProcessLogListRequestMessage>(childProcessLogListRequestMessage).Bytes, childProcessLogListRequestMessage.ClientID);
}
else if (rawMessage is ChildProcessLogConnectMessage)
{
ChildProcessLogConnectMessage childProcessLogConnectMessage = rawMessage as ChildProcessLogConnectMessage;
this.logManager.AddListener(user, childProcessLogConnectMessage.ClientID, childProcessLogConnectMessage.ProcessName, childProcessLogConnectMessage.ProcessID);
}
else if (rawMessage is ChildProcessLogDisconnectMessage)
{
ChildProcessLogDisconnectMessage childProcessLogDisconnectMessage = rawMessage as ChildProcessLogDisconnectMessage;
this.logManager.RemoveListener(user, childProcessLogDisconnectMessage.ClientID, childProcessLogDisconnectMessage.ProcessName, childProcessLogDisconnectMessage.ProcessID);
}
else
{
if (!(rawMessage is ExeInfoRequestMessage))
{
throw new RCServerException("Invalid packet! try to update latest version");
}
ExeInfoRequestMessage exeInfoRequestMessage = rawMessage as ExeInfoRequestMessage;
this.SendFunctionProtocol(user, SerializeWriter.ToBinary <ExeInfoRequestMessage>(exeInfoRequestMessage).Bytes, exeInfoRequestMessage.ClientID);
}
}
}
catch (RCServerException ex)
{
this.NotifyMessage(user, MessageType.Error, ex.Message, new object[0]);
}
catch (Exception ex2)
{
if (rawMessage == null)
{
this.NotifyMessage(MessageType.Message, ex2.ToString(), new object[0]);
}
else
{
IPAddress address = user.Connection.RemoteEndPoint.Address;
this.NotifyMessage(MessageType.Message, "[{0}/{1}] - {2}", new object[]
{
user.ClientId,
address.ToString(),
ex2.ToString()
});
user.Connection.Disconnect();
}
}
}
