public Result <IBotMessage> Execute(CommandArgumentContainer args)
{
//TODO: it's temp solution
string message = string.Join(", ", _context.Queams.ToList().Select(q => q.Name));
return(Result.Ok <IBotMessage>(new BotTextMessage($"Queams: {message}")));
}
public void PingCommand_ShouldReturnPong()
{
PingCommand pingCommand = new PingCommand();
CommandArgumentContainer fakeContainer = A.Fake <CommandArgumentContainer>();
pingCommand.Execute(fakeContainer).Result.IsSuccess.Should().Be(true);
}
public Result Execute(CommandArgumentContainer args)
{
try
{
var parseResult = ParseArguments(args, out string groupName, out DateTime dateTime);
if (!parseResult.IsSuccess)
{
return(parseResult);
}
Task <GroupScheduleModel> scheduleTask = _itmoProvider.ScheduleApi.GetGroupSchedule(groupName);
scheduleTask.WaitSafe();
if (scheduleTask.IsFaulted)
{
return(new Result(false, $"{groupName} from {args.Sender.GroupId} is invalid"));
}
string result = FormatResult(scheduleTask.Result, dateTime);
return(new Result(true, result));
}
catch (Exception e)
{
return(new Result(false, $"ScheduleCommand from {args.Sender.GroupId} was failed with exception {e.Message}").WithException(e));
}
}
private Result ParseArguments(CommandArgumentContainer args, out string groupName, out DateTime date)
{
try
{
using var dbContext = new DatabaseContext();
if (args.Arguments.Count == 0)
{
groupName = dbContext.GroupSettings.Find(args.Sender.GroupId.ToString()).GroupNumber;
date = DateTime.Today;
return(new Result(true));
}
if (args.Arguments.Count == 1)
{
string dateAsString = args.Arguments.FirstOrDefault();
bool result = DateTime.TryParse(dateAsString, out date);
if (result)
{
groupName = dbContext.GroupSettings.Find(args.Sender.GroupId.ToString()).GroupNumber;
return(new Result(true));
}
else
{
groupName = null;
return(new Result(false, $"dateTime {dateAsString} from {args.Sender.GroupId} is invalid"));
}
}
if (args.Arguments.Count == 2)
{
groupName = args.Arguments.FirstOrDefault();
bool dateTimeResult = DateTime.TryParse(args.Arguments.Last(), out date);
if (dateTimeResult == false)
{
return(new Result(false,
$"dateTime {args.Arguments.Last()} from {args.Sender.GroupId} is invalid"));
}
LoggerHolder.Log.Information(date.ToShortDateString());
return(new Result(true));
}
groupName = null;
date = DateTime.MinValue;
return(new Result(false, $"{args.Sender.GroupId}, invalid arguments"));
}
catch (Exception e)
{
groupName = string.Empty;
date = DateTime.MinValue;
return(new Result(false, $"Parse argument from {args.Sender.GroupId} was failed with exception {e.Message}").WithException(e));
}
}
public Result ExecuteCommand(CommandArgumentContainer args)
{
Result <IBotCommand> commandTask = _commands.GetCommand(args.CommandName);
if (!commandTask.IsSuccess)
{
return(commandTask);
}
var command = commandTask.Value;
var commandExecuteResult = command.Execute(args);
return(commandExecuteResult);
}
public Result <IBotMessage> Execute(CommandArgumentContainer args)
{
//TODO: HACK
Queser queser = _context.Quesers.Find(TempKey);
if (queser is null)
{
EntityEntry <Queser> entityEntry = _context.Quesers.Add(Queser.Create("Fake"));
queser = entityEntry.Entity;
}
_context.Queams.Add(Queam.Create(args.Arguments[0], queser));
_context.SaveChanges();
return(Result.Ok <IBotMessage>(new BotTextMessage($"Created new queam: {args.Arguments[0]}")));
}
public Result Execute(CommandArgumentContainer args)
{
try
{
var result = string.Join(Environment.NewLine + Environment.NewLine,
_commandList.Commands.ToList()
.Select(commands =>
$"{commands.Value.CommandName} : {commands.Value.Description}, {Environment.NewLine}args: " +
$"{string.Join(", ", commands.Value.Args.Select(s => s))}"));
return(new Result(true, result));
}
catch (Exception e)
{
return(new Result(false, $"HelpCommand from {args.Sender.GroupId} was failed with exception {e.Message}").WithException(e));
}
}
private void ApiProviderOnMessage(object sender, BotEventArgs e)
{
try
{
CommandArgumentContainer commandWithArgs = Utilities.ParseCommand(e);
var commandTaskResult = _commandHandler.IsCommandCorrect(commandWithArgs);
LoggerHolder.Log.Verbose(commandTaskResult.ExecuteMessage);
if (!commandTaskResult.IsSuccess)
{
return;
}
var commandExecuteResult = _commandHandler.ExecuteCommand(commandWithArgs);
if (!commandExecuteResult.IsSuccess)
{
LoggerHolder.Log.Warning(commandExecuteResult.ExecuteMessage);
}
var writeMessageResult =
_botProvider.WriteMessage(new SenderData(e.GroupId), commandExecuteResult.ExecuteMessage);
LoggerHolder.Log.Verbose(writeMessageResult.ExecuteMessage);
}
catch (Exception error)
{
LoggerHolder.Log.Error(error.Message);
_botProvider.Dispose();
var result = _botProvider.Initialize();
if (result.Exception != null)
{
LoggerHolder.Log.Verbose(result.ExecuteMessage);
}
LoggerHolder.Log.Verbose(result.ExecuteMessage);
}
}
public Result IsCommandCorrect(CommandArgumentContainer args)
{
var commandTask = _commands.GetCommand(args.CommandName);
if (!commandTask.IsSuccess)
{
return(commandTask);
}
var command = commandTask.Value;
if (command.CanExecute(args))
{
return(new Result(true, $"command {args.CommandName} can be executable with args {string.Join(' ', args.Arguments.Select(x => x))}"));
}
var loggerMessage = $"command {command.CommandName} not executable with args {string.Join(' ', args.Arguments.Select(x=>x))}";
//loggerMessage = args.Arguments.Aggregate(loggerMessage, (current, t) => current + (t + " "));
return(new Result(false, loggerMessage));
}
public Result Execute(CommandArgumentContainer args)
{
try
{
using var dbContext = new DatabaseContext();
var oldSetting = dbContext.GroupSettings.Find(args.Sender.GroupId.ToString());
if (oldSetting != null)
{
dbContext.GroupSettings.Remove(oldSetting);
}
dbContext.GroupSettings.Add(new GroupSettings(args.Sender.GroupId.ToString(), args.Arguments.FirstOrDefault()));
dbContext.SaveChanges();
return(new Result(true, $"SetGroup from {args.Sender.GroupId} with {args.Arguments.FirstOrDefault()} was successfully"));
}
catch (Exception e)
{
return(new Result(false, $"SetGroup from {args.Sender.GroupId} was with exception {e.Message}").WithException(e));
}
}
public Result CanExecute(CommandArgumentContainer args)
{
return(Result.Ok(true));
}
public BotEventArgs(IBotMessage message, CommandArgumentContainer commandWithArgs) : this(message, commandWithArgs.Sender)
{
}
public bool CanExecute(CommandArgumentContainer args)
{
return(true);
}
public Result CanExecute(CommandArgumentContainer args)
{
throw new System.NotImplementedException();
}
public Task <Result <IBotMessage> > Execute(CommandArgumentContainer args)
{
IBotMessage message = new BotTextMessage("Pong!");
return(Task.FromResult(Result.Ok(message)));
}
public Task <Result <string> > ExecuteAsync(CommandArgumentContainer args)
{
throw new System.NotImplementedException();
}
public Result Execute(CommandArgumentContainer args)
{
return(new Result(true, "Pong"));
}
