public void Initialize(int scriptId, IPlatformDatabase database)
{
try
{
var script = database.Scripts.First(x => x.Id == scriptId);
if (!string.IsNullOrEmpty(script?.Name))
{
var deserializer = new YamlDotNet.Serialization.Deserializer();
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(script.Instruction)))
using (var reader = new StreamReader(stream))
{
var behavior = deserializer.Deserialize <Behavior>(reader.ReadToEnd());
if (BehaviorValidator.IsValid(behavior))
{
_behavior = behavior;
}
}
}
}
catch (Exception ex)
{
_logger.LogCritical(ex, $"Cannot build behavior. ScriptId: {scriptId}.");
throw;
}
}
public Task <InterpretationResult> InterpretAsync(IPlatformDatabase database, Dialog dialog)
{
return(Task.FromResult(new InterpretationResult
{
ResultType = ExpressionResultType.Boolean,
Result = true
}));
}
public TransportService(
IPlatformDatabase database,
ILogger <TransportService> logger
)
{
_database = database;
_logger = logger;
}
public ScriptService(
IPlatformDatabase database,
ILogger <ScriptService> logger
)
{
_database = database;
_logger = logger;
}
public BotService(
ILogger <BotService> logger,
IPlatformDatabase database
)
{
_logger = logger;
_database = database;
}
public Database(IPlatformDatabase database)
{
_database = database;
_queueCommand = new BlockingQueue <Command>();
// Background Init of database.
Init();
Start();
}
public DiscordService(
ILogger <DiscordService> logger,
IOptions <DiscordOptions> options,
IBehaviorExecutor behaviorExecutor,
IPlatformDatabase database,
ServiceContext serviceContext
)
: base(logger, options, behaviorExecutor, database, serviceContext)
{
_logger = logger;
_options = options.Value;
}
public Task <InterpretationResult> InterpretAsync(IPlatformDatabase database, Dialog dialog)
{
var expression = ExpressionFactory.ParseExpression(_parameters);
var command = _commandFactory.CreateCommand(expression.@operator);
command.Parameter = expression.parameters;
return(Task.FromResult(new InterpretationResult
{
Command = command,
ResultType = ExpressionResultType.TransportCommand,
State = InterpretationResultState.Completed
}));
}
public TelegramService(
ILogger <TelegramService> logger,
IOptions <TelegramOptions> options,
IBehaviorExecutor behaviorExecutor,
IPlatformDatabase database,
ServiceContext serviceContext
)
: base(logger, options, behaviorExecutor, database, serviceContext)
{
_logger = logger;
_options = options.Value;
_botId = serviceContext.BotId;
_client = new TelegramBotClient(_options.Token);
_client.OnMessage += OnMessageAsync;
_client.OnReceiveError += OnReceiveError;
}
public async Task <Message> CreateDialogMessage(IPlatformDatabase dbContext, Dialog dialog, string payload, MessageDirection direction)
{
var message =
new Message
{
Payload = payload,
Direction = direction
};
dialog.Messages.Add(message);
dialog.CurrentMessage = message;
dbContext.Dialogs.Update(dialog);
await dbContext.SaveChangesAsync();
return(message);
}
protected IngoingServiceBase(
ILogger <IngoingServiceBase> logger,
IOptions <TransportOptions> options,
IBehaviorExecutor behaviorExecutor,
IPlatformDatabase database,
ServiceContext serviceContext
)
{
_logger = logger;
_options = options.Value;
_behaviorExecutor = behaviorExecutor;
_serviceContext = serviceContext;
using (database)
{
_behaviorExecutor.Initialize(_serviceContext.ScriptId, database);
}
}
public async Task <Dialog> CreateOrUpdateDialogAsync(IPlatformDatabase dbContext, User client, string payload, MessageDirection direction, int botId = default)
{
var message = new Message
{
Payload = payload,
Direction = direction
};
if (!_dialogs.TryGetValue(client.Id, out var dialog))
{
if (botId < 1)
{
throw new ArgumentOutOfRangeException(nameof(botId), "Dialog cannot be created without botId.");
}
dialog = new Dialog
{
Client = client,
State = DialogState.Active,
BotId = botId,
Messages = new List <Message>
{
message
}
};
_dialogs.TryAdd(client.Id, dialog);
//todo: нужна логика поиска диалога, пока что в случае если текущий диалог не будет найден в репо, то будет создан новый
await dbContext.Dialogs.AddAsync(dialog);
}
else
{
dialog.Messages.Add(message);
dbContext.Dialogs.Update(dialog);
}
dialog.CurrentMessage = message;
await dbContext.SaveChangesAsync();
return(dialog);
}
private PlatformDatabase UpdateDatabases(IManagedPlatform platform, string catalog, string server, ICollection <IEntity> entities)
{
using (Profiler.Measure("PlatformService.UpdateDatabases"))
{
if (string.IsNullOrEmpty(catalog))
{
throw new ArgumentNullException("catalog");
}
if (string.IsNullOrEmpty(server))
{
throw new ArgumentNullException("server");
}
IPlatformDatabase db = null;
if (platform != null)
{
db = platform.DatabaseHistory.FirstOrDefault(d =>
string.Equals(d.Catalog, catalog, StringComparison.InvariantCultureIgnoreCase) &&
string.Equals(d.Server, server, StringComparison.InvariantCultureIgnoreCase));
}
if (db != null)
{
db = db.AsWritable <PlatformDatabase>();
}
else
{
db = CastEntityHelper.CreatePlatformDatabase();
db.Catalog = catalog;
db.Server = server;
}
db.Name = string.Format("{0} ({1})", server, catalog);
db.LastContact = DateTime.UtcNow;
entities.Add(db);
return((PlatformDatabase)db);
}
}
public async Task <InterpretationResult> InterpretAsync(IPlatformDatabase database, Dialog dialog)
{
var parameters = _parameters.Split(' ').Select(x => x.Trim());
var result = new InterpretationResult
{
Result = false,
ResultType = ExpressionResultType.Boolean
};
foreach (var p in parameters)
{
if (dialog.CurrentMessage.Payload.Contains(p, System.StringComparison.OrdinalIgnoreCase))
{
result.Result = true;
}
}
return(result);
}
public async Task StopBotsAsync(IPlatformDatabase database)
{
var lastExecution = DateTime.Now.AddMilliseconds(-1 * _options.ServiceIntervalMs);
var stoppedBots = await database.Bots
.AsNoTracking()
.Where(x => x.BotState == BotState.Stopped && x.ModifiedOn > lastExecution)
.ToListAsync();
var transportsData = _runningBots.Where(x => stoppedBots.Contains(x.Bot));
if (transportsData.Any())
{
foreach (var transportData in transportsData)
{
transportData.Bot.BotState = BotState.Stopped;
await transportData.Transport.StopAsync();
_runningBots.Remove(transportData);
}
}
}
public async Task StartBotsAsync(IPlatformDatabase database)
{
var bots = await database.Bots
.Where(x => (x.BotState == BotState.Pending || x.BotState == BotState.Started) &&
!_runningBots.Select(e => e.Bot.Id).Contains(x.Id))
.Include(x => x.Transport)
.Include(x => x.Owner)
.Include(x => x.Script)
.ToListAsync();
if (bots.Any())
{
foreach (var bot in bots)
{
try
{
EnsureValidity(bot);
var transportData = CreateTransport(bot);
_runningBots.Add(transportData);
await transportData.Transport.StartAsync(transportData.CancellationToken);
bot.BotState = BotState.Started;
}
catch (Exception ex)
{
bot.BotState = BotState.Invalid;
_logger.LogError(ex, $"Error during bot creation. BotId: {bot.Id}.");
}
database.Bots.Update(bot);
}
await database.SaveChangesAsync();
}
}
public Task FinishDialogAsync(IPlatformDatabase dbContext, Dialog dialog)
{
dialog.State = DialogState.Finished;
dbContext.Dialogs.Update(dialog);
return(dbContext.SaveChangesAsync());
}
public DialogService(
IPlatformDatabase database,
ILogger <DialogService> logger)
{
}
public Task <InterpretationResult> InterpretAsync(IPlatformDatabase database, Dialog dialog)
{
throw new NotImplementedException();
}
public UserService(IPlatformDatabase database, ILogger <UserService> logger)
{
_database = database;
_logger = logger;
}
public Task <string> InsertEntityParameters(string message, Dialog dialog, IPlatformDatabase database)
{
return(TextTemplateHandler.InsertEntityParameters(message, dialog, database));
}
public async Task <InterpretationResult> Interpret(IInstruction instruction, Dialog dialog, IPlatformDatabase database, string transport)
{
try
{
var enrichedInstruction = await InsertEntityParameters(instruction.Instruction, dialog, database);
var expression = _expressionFactory.CreateExpression(enrichedInstruction, transport);
return(await expression.InterpretAsync(database, dialog));
}
catch (Exception ex)
{
_logger.LogError(ex, $"Interpretation failed. Instruction: {instruction.Instruction}.");
return(new InterpretationResult
{
Result = ex,
State = InterpretationResultState.Failed
});
}
}
private async Task <User> FindOrCreateUserAsync(string connectionId, string username, IPlatformDatabase database, Services.ServiceContext serviceContext)
{
var client =
(await database.UserTransports
.Include(x => x.User)
.FirstOrDefaultAsync(x => x.Id == serviceContext.TransportId && x.TransportUserId.Equals(connectionId)))?.User;
if (client is null)
{
client = new User
{
Username = username
};
database.UserTransports.Add(
new UserTransport
{
Transport = await database.Transports.FirstAsync(x => x.Id == serviceContext.TransportId),
User = client,
TransportUserId = connectionId
});
_logger.LogInformation($"New user just created. Username: {username}. Transport: {serviceContext.TransportName}. BotId: {serviceContext.BotId}.");
}
client.LastActivity = DateTime.Now;
await database.SaveChangesAsync();
_connectionsRepository.AddConnection(client.Id, serviceContext.TransportName, connectionId);
return(client);
}
public static async Task <string> InsertEntityParameters(string textTemplate, Dialog dialog, IPlatformDatabase database)
{
//todo: нужно считать хеш шаблона, хранить его возможно прямо в объекте шага поведения, после кешировать хеш и параметры шаблона
var parameters = TemplateRegex.Matches(textTemplate)
.OfType <Match>()
.Select(x => x.Groups[0].Value)
.ToDictionary(parameter => parameter.Trim('{').Trim('}'), parameter => parameter);
if (!parameters.Any())
{
return(textTemplate);
}
StringBuilder resultString = new StringBuilder(textTemplate);
foreach (var p in parameters.Keys)
{
var entityParameter = p.Split(':');
if (!EntityNameIsValid(entityParameter[0]))
{
throw new KeyNotFoundException($"Text template processing error. Entity name not found. {p[0]}");
}
if (entityParameter[0].Equals("user", StringComparison.OrdinalIgnoreCase))
{
var value = dialog.Client.GetType()
.GetProperties()
.FirstOrDefault(x => x.Name.Equals(entityParameter[1], StringComparison.OrdinalIgnoreCase))
?.GetValue(dialog.Client)
?.ToString() ?? "null";
resultString.Replace(parameters[p], value);
}
else
{
}
}
return(resultString.ToString());
}
public ConnectionsRepository(IPlatformDatabase database)
{
_database = database;
}
