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 async Task <ScriptHeaderDto> Create(ScriptDto script, int userId, CancellationToken cancellationToken)
{
try
{
var owner = await _database.Users.FirstOrDefaultAsync(x => x.Id == userId, cancellationToken);
Script dbScript = new Script
{
Name = script.Name,
Instruction = script.Instruction,
Owner = owner
};
var result = await _database.Scripts.AddAsync(dbScript, cancellationToken);
await _database.SaveChangesAsync(cancellationToken);
return(result.Adapt <ScriptHeaderDto>());
}
catch (Exception ex)
{
_logger.LogError(ex, "Error during script creation.");
throw;
}
}
public async Task <bool> Activate(int botId, int userId, CancellationToken cancellationToken)
{
try
{
var bot = await FindBot(botId, userId, cancellationToken);
switch (bot.BotState)
{
case BotState.Created:
break;
case BotState.Invalid:
break;
case BotState.Pending:
break;
case BotState.Started:
break;
case BotState.Stopped:
break;
case BotState.Deactivated:
break;
default:
break;
}
bot.BotState = BotState.Pending;
_database.Bots.Update(bot);
await _database.SaveChangesAsync();
return(true);
}
catch (OperationCanceledException)
{
return(false);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error during bot activating.");
throw;
}
}
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);
}
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);
}
public async Task <UserDto> CreateUser(AuthDto auth, CancellationToken cancellationToken)
{
try
{
var exists = await _database.Users
.AsNoTracking()
.FirstOrDefaultAsync(x => string.Equals(x.Username, auth.Username, StringComparison.OrdinalIgnoreCase));
if (exists != null)
{
return(null);
}
byte[] salt = new byte[16]; //128 bit
using var random = RandomNumberGenerator.Create();
random.GetBytes(salt);
var newUser = new User
{
Username = auth.Username,
Password = HashPassword(auth.Password, salt),
Salt = Convert.ToBase64String(salt)
};
await _database.Users.AddAsync(newUser);
await _database.SaveChangesAsync();
return(new UserDto
{
Id = newUser.Id,
Username = newUser.Username
});
}
catch (Exception ex)
{
_logger.LogError(ex, "Error during user creation.");
throw;
}
}
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());
}