private async Task WritingAction(CancellationToken forceStopToken)
{
using (ConnectionWrapper connectionWrapper = await manager.GetConnectionAsync(forceStopToken))
{
DbCommand command = writerCore.CreateMainCommand(connectionWrapper.Connection);
while (!forceStopToken.IsCancellationRequested && !DataQueue.IsEmpty)
{
using (DbTransaction transaction = await connectionWrapper.Connection.BeginTransactionAsync(forceStopToken))
{
try
{
for (int i = 0; i < settings.TrasactionSize && !forceStopToken.IsCancellationRequested && !DataQueue.IsEmpty; i++)
{
if (DataQueue.TryDequeue(out T message))
{
await writerCore.ExecuteWriting(command, message, forceStopToken);
}
}
await transaction.CommitAsync(forceStopToken);
}
catch (Exception ex)
{
logger.Error(ex, "Error while writing messages!");
await transaction.RollbackAsync();
}
}
await Task.Delay(100);
}
}
}
public async Task <List <Entity> > Read(CancellationToken cancellationToken)
{
List <Entity> result = new List <Entity>();
using (var cnn = await connectionsFactory.GetConnectionAsync(cancellationToken))
{
var command = cnn.Connection.CreateCommand();
command.CommandText = "select id, username, is_channel from chats;";
command.CommandType = System.Data.CommandType.Text;
using (var reader = await command.ExecuteReaderAsync(cancellationToken))
{
while (await reader.ReadAsync(cancellationToken))
{
if (!reader.IsDBNull(1) && !reader.IsDBNull(2))
{
bool is_channel = reader.GetBoolean(2);
result.Add(new Entity()
{
Id = reader.GetInt64(0), Link = reader.GetString(1),
Type = is_channel ? EntityType.Channel:EntityType.Group
});
}
}
}
}
return(result);
}
public async Task <ChatInfo> ReadAsync(object parameters, CancellationToken token)
{
using (ConnectionWrapper connectionWrapper = await connectionsFactory.GetConnectionAsync(token))
{
if (parameters is ChatInfoRequest request)
{
DbCommand additionalCommand = connectionWrapper.Connection.CreateCommand();
additionalCommand.CommandType = System.Data.CommandType.Text;
additionalCommand.CommandText = "select last_message_id from chats where id=@_chat_id";
additionalCommand.Parameters.Add(new NpgsqlParameter("_chat_id", NpgsqlTypes.NpgsqlDbType.Bigint));
additionalCommand.Parameters["_chat_id"].Value = request.Id;
DbDataReader reader = await additionalCommand.ExecuteReaderAsync(token);
while (await reader.ReadAsync(token))
{
long offset = 1;
if (!await reader.IsDBNullAsync(0))
{
offset = reader.GetInt64(0);
}
return(new ChatInfo()
{
Id = request.Id, Offset = offset
});
}
}
throw new Exception("Reading failed");
}
}
private async Task action(CancellationToken token)
{
while (!token.IsCancellationRequested)
{
while (!token.IsCancellationRequested)
{
using (ConnectionWrapper connection = await connectionPoolManager.GetConnectionAsync(token))
{
try
{
NpgsqlCommand mainCommand = connection.Connection.CreateCommand();
mainCommand.CommandType = System.Data.CommandType.StoredProcedure;
mainCommand.CommandText = "ban";
bool continuation = true;
while (continuation)
{
using NpgsqlDataReader reader = await mainCommand.ExecuteReaderAsync(token);
while (await reader.ReadAsync(token))
{
continuation = reader.GetBoolean(0);
}
}
}
catch (Exception)
{
}
await Task.Delay((int)settings.StartWritingInterval, token);
}
}
}
}
private async Task action(CancellationToken token)
{
while (!token.IsCancellationRequested)
{
int count = settings.StartVectorizerCount;
while (!token.IsCancellationRequested)
{
using (ConnectionWrapper connection = await connectionPoolManager.GetConnectionAsync(token))
{
try
{
NpgsqlCommand mainCommand = connection.Connection.CreateCommand();
mainCommand.CommandType = System.Data.CommandType.StoredProcedure;
mainCommand.CommandText = "create_fulltext_data";
mainCommand.Parameters.Add(new NpgsqlParameter("count", NpgsqlTypes.NpgsqlDbType.Integer));
mainCommand.Parameters["count"].Value = count;
bool continuation = true;
while (continuation)
{
using NpgsqlDataReader reader = await mainCommand.ExecuteReaderAsync(token);
while (await reader.ReadAsync(token))
{
continuation = reader.GetBoolean(0);
}
}
//await act(mainCommand, token);
}
catch (Exception)
{
count /= 10;
if (count > 1)
{
break;
}
else
{
NpgsqlCommand additionalCommand = connection.Connection.CreateCommand();
additionalCommand.CommandType = System.Data.CommandType.StoredProcedure;
additionalCommand.CommandText = "force_parse";
await additionalCommand.ExecuteNonQueryAsync(token);
count = settings.StartVectorizerCount;
break;
}
}
await Task.Delay((int)settings.StartWritingInterval, token);
}
}
}
}
private async Task <ConcurrentQueue <Order> > CreateSingleHistoryOrders(CancellationToken token)
{
try
{
ConcurrentQueue <Order> SingleUpdatesQueue = new ConcurrentQueue <Order>();
using (ConnectionWrapper connection = await connectionsFactory.GetConnectionAsync(token))
{
using NpgsqlCommand command = connection.Connection.CreateCommand();
command.CommandType = System.Data.CommandType.Text;
command.CommandText = "select id,username,last_message_id,finders from chats where " +
"(has_actual_order is null or not has_actual_order) and not banned and (finders is not null and array_length(finders,1)>0);";
using NpgsqlDataReader reader = await command.ExecuteReaderAsync(token);
while (!token.IsCancellationRequested && await reader.ReadAsync(token))
{
long ChatId = reader.GetInt64(0);
string Username = reader.IsDBNull(1) ? string.Empty : reader.GetString(1);
long Offset = reader.IsDBNull(2) ? 1 : reader.GetInt64(2);
string[] Finders = reader.IsDBNull(3) ? new string[0] : (string[])reader.GetValue(3);
if (string.IsNullOrEmpty(Username))
{
continue;
}
Order order = new Order()
{
Id = ChatId,
Link = Username,
Offset = Offset,
Type = OrderType.History,
};
foreach (string finder in Finders)
{
order.Finders.Add(finder);
}
state.AddOrder(order);
//state.Orders.Enqueue(order);
}
}
return(SingleUpdatesQueue);
}
catch (Exception ex)
{
logger.Error(ex, "Error while UpdateOrdersCreation");
throw ex;
}
}
private async Task action(object cancellationToken)
{
if (!(cancellationToken is CancellationToken))
{
return;
}
CancellationToken ct = (CancellationToken)cancellationToken;
using (ConnectionWrapper connectionWrapper = await connectionPoolManager.GetConnectionAsync(ct))
{
connection = connectionWrapper.Connection;
WriteCommand = connection.CreateCommand();
WriteCommand.CommandType = System.Data.CommandType.Text;
WriteCommand.CommandText = "update messages SET formatting_costyl = null, media_costyl = null, formatting = @_formatting, media = @_media where message_db_id = @_id";
WriteCommand.Parameters.Add(new NpgsqlParameter("_formatting", NpgsqlTypes.NpgsqlDbType.Jsonb));
WriteCommand.Parameters.Add(new NpgsqlParameter("_media", NpgsqlTypes.NpgsqlDbType.Jsonb));
WriteCommand.Parameters.Add(new NpgsqlParameter("_id", NpgsqlTypes.NpgsqlDbType.Bigint));
ReadCommand = connection.CreateCommand();
ReadCommand.CommandType = System.Data.CommandType.Text;
ReadCommand.CommandText = "select message_db_id,media_costyl,formatting_costyl from messages where (media_costyl is not null and media_costyl!='') or formatting_costyl is not null limit 10000";
while (!ct.IsCancellationRequested)
{
try
{
List <Record> records = new List <Record>();
using (NpgsqlDataReader reader = ReadCommand.ExecuteReader())
{
while (reader.Read())
{
Record record = new Record()
{
Id = reader.GetInt64(0),
media_costyl = !reader.IsDBNull(1) ? reader.GetString(1) : null,
formatting_costyl = !reader.IsDBNull(2) ? reader.GetString(2) : null,
};
records.Add(record);
}
}
if (records.Count == 0)
{
return;
}
List <object> list = new List <object>();
using NpgsqlTransaction transaction = connection.BeginTransaction();
try
{
foreach (Record record in records)
{
object form = dataPreparator.PreparateFormatting(record.formatting_costyl);
object med = dataPreparator.PreparateMedia(record.media_costyl);
list.Add(form);
list.Add(med);
WriteCommand.Transaction = transaction;
WriteCommand.Parameters["_formatting"].Value = form;
WriteCommand.Parameters["_media"].Value = med;
WriteCommand.Parameters["_id"].Value = record.Id;
WriteCommand.ExecuteNonQuery();
}
transaction.Commit();
}
catch (Exception)
{
transaction.Rollback();
}
}
catch (Exception)
{
}
}
}
}
public async Task <UserInfo> Check(long userId)
{
UserInfo ft = new UserInfo()
{
Status = UserStatus.Normal
};
using (var cnwr = await connectionsFactory.GetConnectionAsync(CancellationToken.None))
{
var comm = cnwr.Connection.CreateCommand();
comm.CommandText = "check_user";
comm.CommandType = System.Data.CommandType.StoredProcedure;
comm.Parameters.Add(new Npgsql.NpgsqlParameter("_user_id", NpgsqlTypes.NpgsqlDbType.Bigint));
comm.Parameters["_user_id"].Value = userId;
ObjectId currentId = ObjectId.GenerateNewId();
ObjectId? nextId = ObjectId.GenerateNewId();
ObjectId? prevId = null;
List <Page> pages = new List <Page>()
{
new Page(currentId, prevId, nextId)
{
position = Page.Position.First, brouseDonate = false
}
};
int count = 0;
int countBad = 0;
float summ = 0;
using (var reader = await comm.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
float rank = reader.GetFloat(0);
string text = !reader.IsDBNull(1)?reader.GetString(1):string.Empty;
string link = !reader.IsDBNull(2)?reader.GetString(2):string.Empty;
string name = !reader.IsDBNull(3)?reader.GetString(3):string.Empty;
if (!string.IsNullOrEmpty(text))
{
count++;
if (rank != 100)
{
countBad++;
summ += rank;
if (!pages.Last().TryAddResult(name, text, link))
{
prevId = currentId;
currentId = nextId.Value;
nextId = ObjectId.GenerateNewId();
pages.Add(new Page(currentId, prevId, nextId)
{
position = Page.Position.Middle, brouseDonate = false
});
}
}
}
}
}
pages.Last().position = Page.Position.Last;
await dataStorage.SavePages(pages, CancellationToken.None, TextMessage.defaultClient.BotId.Value);
ft.FirstPageId = pages.Count > 0 && !string.IsNullOrEmpty(pages.First().Text) ? pages.First().Id : ObjectId.Empty;
if (summ != 0)
{
ft.TotalMessages = count;
ft.BadMessages = countBad;
ft.Score = ((count - countBad) * 100 + summ) / count;
ft.Status = UserStatus.Middle;
if (ft.Score < 60)
{
ft.Status = UserStatus.SimpleBad;
}
}
}
return(ft);
}
