public async Task<IActionResult> Register(UserModel userModel)
{
if (!ModelState.IsValid)
{
return ErrorResult();
}
var command = new RegisterUserCommand(userModel.UserName, userModel.EMail, userModel.Password);
var result = await _messageDispatcher.Execute(command);
return ErrorResult(result);
}
public string DispatchCommand(string[] commandParameters)
{
var command = commandParameters[0].ToLower();
string result;
switch (command)
{
case "registeruser":
result = RegisterUserCommand.Execute(commandParameters);
break;
case "addtown":
result = AddTownCommand.Execute(commandParameters);
break;
case "modifyuser":
result = ModifyUserCommand.Execute(commandParameters);
break;
case "deleteuser":
result = DeleteUser.Execute(commandParameters);
break;
case "addtag":
result = AddTagCommand.Execute(commandParameters);
break;
case "exit":
result = ExitCommand.Execute();
break;
case "makefriends":
result = AddFriendCommand.Execute(commandParameters);
break;
case "acceptfriend":
result = AcceptFriendCommand.Execute(commandParameters);
break;
case "listfriends":
result = PrintFriendsListCommand.Execute(commandParameters);
break;
case "createalbum":
result = CreateAlbumCommand.Execute(commandParameters);
break;
case "addtagto":
result = AddTagToCommand.Execute(commandParameters);
break;
case "sharealbum":
result = ShareAlbumCommand.Execute(commandParameters);
break;
case "uploadpicture":
result = UploadPictureCommand.Execute(commandParameters);
break;
case "login":
result = LoginCommand.Execute(commandParameters);
break;
case "logout":
result = LogoutCommand.Execute();
break;
default: throw new InvalidOperationException($"Command {command} not valid!");
}
return(result);
}
public async Task <IActionResult> Register([FromBody] RegisterUserCommand command)
{
await _mediator.Send(command);
return(NoContent());
}
public string DispatchCommand(string[] commandParameters)
{
string commandName = commandParameters[0];
commandParameters = commandParameters.Skip(1).ToArray();
string result = string.Empty;
switch (commandName)
{
case "RegisterUser":
RegisterUserCommand registerUser = new RegisterUserCommand(new UserService());
result = registerUser.Execute(commandParameters);
break;
case "Login":
LoginCommand loginCommand = new LoginCommand(new UserService());
result = loginCommand.Execute(commandParameters);
break;
case "Logout":
LogoutCommand logoutCommand = new LogoutCommand(new UserService());
result = logoutCommand.Execute(commandParameters);
break;
case "DeleteUser":
DeleteUserCommand deleteUser = new DeleteUserCommand(new UserService());
result = deleteUser.Execute(commandParameters);
break;
case "CreateEvent":
CreateEventCommand createEvent = new CreateEventCommand(new EventService());
result = createEvent.Execute(commandParameters);
break;
case "CreateTeam":
CreateTeamCommand createTeam = new CreateTeamCommand(new TeamService());
result = createTeam.Execute(commandParameters);
break;
case "InviteToTeam":
InviteToTeamCommand invToTeam = new InviteToTeamCommand(new TeamService(), new UserService());
result = invToTeam.Execute(commandParameters);
break;
case "AcceptInvite":
AcceptInviteCommand acceptInvite = new AcceptInviteCommand(new TeamService(), new UserService());
result = acceptInvite.Execute(commandParameters);
break;
case "DeclineInvite":
DeclineInviteCommand declineInvite = new DeclineInviteCommand(new TeamService(), new UserService());
result = declineInvite.Execute(commandParameters);
break;
case "KickMember":
KickMemberCommand kickMember = new KickMemberCommand(new TeamService(), new UserService());
result = kickMember.Execute(commandParameters);
break;
case "Disband":
DisbandCommand disbandTeam = new DisbandCommand(new TeamService(), new UserService());
result = disbandTeam.Execute(commandParameters);
break;
case "AddTeamTo":
AddTeamToCommand addTeam = new AddTeamToCommand(new EventService(), new TeamService());
result = addTeam.Execute(commandParameters);
break;
case "ShowEvent":
ShowEventCommand showEvent = new ShowEventCommand(new EventService());
result = showEvent.Execute(commandParameters);
break;
case "ShowTeam":
ShowTeamCommand showTeam = new ShowTeamCommand(new TeamService());
result = showTeam.Execute(commandParameters);
break;
case "ImportUsers":
ImportUsersCommand importUsers = new ImportUsersCommand(new UserService());
result = importUsers.Execute(commandParameters);
break;
case "ImportTeams":
ImportTeamsCommand importTeams = new ImportTeamsCommand(new TeamService());
result = importTeams.Execute(commandParameters);
break;
case "ExportTeam":
ExportTeamCommand exportTeam = new ExportTeamCommand(new TeamService());
result = exportTeam.Execute(commandParameters);
break;
case "Exit":
ExitCommand exit = new ExitCommand();
exit.Execute(commandParameters);
break;
default:
throw new NotSupportedException($"Command {commandName} not valid!");
}
return(result);
}
public async Task <IActionResult> Register([FromBody] RegisterUserCommand createUser)
{
return(GetResponseOnlyResult(await Mediator.Send(createUser)));
}
public string DispatchCommand(string[] commandParameters)
{
string cmdName = commandParameters[0];
commandParameters = commandParameters.Skip(1).ToArray();
string result = string.Empty;
TagService tagService = new TagService();
UserService userService = new UserService();
TownService townService = new TownService();
AlbumService albumService = new AlbumService();
PictureService pictureService = new PictureService();
switch (cmdName)
{
case "Login":
LoginUserCommand loginUser = new LoginUserCommand(userService);
result = loginUser.Execute(commandParameters);
break;
case "RegisterUser":
RegisterUserCommand registerUser = new RegisterUserCommand(userService);
result = registerUser.Execute(commandParameters);
break;
case "Logout":
LogoutCommand logout = new LogoutCommand();
result = logout.Execute();
break;
case "CreateAlbum":
CreateAlbumCommand createAlbum = new CreateAlbumCommand(albumService, userService, tagService);
result = createAlbum.Execute(commandParameters);
break;
case "ShareAlbum":
ShareAlbumCommand shareAlbum = new ShareAlbumCommand(albumService, userService);
result = shareAlbum.Execute(commandParameters);
break;
case "UploadPicture":
UploadPictureCommand uploadPicture = new UploadPictureCommand(albumService, pictureService);
result = uploadPicture.Execute(commandParameters);
break;
case "AddTown":
AddTownCommand addTown = new AddTownCommand(townService);
result = addTown.Execute(commandParameters);
break;
case "AddTag":
AddTagCommand addTag = new AddTagCommand(tagService);
result = addTag.Execute(commandParameters);
break;
case "AddTagTo":
AddTagToCommand addTagTo = new AddTagToCommand(tagService, albumService);
result = addTagTo.Execute(commandParameters);
break;
case "ModifyUser":
ModifyUserCommand modifyUser = new ModifyUserCommand(userService, townService);
result = modifyUser.Execute(commandParameters);
break;
case "MakeFriends":
MakeFriendsCommand makeFriends = new MakeFriendsCommand(userService);
result = makeFriends.Execute(commandParameters);
break;
case "DeleteUser":
DeleteUser deleteUser = new DeleteUser(userService);
result = deleteUser.Execute(commandParameters);
break;
case "ListFriends":
PrintFriendsListCommand listFriends = new PrintFriendsListCommand(userService);
result = listFriends.Execute(commandParameters);
break;
case "Exit":
ExitCommand exit = new ExitCommand();
exit.Execute();
break;
default:
throw new NotImplementedException($"Command < {cmdName} > not valid!");
}
return(result);
}
public string DispatchCommand(string[] commandParameters)
{
string commandName = commandParameters[0];
commandParameters = commandParameters.Skip(1).ToArray();
string result = string.Empty;
switch (commandName)
{
case "RegisterUser":
RegisterUserCommand registerUser = new RegisterUserCommand();
result = registerUser.Execute(commandParameters);
break;
case "AddTown":
AddTownCommand addTown = new AddTownCommand();
result = addTown.Execute(commandParameters);
break;
case "ModifyUser":
ModifyUserCommand modifyUser = new ModifyUserCommand();
result = modifyUser.Execute(commandParameters);
break;
case "DeleteUser":
DeleteUserCommand deleteUser = new DeleteUserCommand();
result = deleteUser.Execute(commandParameters);
break;
case "AddTag":
AddTagCommand addTag = new AddTagCommand();
result = addTag.Execute(commandParameters);
break;
case "CreateAlbum":
CreateAlbumCommand createAlbum = new CreateAlbumCommand();
result = createAlbum.Execute(commandParameters);
break;
case "AddTagTo":
AddTagToCommand addTagTo = new AddTagToCommand();
result = addTagTo.Execute(commandParameters);
break;
case "MakeFriends":
MakeFriendsCommand makeFriend = new MakeFriendsCommand();
result = makeFriend.Execute(commandParameters);
break;
case "ListFriends":
PrintFriendsListCommand listFriends = new PrintFriendsListCommand();
result = listFriends.Execute(commandParameters);
break;
case "UploadPicture":
UploadPictureCommand uploadPicture = new UploadPictureCommand();
result = uploadPicture.Execute(commandParameters);
break;
case "ShareAlbum":
ShareAlbumCommand shareAlbum = new ShareAlbumCommand();
result = shareAlbum.Execute(commandParameters);
break;
case "Login":
LoginCommand login = new LoginCommand();
result = login.Execute(commandParameters);
break;
case "Logout":
LogoutCommand logout = new LogoutCommand();
result = logout.Execute(commandParameters);
break;
case "Exit":
ExitCommand exit = new ExitCommand();
exit.Execute();
break;
default:
Console.WriteLine($"Command {commandName} not valid!");
break;
}
return(result);
}
public GenericCommandResult RegisterUser(
[FromServices] IUserService service,
[FromBody] RegisterUserCommand command)
{
return(service.Register(command));
}
public async Task <IActionResult> Register([FromBody] RegisterUserCommand createUser)
{
var result = await Mediator.Send(createUser);
return(result.Success ? Ok(result) : BadRequest(result));
}
public async Task <IActionResult> RegisterUser([FromForm] RegisterUserCommand command)
{
return(await SendCommand(DispatcherActorsNames.UserCommandActor, command));
}
public Task <Result <User> > Handle(RegisterUserCommand command, CancellationToken cancellationToken)
=> _generator.GenerateToken(new { command.Email, _systemTime.Now })
.OnSuccess(token => User.Register(command.Email, command.Password, token))
.OnSuccess(async user => await _unitOfWork.Add(user))
.OnSuccess(async user => await _unitOfWork.Compleate());
public string Dispatch(string input)
{
string result = string.Empty;;
string[] inputArgs = input
.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
string commandName = inputArgs.Length > 0 ? inputArgs[0].ToLower() : string.Empty;
inputArgs = inputArgs.Skip(1).ToArray();
switch (commandName)
{
case "exit":
result = ExitCommand.Execute(inputArgs);
break;
case "registeruser":
result = RegisterUserCommand.Execute(inputArgs);
break;
case "login":
result = LoginCommand.Execute(inputArgs);
break;
case "logout":
result = LogoutCommand.Execute(inputArgs);
break;
case "deleteuser":
result = DeleteUserCommand.Execute(inputArgs);
break;
case "createevent":
result = CreateEventInternalCommand.Execute(inputArgs);
break;
case "createteam":
result = CreateTeamCommand.Execute(inputArgs);
break;
case "invitetoteam":
result = InviteToTeamCommand.Execute(inputArgs);
break;
case "acceptinvite":
result = AcceptInviteCommand.Execute(inputArgs);
break;
case "declineinvite":
result = DeclineInvitartionCommand.Execute(inputArgs);
break;
case "kickmember":
result = KickMemberInternalCommand.Execute(inputArgs);
break;
case "disband":
result = DisbandCommand.Execute(inputArgs);
break;
case "addteamto":
result = AddTeamToCommand.Execute(inputArgs);
break;
case "showevent":
result = ShowEventCommand.Execute(inputArgs);
break;
case "showteam":
result = ShowTeamCommand.Execute(inputArgs);
break;
default:
throw new NotSupportedException($"Command {commandName} not supported!");
}
return(result);
}
public async Task <UserProperty> Register(RegisterUserCommand command)
{
return(await Mediator.Send(command));
}
public async Task <ActionResult> RegisterUser([FromBody] RegisterUserCommand command)
{
return(Ok(await _mediator.Send(command)));
}
public RegisterUserService(RegisterUserCommand command, IUserRepository repository) : base(command)
{
_command = command;
_repository = repository;
}
public string Dispatch(string input)
{
string[] arguments = input.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
string commandName = arguments.Length > 0 ? arguments[0] : string.Empty;
arguments = arguments.Skip(1).ToArray();
switch (commandName)
{
case "RegisterUser":
RegisterUserCommand register = new RegisterUserCommand(authenticationManager);
return(register.Execute(arguments));
case "Login":
LogInCommand login = new LogInCommand(authenticationManager);
return(login.Execute(arguments));
case "Logout":
LogOutCommand logout = new LogOutCommand(authenticationManager);
return(logout.Execute(arguments));
case "DeleteUser":
DeleteUserCommand delete = new DeleteUserCommand(authenticationManager);
return(delete.Execute(arguments));
case "CreateEvent":
CreateEventCommand createEvent = new CreateEventCommand(authenticationManager);
return(createEvent.Execute(arguments));
case "CreateTeam":
CreateTeamCommand createTeam = new CreateTeamCommand(authenticationManager);
return(createTeam.Execute(arguments));
case "InviteToTeam":
InviteToTeamCommand inviteToTeam = new InviteToTeamCommand(authenticationManager);
return(inviteToTeam.Execute(arguments));
case "AcceptInvite":
AcceptInviteCommand acceptInvite = new AcceptInviteCommand(authenticationManager);
return(acceptInvite.Execute(arguments));
case "DeclineInvite":
DeclineInviteCommand declineInvite = new DeclineInviteCommand(authenticationManager);
return(declineInvite.Execute(arguments));
case "KickMember":
KickMemberCommand kickMember = new KickMemberCommand(authenticationManager);
return(kickMember.Execute(arguments));
case "Disband":
DisbandCommand disband = new DisbandCommand(authenticationManager);
return(disband.Execute(arguments));
case "AddTeamTo":
AddTeamToCommand addTeamToCommand = new AddTeamToCommand(authenticationManager);
return(addTeamToCommand.Execute(arguments));
case "ShowEvent":
ShowEventCommand showEvent = new ShowEventCommand(authenticationManager);
return(showEvent.Execute(arguments));
case "ShowTeam":
ShowTeamCommand showTeam = new ShowTeamCommand(authenticationManager);
return(showTeam.Execute(arguments));
case "Exit":
ExitCommand exitCommand = new ExitCommand();
return(exitCommand.Execute(arguments));
default:
throw new NotSupportedException($"Command {commandName} is not supported!");
}
}
public async Task <ActionResult> Register(RegisterUserCommand command)
{
await Mediator.Send(command);
return(Ok());
}
public async Task <IActionResult> Post([FromBody] RegisterUserCommand command)
{
var result = _handler.Handle(command);
return(await Response(result, _handler.Notifications));
}
public IActionResult Post([FromBody] RegisterUserCommand registerUserCommand)
{
var newUser = _identityApplicationService.RegisterUser(registerUserCommand);
return(CreatedAtAction(nameof(Get), new { tenantId = registerUserCommand.TenantId, userName = registerUserCommand.Username }, null));
}
public Task <IActionResult> RegisterUser([FromBody] RegisterStudentCommand student, [FromBody] RegisterUserCommand user)
{
RegisterStudentService service = new RegisterStudentService(student, user, null);
service.Run();
return(ReturnResponse(
service,
new { message = "Bem vindo ao balta.io" },
new { message = "Seu cadastro não pode ser efetuado" }
));
}
public async Task <IActionResult> RegisterUser([FromBody] RegisterUserCommand command)
{
return(await TryAsync(CommandAsync(command))
.Map(list => (IActionResult)Ok(list))
.IfFail(exception => (IActionResult)BadRequest(exception.Message)));
}
public string Dispatch(string input)
{
string result = string.Empty;
var inputArgs = input.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
string command = inputArgs.Length > 0 ? inputArgs[0] : string.Empty;
string[] commandArgs = inputArgs.Skip(1).ToArray();
switch (command.ToLower())
{
case "registeruser": result = new RegisterUserCommand().Execute(commandArgs);
break;
case "login": result = new LoginCommand().Execute(commandArgs);
break;
case "logout": result = new LogoutCommand().Execute(commandArgs);
break;
case "deleteuser": result = new DeleteUserCommand().Execute(commandArgs);
break;
case "createevent": result = new CreateEventCommand().Execute(commandArgs);
break;
case "createteam": result = new CreateTeamCommand().Execute(commandArgs);
break;
case "invitetoteam": result = new InviteToTeamCommand().Execute(commandArgs);
break;
case "acceptinvite": result = new AcceptInviteCommand().Execute(commandArgs);
break;
case "declineinvite": result = new DeclineInviteCommand().Execute(commandArgs);
break;
case "kickmember": result = new KickMemberCommand().Execute(commandArgs);
break;
case "disband": result = new DisbandCommand().Execute(commandArgs);
break;
case "addteamto": result = new AddTeamToCommand().Execute(commandArgs);
break;
case "showevent": result = new ShowEventCommand().Execute(commandArgs);
break;
case "showteam": result = new ShowTeamCommand().Execute(commandArgs);
break;
case "exit":
var exit = new ExitCommand().Execute(commandArgs);
break;
default: throw new NotSupportedException($"Command {command} not supported!");
}
return(result);
}
public string Dispatch(string input)
{
string result = string.Empty;
string[] inputArgs = input
.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
string commandName = inputArgs.Length > 0 ? inputArgs[0] : string.Empty;
inputArgs = inputArgs.Skip(1).ToArray();
switch (commandName.ToLower())
{
case "exit":
ExitCommand exit = new ExitCommand();
exit.Execute(inputArgs);
break;
case "registeruser":
RegisterUserCommand registerUserCommand = new RegisterUserCommand();
result = registerUserCommand.Execute(inputArgs);
break;
case "login":
LoginCommand login = new LoginCommand();
result = login.Execute(inputArgs);
break;
case "logout":
LogoutCommand logoutCommand = new LogoutCommand();
result = logoutCommand.Execute(inputArgs);
break;
case "deleteuser":
DeleteUserCommand deleteUserCommand = new DeleteUserCommand();
result = deleteUserCommand.Execute(inputArgs);
break;
case "createevent":
CreateEventCommand createEvent = new CreateEventCommand();
result = createEvent.Execute(inputArgs);
break;
case "createteam":
CreateTeamCommand createTeam = new CreateTeamCommand();
result = createTeam.Execute(inputArgs);
break;
case "invitetoteam":
InviteToTeamCommand inviteToTeamCommand = new InviteToTeamCommand();
result = inviteToTeamCommand.Execute(inputArgs);
break;
case "acceptinvite":
AcceptInviteCommand acceptInviteCommand = new AcceptInviteCommand();
result = acceptInviteCommand.Execute(inputArgs);
break;
case "declineinvite":
DeclineInviteCommand declineInviteCommand = new DeclineInviteCommand();
result = declineInviteCommand.Execute(inputArgs);
break;
case "kickmember":
KickMemberCommand kickMemberCommand = new KickMemberCommand();
result = kickMemberCommand.Execute(inputArgs);
break;
case "disband":
DisbandCommand disbandCommand = new DisbandCommand();
result = disbandCommand.Execute(inputArgs);
break;
case "addteamto":
AddTeamToCommand addTeamToCommand = new AddTeamToCommand();
result = addTeamToCommand.Execute(inputArgs);
break;
case "showevent":
ShowEventCommand showEventCommand = new ShowEventCommand();
result = showEventCommand.Execute(inputArgs);
break;
case "showteam":
ShowTeamCommand showTeamCommand = new ShowTeamCommand();
result = showTeamCommand.Execute(inputArgs);
break;
default:
throw new NotSupportedException($"Command {commandName} not supported!");
}
return(result);
}
public async Task <IActionResult> Register(RegisterUserCommand request, CancellationToken token)
{
var result = await Mediator.Send(request, token);
return(Ok(result));
}
public IActionResult RegisterUser([FromBody, Required] RegisterUserCommand command)
{
Mediator.SendCommand(command);
return(Ok());
}
public async Task <ActionResult <Guid> > Register([FromBody] RegisterUserCommand command)
{
var userId = await Mediator.Send(command);
return(Ok(userId));
}
public async Task <IActionResult> RegisterUser(RegisterUserCommand registerUserCommand)
{
var result = await _mediator.Send(registerUserCommand);
return(Json(result.IsSuccessful ? string.Empty : result.ErrorMessage));
}
public async Task <ActionResult> Register(RegisterUserCommand command) => await this.Send(command);
public string Dispatch(string input)
{
string output = String.Empty;
string[] inputArgs = input.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
string commandName = inputArgs.Length > 0 ? inputArgs[0] : String.Empty;
string[] commandArgs = inputArgs.Skip(1).ToArray();
ICommand command = null;
switch (commandName)
{
case "AcceptInvite":
command = new AcceptInviteCommand(serviceProvider);
break;
case "AddTeamTo":
command = new AddTeamToCommand(serviceProvider);
break;
case "CreateEvent":
command = new CreateEventCommand(serviceProvider);
break;
case "CreateTeam":
command = new CreateTeamCommand(serviceProvider);
break;
case "DeclineInvite":
command = new DeclineInviteCommand(serviceProvider);
break;
case "DeleteUser":
command = new DeleteUserCommand(serviceProvider);
break;
case "Disband":
command = new DisbandCommand(serviceProvider);
break;
case "Exit":
command = new ExitCommand();
break;
case "InviteToTeam":
command = new InviteToTeamCommand(serviceProvider);
break;
case "KickMember":
command = new KickMemberCommand(serviceProvider);
break;
case "Login":
command = new LoginCommand(serviceProvider);
break;
case "Logout":
command = new LogoutCommand(serviceProvider);
break;
case "RegisterUser":
command = new RegisterUserCommand(serviceProvider);
break;
case "ShowEvent":
command = new ShowEventCommand(serviceProvider);
break;
case "ShowTeam":
command = new ShowTeamCommand(serviceProvider);
break;
default:
throw new NotSupportedException(String.Format(Messages.CommandNotSupported, commandName));
}
output = command.Execute(commandArgs);
return(output);
}
public async Task <ActionResult <Application.Users.Commands.RegisterUser.UserVm> > Register(RegisterUserCommand command)
{
return(await Mediator.Send(command));
}
public string DispatchCommand(string[] commandParameters)
{
string commandName = commandParameters[0];
var commandArg = commandParameters.Skip(1).ToArray();
string result = string.Empty;
switch (commandName)
{
case "RegisterUser":
var registerUser = new RegisterUserCommand();
result = registerUser.Execute(commandArg);
break;
case "AddTown":
var addTown = new AddTownCommand();
result = addTown.Execute(commandArg);
break;
case "ModifyUser":
var modifyUser = new ModifyUserCommand();
result = modifyUser.Execute(commandArg);
break;
case "DeleteUser":
var deleteUser = new DeleteUser();
result = deleteUser.Execute(commandArg);
break;
case "AddTag":
var tag = new AddTagCommand();
result = tag.Execute(commandArg);
break;
case "CreateAlbum":
var album = new CreateAlbumCommand();
result = album.Execute(commandArg);
break;
case "AddTagTo":
var tagTo = new AddTagToCommand();
result = tagTo.Execute(commandArg);
break;
case "AddFriend":
var addFriend = new AddFriendCommand();
result = addFriend.Execute(commandArg);
break;
case "AcceptFriend":
var acceptFriend = new AcceptFriendCommand();
result = acceptFriend.Execute(commandArg);
break;
case "ListFriends":
var listFriend = new PrintFriendsListCommand();
result = listFriend.Execute(commandArg);
break;
case "ShareAlbum":
var shareAlbum = new ShareAlbumCommand();
result = shareAlbum.Execute(commandArg);
break;
case "UploadPicture":
var uploadPicture = new UploadPictureCommand();
result = uploadPicture.Execute(commandArg);
break;
case "Exit":
ExitCommand.Execute();
break;
case "Login":
var login = new LoginCommand();
result = login.Execute(commandArg);
break;
case "Logout":
var logout = new LogoutCommand();
result = logout.Execute();
break;
default:
throw new InvalidOperationException($"Command {commandName} not valid!");
}
return(result);
}
