public GrpcTestFixture(Action <IServiceCollection>?initialConfigureServices)
{
LoggerFactory = new LoggerFactory();
LoggerFactory.AddProvider(new ForwardingLoggerProvider((logLevel, category, eventId, message, exception) =>
{
LoggedMessage?.Invoke(logLevel, category, eventId, message, exception);
}));
var builder = new HostBuilder()
.ConfigureServices(services =>
{
services.AddSingleton <ILoggerFactory>(LoggerFactory);
})
.ConfigureWebHostDefaults(webHost =>
{
webHost
.UseTestServer()
.UseStartup <TStartup>();
if (initialConfigureServices != null)
{
webHost.ConfigureServices(initialConfigureServices);
}
});
_host = builder.Start();
_server = _host.GetTestServer();
Handler = _server.CreateHandler();
}
/// <summary>
/// Runs Every Time a Message is Logged
/// </summary>
public virtual void OnMessageLogged(string message)
{
LoggedMessage?.Invoke(this, new LogEventArgs()
{
Log = message
});
}
/// <summary>
/// Получить объект асинхронно, при возникновении исключения, сохранить ошибку.
/// и параметры, вызвавшие исключение.
/// </summary>
/// <typeparam name="TLoggedClass">Логируемый класс</typeparam>
/// <typeparam name="TSource">Источник</typeparam>
/// <typeparam name="TKey">Класс ключ</typeparam>
/// <typeparam name="TElement">Класс элемента</typeparam>
/// <param name="query">Запрос</param>
/// <param name="keySelector">Функция выбора ключа</param>
/// <param name="elementSelector">Функция выбора значения словаря</param>
/// <param name="loggedMessage">Описание места и состоянии объекта вызвавшего исключение</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Список объектов</returns>
internal static async Task <Dictionary <TKey, TElement> > ToDictionaryAndLogErrorAsync <TSource, TLoggedClass, TKey, TElement>
(this IQueryable <TSource> query, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector,
LoggedMessage <TLoggedClass> loggedMessage, CancellationToken cancellationToken) where TLoggedClass : class
{
return(await ContextLogErrorAsync(async() => await query.
ToDictionaryAsync(keySelector, elementSelector, cancellationToken), loggedMessage));
}
public GrpcTestFixture(Action <IServiceCollection>?initialConfigureServices)
{
LoggerFactory = new LoggerFactory();
LoggerFactory.AddProvider(new ForwardingLoggerProvider((logLevel, category, eventId, message, exception) =>
{
LoggedMessage?.Invoke(logLevel, category, eventId, message, exception);
}));
var builder = new HostBuilder().ConfigureServices(services =>
{
initialConfigureServices?.Invoke(services);
services.AddSingleton <ILoggerFactory>(LoggerFactory);
}).ConfigureWebHostDefaults(webHost =>
{
webHost.UseTestServer()
.UseStartup <TStartup>();
});
_host = builder.Start();
_server = _host.GetTestServer();
// Need to set the response version to 2.0.
// dotnet core 3.1 fix bug, IHost.GetTestClient() 即可
//var responseVersionHandler = new ResponseVersionHandler();
//responseVersionHandler.InnerHandler = _server.CreateHandler();
//var client = new HttpClient(responseVersionHandler);
//client.BaseAddress = new Uri("http://localhost");
//Client = client;
Client = _host.GetTestClient();//new HttpClient { BaseAddress=new Uri("http://localhost") };
}
public GrpcTestFixture(Action <IServiceCollection>?initialConfigureServices)
{
LoggerFactory = new LoggerFactory();
LoggerFactory.AddProvider(new ForwardingLoggerProvider((logLevel, category, eventId, message, exception) =>
{
LoggedMessage?.Invoke(logLevel, category, eventId, message, exception);
}));
var builder = new HostBuilder()
.ConfigureServices(services =>
{
initialConfigureServices?.Invoke(services);
services.AddSingleton <ILoggerFactory>(LoggerFactory);
})
.ConfigureWebHostDefaults(webHost =>
{
webHost
.UseTestServer()
.UseStartup <TStartup>();
});
_host = builder.Start();
_server = _host.GetTestServer();
// Need to set the response version to 2.0.
// Required because of this TestServer issue - https://github.com/aspnet/AspNetCore/issues/16940
var responseVersionHandler = new ResponseVersionHandler();
responseVersionHandler.InnerHandler = _server.CreateHandler();
Handler = responseVersionHandler;
}
public TestServerFixture(Action <IServiceCollection>?initialConfigureServices)
{
LoggerFactory = new LoggerFactory();
LoggerFactory.AddProvider(new ForwardingLoggerProvider((logLevel, category, eventId, message, exception) => {
LoggedMessage?.Invoke(logLevel, category, eventId, message, exception);
}));
var builder = new HostBuilder()
.ConfigureWebHostDefaults(webHost => {
webHost.UseTestServer()
.UseStartup <TStartup>();
})
.ConfigureServices(services => {
services.AddSingleton <ILoggerFactory>(LoggerFactory);
var descriptors = services.Where(d => d.ServiceType == typeof(DbContextOptions <TDataContext>));
if (descriptors.Count() > 0)
{
foreach (var descriptor in descriptors.ToArray())
{
services.Remove(descriptor);
}
}
services.AddDbContext <TDataContext>(options =>
options.UseInMemoryDatabase(new Guid().ToString()));
initialConfigureServices?.Invoke(services);
});
_host = builder.Start();
_server = _host.GetTestServer();
Handler = _server.CreateHandler();
}
public GrpcTestFixture()
{
LoggerFactory = new LoggerFactory();
LoggerFactory.AddProvider(new ForwardingLoggerProvider((logLevel, category, eventId, message, exception) =>
{
LoggedMessage?.Invoke(logLevel, category, eventId, message, exception);
}));
}
/// <summary>
/// Получить список объектов асинхронно, при возникновении исключения, сохранить ошибку.
/// и параметры, вызвавшие исключение.
/// </summary>
/// <typeparam name="TResult">Список объектов</typeparam>
/// <typeparam name="TLoggedClass">Логируемый класс</typeparam>
/// <param name="query">Запрос</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Список объектов</returns>
internal static async Task <List <TResult> > ToListAndLogErrorAsync <TResult, TLoggedClass>(this IQueryable <TResult> query,
CancellationToken cancellationToken) where TLoggedClass : class
{
ILogger <TLoggedClass> logger = MKKContext.LoggerFactory.CreateLogger <TLoggedClass>();
LoggedMessage <TLoggedClass> loggedMessage =
new LoggedMessage <TLoggedClass>(logger, "Ошибка получения списка из БД./ Объект {TResult}.*/", typeof(TResult));
return(await ContextLogErrorAsync(async() => await query.ToListAsync(cancellationToken), loggedMessage));
}
/// <summary>
/// Сохранить изменения в БД асинхронно, при возникновении исключения, сохранить ошибку.
/// и параметры, вызвавшие исключение.
/// </summary>
/// <typeparam name="TLoggedClass">Логируемый класс</typeparam>
/// <param name="context">Расширяемый класс (DBContext)</param>
/// <param name="logShortMessage">Сообщение для логгера</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns></returns>
internal static async Task <int> SaveChangesAndLogErrorAsync <TLoggedClass>(this IDBSource context,
LogShortMessage logShortMessage, CancellationToken cancellationToken) where TLoggedClass : class
{
ILogger <TLoggedClass> logger = MKKContext.LoggerFactory.CreateLogger <TLoggedClass>();
LoggedMessage <TLoggedClass> loggedMessage =
new LoggedMessage <TLoggedClass>(logger, logShortMessage.Message, logShortMessage.Params);
return(await context.SaveChangesAndLogErrorAsync(loggedMessage, cancellationToken));
}
/// <summary>
/// Сохранить изменения в БД асинхронно, при возникновении исключения, сохранить ошибку.
/// и параметры, вызвавшие исключение.
/// </summary>
/// <typeparam name="TLoggedClass">Логируемый класс</typeparam>
/// <param name="context">Расширяемый класс (DBContext)</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns></returns>
internal static async Task <int> SaveChangesAndLogErrorAsync <TLoggedClass>(this IDBSource context,
CancellationToken cancellationToken) where TLoggedClass : class
{
ILogger <TLoggedClass> logger = MKKContext.LoggerFactory.CreateLogger <TLoggedClass>();
LoggedMessage <TLoggedClass> loggedMessage =
new LoggedMessage <TLoggedClass>(logger, "Ошибка внесения изменений в БД.");
return(await context.SaveChangesAndLogErrorAsync <TLoggedClass>(loggedMessage, cancellationToken));
}
/// <summary>
/// Получить объект асинхронно, при возникновении исключения, сохранить ошибку.
/// и параметры, вызвавшие исключение.
/// </summary>
/// <typeparam name="TResult">Список объектов</typeparam>
/// <typeparam name="TLoggedClass">Логируемый класс</typeparam>
/// <param name="query">Запрос</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Объект</returns>
internal static async Task <TResult> SingleOrDefaultAndErrorAsync <TResult, TLoggedClass>(this IQueryable <TResult> query,
CancellationToken cancellationToken) where TLoggedClass : class
{
ILogger <TLoggedClass> logger = MKKContext.LoggerFactory.CreateLogger <TLoggedClass>();
LoggedMessage <TLoggedClass> loggedMessage =
new LoggedMessage <TLoggedClass>(logger, "Ошибка поиска объекта в БД./* Объект {TResult}*/", typeof(TResult));
return(await SingleOrDefaultAndErrorAsync(query, loggedMessage, cancellationToken));
}
/// <summary>
/// Получить объект асинхронно, при возникновении исключения, сохранить ошибку.
/// и параметры, вызвавшие исключение.
/// </summary>
/// <typeparam name="TResult">Список объектов</typeparam>
/// <typeparam name="TLoggedClass">Логируемый класс</typeparam>
/// <param name="query">Запрос</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Список объектов</returns>
internal static async Task <TResult> FirstOrDefaultAndLogErrorAsync <TResult, TLoggedClass>(this IQueryable <TResult> query,
CancellationToken cancellationToken) where TLoggedClass : class
{
ILogger <TLoggedClass> logger = MKKContext.LoggerFactory.CreateLogger <TLoggedClass>();
LoggedMessage <TLoggedClass> loggedMessage =
new LoggedMessage <TLoggedClass>(logger, "Ошибка поиска объекта в БД./*Тип объекта {TResult}*/", typeof(TResult));
return(await ContextLogErrorAsync(async() => await query.FirstOrDefaultAsync(cancellationToken), loggedMessage));
}
/// <summary>
/// Получить список объектов асинхронно, при возникновении исключения, сохранить ошибку.
/// и параметры, вызвавшие исключение.
/// </summary>
/// <typeparam name="TResult">Список объектов</typeparam>
/// <typeparam name="TLoggedClass">Логируемый класс</typeparam>
/// <param name="query">Запрос</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Список объектов</returns>
internal static async Task <TResult[]> ToArrayAndLogErrorAsync <TResult, TLoggedClass>(this IQueryable <TResult> query,
CancellationToken cancellationToken) where TLoggedClass : class
{
ILogger <TLoggedClass> logger = MKKContext.LoggerFactory.CreateLogger <TLoggedClass>();
LoggedMessage <TLoggedClass> loggedMessage =
new LoggedMessage <TLoggedClass>(logger, "Ошибка выгрузки в массив из БД./*Тип объекта {TResult}*/", typeof(TResult));
return(await ContextLogErrorAsync(async() => await query.ToArrayAsync(cancellationToken), loggedMessage));
}
/// <summary>
/// Найти запись в БД по имени асинхронно. Если записи нет, то создать новую с Name = параметру name, Code1C = code1C.
/// </summary>
/// <typeparam name="TEntity">Таблица</typeparam>
/// <typeparam name="TLoggedClass">Класс логируемого объекта</typeparam>
/// <param name="name">Имя записи</param>
/// <param name="code1C">Код 1С</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Запись с искомым ID</returns>
internal static async Task <TEntity> FindRequiredDBRecordByNameAndLogErrorAsync <TEntity, TLoggedClass>(string name,
string code1C, CancellationToken cancellationToken) where TEntity : class, IDBTableIDNameW1CCode, new() where TLoggedClass : class
{
ILogger <TLoggedClass> logger = LoggerFactory.CreateLogger <TLoggedClass>();
LoggedMessage <TLoggedClass> loggedMessage =
new LoggedMessage <TLoggedClass>(logger, "Ошибка поиска объекта в БД./* Объект {TEntity}, значение {name}, код 1С {code1C}.*/", typeof(TEntity), name, code1C);
return(await FindRequiredDBRecordByNameAndLogErrorAsync <TEntity, TLoggedClass>(name, code1C, loggedMessage, cancellationToken));
}
/// <summary>
/// Найти асинхронно договор по коду 1С.
/// </summary>
/// <typeparam name="TLoggedClass">Тип логируемого объекта</typeparam>
/// <param name="account1CCode">Номер договора 1С</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <param name="includes">Инклуды</param>
/// <returns></returns>
internal static async Task <Account1C> FindAccountAndLogErrorAsync <TLoggedClass>(string account1CCode,
CancellationToken cancellationToken, params Expression <Func <Account1C, object> >[] includes) where TLoggedClass : class
{
ILogger <TLoggedClass> logger = LoggerFactory.CreateLogger <TLoggedClass>();
LoggedMessage <TLoggedClass> loggedMessage =
new LoggedMessage <TLoggedClass>(logger, "Ошибка поиска договора в БД./* Код договора {account1CCode}.*/", account1CCode);
return(await FindAccountAndLogErrorAsync(account1CCode, loggedMessage, cancellationToken, includes));
}
protected override void WriteToOperationsLog(string message, int eventId, string category)
{
var messageToAdd = new LoggedMessage();
messageToAdd.Message = message;
messageToAdd.EventId = eventId;
messageToAdd.Category = category;
Messages.Add(messageToAdd);
}
protected override void WriteToDeveloperTrace(string message, int eventId, SandboxTraceSeverity severity, string category)
{
var messageToAdd = new LoggedMessage();
messageToAdd.Message = message;
messageToAdd.EventId = eventId;
messageToAdd.SandboxTraceSeverity = severity;
messageToAdd.Category = category;
Messages.Add(messageToAdd);
}
private void LogMessage(LogSeverity severity, string message, params object[] propertyValues)
{
LoggedMessage?.Invoke(new LogEntry
{
Message = message,
PropertyValues = propertyValues.ToArray(),
Severity = severity,
Timestamp = DateTime.Now
});
}
private void LogMessage(LogType Type, string message, params object[] propertyValues)
{
LoggedMessage?.Invoke(new LogEntry
{
Message = message,
PropertyValues = propertyValues.ToArray(),
Type = Type,
Timestamp = DateTime.Now
});
}
public override int GetHashCode()
{
unchecked
{
var hashCode = (int)Level;
hashCode = (hashCode * 397) ^ (LoggedMessage?.GetHashCode() ?? 0);
hashCode = (hashCode * 397) ^ (Exception?.GetHashCode() ?? 0);
return(hashCode);
}
}
/// <summary>
/// Найти асинхронно клиента по ID из 1С.
/// </summary>
/// <param name="code1C">Код клиента</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns>Запись в БД</returns>
internal static async Task <ClientDB> FindClientAndLogErrorAsync <TLoggedClass>(string code1C,
CancellationToken cancellationToken) where TLoggedClass : class
{
using (IDBSource source = new MKKContext()) {
ILogger <TLoggedClass> logger = LoggerFactory.CreateLogger <TLoggedClass>();
LoggedMessage <TLoggedClass> loggedMessage =
new LoggedMessage <TLoggedClass>(logger, "Ошибка поиска клиента в БД./* Код клиента {client1CCode}.*/", code1C);
return(await ClientDBQuery(source, code1C).SingleOrDefaultAndErrorAsync(loggedMessage, cancellationToken));
}
}
/// <summary>
/// Приатачить значение, при возникновении исключения, залогировать и пробросить дальше.
/// </summary>
/// <typeparam name="TEntity">Тип данных</typeparam>
/// <typeparam name="TLoggedClass">Класс логируемого объекта</typeparam>
/// <param name="dbContext">Контекст БД</param>
/// <param name="value">Поток с данными</param>
/// <param name="loggedMessage">Описание места и состоянии объекта вызвавшего исключение</param>
/// <returns>Приатаченное значение</returns>
internal static TEntity AttachAndLogError <TEntity, TLoggedClass>(IDBSource dbContext, TEntity value,
LoggedMessage <TLoggedClass> loggedMessage) where TEntity : class where TLoggedClass : class
{
try {
((MKKContext)dbContext).Set <TEntity>().Attach(value);
}
catch (Exception exception) {
loggedMessage.LogMessage("Ошибка работы с аттаче объекта. Исключение: {ContextException}", exception);
throw;
}
return(value);
}
/// <summary>
/// Найти объект по ID.
/// </summary>
/// <param name="id">ID объекта</param>
/// <param name="cancellationToken">Токен отмены</param>
/// <param name="includes">Инклуды</param>
/// <returns>Запись в БД</returns>
internal static async Task <TEntity> FindDBRecordByIDdAndLogErrorAsync <TEntity, TLoggedClass>(int id,
CancellationToken cancellationToken, params Expression <Func <TEntity, object> >[] includes)
where TEntity : class, IDBTableID where TLoggedClass : class
{
ILogger <TLoggedClass> logger = LoggerFactory.CreateLogger <TLoggedClass>();
LoggedMessage <TLoggedClass> loggedMessage =
new LoggedMessage <TLoggedClass>(
logger,
"Ошибка поиска объекта в БД./* Объект {TEntity}, id {id}.*/",
typeof(TEntity), id);
return(await FindDBRecordByIDdAndLogErrorAsync(id, loggedMessage, cancellationToken, includes));
}
void LoggedMessage_NewMessage(LoggedMessage obj)
{
if (this.dgvLogTable.InvokeRequired)
{
this.dgvLogTable.Invoke(new Action<LoggedMessage>(LoggedMessage_NewMessage), obj);
}
else
{
if (this.dgvLogTable.Rows.Count > 0)
{
this.dgvLogTable.Rows.Add(obj.GetValues());
}
}
}
/// <summary>
/// Получить описание файла по ID асинхронно.
/// </summary>
/// <param name="idFileDescription"></param>
/// <param name="cancellationToken">Токен отмены</param>
/// <returns></returns>
internal static async Task <FileDescriptionDB> FindFileDescriptionDBAndLogErrorAsync <TLoggedClass>(int idFileDescription,
CancellationToken cancellationToken) where TLoggedClass : class
{
ILogger <TLoggedClass> logger = LoggerFactory.CreateLogger <TLoggedClass>();
LoggedMessage <TLoggedClass> loggedMessage =
new LoggedMessage <TLoggedClass>(logger, "Ошибка поиска описания файла в БД./* Код описания {idFileDescription}.*/", idFileDescription);
using (IDBSource source = new MKKContext()) {
return(await source.FileDescriptionDBs.
AsNoTracking().
Where(i => i.ID.Equals(idFileDescription)).
SingleOrDefaultAndErrorAsync(loggedMessage, cancellationToken));
}
}
void LoggedMessage_NewMessage(LoggedMessage obj)
{
if (this.dgvLogTable.InvokeRequired)
{
this.dgvLogTable.Invoke(new Action <LoggedMessage>(LoggedMessage_NewMessage), obj);
}
else
{
if (this.dgvLogTable.Rows.Count > 0)
{
this.dgvLogTable.Rows.Add(obj.GetValues());
}
}
}
public GrpcTestFixture(Action <IServiceCollection>?initialConfigureServices)
{
LoggerFactory = new LoggerFactory();
LoggerFactory.AddProvider(new ForwardingLoggerProvider((logLevel, category, eventId, message, exception) =>
{
LoggedMessage?.Invoke(logLevel, category, eventId, message, exception);
}));
var builder = new HostBuilder()
.ConfigureServices(services =>
{
initialConfigureServices?.Invoke(services);
services.AddSingleton <ILoggerFactory>(LoggerFactory);
var descriptor = services.SingleOrDefault(
d => d.ServiceType ==
typeof(DbContextOptions <DemoDbContext>));
services.Remove(descriptor);
services.AddDbContext <DemoDbContext>(options =>
{
options.UseInMemoryDatabase("InMemoryDbForTesting");
});
var sp = services.BuildServiceProvider();
using (var scope = sp.CreateScope())
{
var scopedServices = scope.ServiceProvider;
var db = scopedServices.GetRequiredService <DemoDbContext>();
db.Database.EnsureCreated();
}
services.AddDbContext <DemoDbContext>();
})
.ConfigureWebHostDefaults(webHost =>
{
webHost
.UseTestServer()
.UseStartup <TStartup>();
});
Host = builder.Start();
_server = Host.GetTestServer();
Handler = _server.CreateHandler();
}
/// <summary>
/// Проверить наличие роли у пользователя.
/// </summary>
/// <param name="adLogin">Логин пользователя</param>
/// <param name="role">Роль, наличие которой необходимо проверить</param>
/// <returns></returns>
private static bool RoleContains(string adLogin, string role)
{
string[] roles;
try { roles = Singleton <ProxyADRoles> .Values[adLogin]; }
catch (Exception exception) {
LoggedMessage <EFServicePosts> logMessage = new LoggedMessage <EFServicePosts>(
_Logger,
"Не удалось получить список ролей./* Метод {methodName} adLogin: {adLogin}.*/",
"RoleContains", adLogin);
logMessage.LogMessage($"{Environment.NewLine}" + "Описание ошибки: {exception}", exception);
throw;
}
return(roles.Contains(role));
}
private void LogMessage(Dictionary <Type, List <LoggedMessage> > logs, MessageActorWidget associatedActor, Type messageType, string messageName)
{
if (!logs.ContainsKey(messageType))
{
logs.Add(messageType, new List <LoggedMessage>());
}
LoggedMessage loggedMessage = logs[messageType].Find(x => x.MessageName == messageName);
if (loggedMessage == null)
{
loggedMessage = new LoggedMessage(messageName);
logs[messageType].Add(loggedMessage);
}
if (!loggedMessage.AssociatedActors.Contains(associatedActor))
{
loggedMessage.AssociatedActors.Add(associatedActor);
}
}
public async Task MessageReceived(SocketMessage message)
{
var loggedMessage = new LoggedMessage()
{
MessageId = message.Id,
AuthorId = message.Author.Id,
ChannelId = message.Channel.Id,
Message = message.Content,
Timestamp = message.Timestamp.DateTime
};
LogAttachments(message, loggedMessage);
if (message.Channel is SocketGuildChannel)
{
loggedMessage.ServerId = (message.Channel as SocketGuildChannel).Guild.Id;
}
DbService.LoggedMessages.Add(loggedMessage);
await DbService.SaveChangesAsync();
}
private void LogAttachments(SocketMessage message, LoggedMessage loggedMessage)
{
if (message.Attachments.Any())
{
foreach (var attachment in message.Attachments)
{
if (DbService.LoggedMessageAttachments.Any(att => att.Id == attachment.Id))
{
continue;
}
var loggedAttachment = new LoggedMessageAttachment()
{
Id = attachment.Id,
MessageId = loggedMessage.MessageId,
Message = loggedMessage,
Url = attachment.Url
};
DbService.LoggedMessageAttachments.Add(loggedAttachment);
}
}
}
