public void Start(ConnectionOptions options)
{
//configure options
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionValidator(context =>
{
_logger?.Log(nameof(Broker), $"{context.ClientId} connection validator for c.Endpoint: {context.Endpoint}");
context.ReasonCode = MqttConnectReasonCode.Success;
})
.WithApplicationMessageInterceptor(context =>
{
_logger?.Log(nameof(Broker), $"Intercept data");
//var newData = Encoding.UTF8.GetBytes(DateTime.Now.ToString("O"));
//var oldData = context.ApplicationMessage.Payload;
//var mergedData = newData.Concat(oldData).ToArray();
//context.ApplicationMessage.Payload = mergedData;
})
.WithConnectionBacklog(100)
.WithDefaultEndpointBoundIPAddress(IPAddress.Parse(options.IpAddress))
.WithDefaultEndpointPort(options.Port)
;
//start server
_mqttServer = new MqttFactory().CreateMqttServer();
_mqttServer.StartAsync(optionsBuilder.Build()).Wait();
}
public async Task <ActionResult <OrdemCompra> > ConsultarPorId([FromRoute] string idOrdemCompra)
{
try
{
var ordemCompra = await _ordemCompraRepositorio.ConsultarPorId(idOrdemCompra);
if (ordemCompra == null)
{
return(NotFound());
}
return(Ok(ordemCompra));
}
catch (Exception ex)
{
_logger.Log($"Erro ao obter ordem de compra. {ex}", EventLevel.Error);
throw; //deixar subir o erro para retornar 500
}
}
public Comando1(IScopedService scopeSrv,
ITransientService transientSrv,
ICustomLogger logger)
{
_logger = logger;
_logger.Log("Instancia Comando1");
_scopeSrv = scopeSrv;
_transientSrv = transientSrv;
}
public ActionResult GetLogger()
{
var result =
new
{
Logger = logger.Log("Hello")
};
return(Ok(result));
}
/// <summary>
/// Complete logging a request
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
public static void CompleteRequest <T>(T obj, StringBuilder sb, ICustomLogger logger)
{
sb.AppendLine();
//get return type data to put in the log
sb.AppendLine($"Returned value of type {typeof(T).FullName}: {CustomLogger.GetArgsData(new object[] { obj })}");
//perform normal logging here
logger.Log(sb.ToString());
}
public async Task <ActionResult <IEnumerable <Produto> > > Get()
{
try
{
var produtos = await _produtoRepositorio.Consultar();
if (produtos == null)
{
produtos = new List <Produto>();
}
return(Ok(produtos));
}
catch (Exception ex)
{
_logger.Log($"Erro ao listar produtos. {ex}", EventLevel.Error);
throw; //deixar subir o erro para retornar 500
}
}
public async Task <ActionResult <IEnumerable <Cliente> > > Get()
{
try
{
var clientes = await _clienteRepositorio.ConsultarTodosCliente();
if (clientes == null)
{
clientes = new List <Cliente>();
}
return(Ok(clientes));
}
catch (Exception ex)
{
_logger.Log($"Erro ao listar clientes. {ex}", EventLevel.Error);
throw; //deixar subir o erro para retornar 500
}
}
public void TestLoggerOnlyLogsAboveMinimumLevel()
{
var successString = "This will be logged";
loggerSubject = new ConsoleLogger(LogLevel.Trace, consoleWriterMock.Object);
loggerSubject.Log(LogLevel.Information, successString);
loggerSubject = new ConsoleLogger(LogLevel.Error, consoleWriterMock.Object);
loggerSubject.Log(LogLevel.Information, "This Won't Be Logged");
consoleWriterMock.Verify(c => c.WriteLine(It.Is <string>(p => p.Equals($"INFORMATION | {successString}"))));
consoleWriterMock.Verify(c => c.WriteLine(It.IsAny <string>()), Times.Once);
}
public async Task Extract(WorkMode workMode, string basicUrl)
{
await InitSender(workMode);
var numberOfPage = await GetNumberOfPages(basicUrl);
_logger.Log($"Number of pages: {numberOfPage}");
var articlesUrl = new List <string>();
for (int i = 1; i <= numberOfPage; i++)
{
articlesUrl.AddRange(await GetArticlesUrlFromPage(basicUrl + "?page=" + i));
}
_logger.Log($"Number of articles: {articlesUrl.Count}");
foreach (var url in articlesUrl)
{
await _sender.Send(await GetArticleContent(url));
}
await Task.CompletedTask;
}
public async Task <bool> AlterarStatudOrdemDeCompraParaEmAnalise(string ordemDeCompraId)
{
try
{
return(await _ordemCompraRepositorio.AlterarStatusOrdemCompra(ordemDeCompraId, OrdemCompraStatus.EmAnalise).ConfigureAwait(false));
}
catch (Exception ex)
{
_logger.Log($"Erro ao atualizar status da Ordem de Compra {ordemDeCompraId} para {OrdemCompraStatus.EmAnalise}. {ex}", EventLevel.Error);
throw;
}
}
public DIController(ISingletonService singletonSrv,
IScopedService scopeSrv,
ITransientService transientSrv,
IComando comando,
ICustomLogger logger)
{
_singletonSrv = singletonSrv;
_scopeSrv = scopeSrv;
_transientSrv = transientSrv;
_comando = comando;
_logger = logger;
_logger.Log("****** Instancia DIController ******");
}
public AnswerStatus CreatePost(PostDto postDTO)
{
using (var uow = _unitOfWorkFactory.Create())
{
try
{
var postToCreate = _postBuilder.CreatePost(postDTO.PostTitle, postDTO.PostContent, postDTO.CreationDate);
var blogRepository = _repositoryFactory.CreateBlogRepository(uow);
var postBlog = blogRepository.GetEntityById(postDTO.RelatedTo.Id);
_postBuilder.SetBlogRelatedTo(postToCreate, postBlog);
var postRepository = _repositoryFactory.CreatePostRepository(uow);
postRepository.CreateEntity(postToCreate);
var categoryRepository = _repositoryFactory.CreateCategoryRepository(uow);
if (postDTO.PostCategories != null)
{
foreach (var categoryDTO in postDTO.PostCategories)
{
var categoryToAdd = categoryRepository.GetEntityById(categoryDTO.Id);
if (categoryToAdd != null)
{
postRepository.AddCategoryToPost(postToCreate, categoryToAdd);
}
}
}
uow.SaveChanges();
return(AnswerStatus.Successfull);
}
catch (Exception exc)
{
_logger.Log(exc.ToString());
return(AnswerStatus.Failed);
}
}
}
private async Task <List <CarModelDto> > GenerateModelList(AngleSharp.Dom.IHtmlCollection <AngleSharp.Dom.IElement> data, string carBrand)
{
_logger.Log($"Returned {data.Length} model entries for selected brand: {carBrand}");
var carModelList = new List <CarModelDto>();
foreach (var item in data)
{
carModelList.Add(new CarModelDto()
{
ModelName = item.TextContent.Replace(" ", string.Empty).ToString(),
ModelValue = item.GetAttribute("title").ToLower().Replace(" " + carBrand.ToLower().ToString() + " ", string.Empty).Replace(" ", "-").ToString()
});
}
return(await Task.FromResult(carModelList));
}
/// <summary>
/// Logs the object being sent in the request
/// </summary>
/// <typeparam name="TRequest"></typeparam>
/// <param name="func"></param>
/// <param name="sb"></param>
public static void PerformRequestLogging <TRequest>(Func <TRequest> func, StringBuilder sb, ICustomLogger logger) where TRequest : class
{
var target = func.Target;
if (target != null)
{
sb.AppendLine($"Requested value of type {typeof(TRequest).FullName}: ");
foreach (var field in target.GetType().GetFields())
{
sb.AppendLine($"Name: {field.Name}");
sb.AppendLine($"Value: {CustomLogger.GetArgsData(new object[] { field.GetValue(target) }, true)}");
}
logger.Log(sb.ToString());
}
}
public async Task <LeaseNoticeSchedule> ParseEntryText(RawEntryTextOutput item)
{
if (item.EntryText.Count() > 0)
{
StringBuilder registrationStringBuilder = new StringBuilder(), propDescriptionStringBuilder = new StringBuilder(),
dateOfLeaseStringBuilder = new StringBuilder(), lesseesStringBuilder = new StringBuilder(), noteStringBuilder = new StringBuilder();
var entryTextArray = item.EntryText.Where(p => !string.IsNullOrWhiteSpace(p))
.ToArray();
var lastRowState = RowState.Standard;
for (int i = 0; i < entryTextArray.Length; i++)
{
lastRowState = await rowDataParser.ParseRowData(i,
entryTextArray[i],
registrationStringBuilder,
propDescriptionStringBuilder,
dateOfLeaseStringBuilder,
lesseesStringBuilder,
noteStringBuilder,
lastRowState);
}
return(new LeaseNoticeSchedule()
{
Id = Guid.NewGuid(),
RegistrationDateAndPlan = registrationStringBuilder.ToString().Trim(),
PropertyDescription = propDescriptionStringBuilder.ToString().Trim(),
DateOfLeaseAndTerm = dateOfLeaseStringBuilder.ToString().Trim(),
LesseesTitle = lesseesStringBuilder.ToString().Trim(),
Notes = noteStringBuilder.ToString().Trim(),
});
}
else
{
//We would build on this and give a diagnostic Row ID + details success metrics for troubleshooting
logger.Log(LogLevel.Warning, "Invalid RawEntryTextOutput Item passed for parsing, Entry Text contained no rows");
}
return(new LeaseNoticeSchedule());
}
public async Task Extract(WorkMode workMode, string basicUrl)
{
if (!basicUrl.Contains("otomoto.pl/osobowe"))
{
_logger.Log($"Wrong url: {basicUrl}");
return;
}
await InitSender(workMode);
var numberOfPage = await GetNumberOfPages(basicUrl);
_logger.Log($"Number of pages: {numberOfPage}");
var articlesUrl = new List <string>();
for (int i = 1; i <= numberOfPage; i++)
{
articlesUrl.AddRange(await GetArticlesUrlFromPage(basicUrl + "?page=" + i));
}
_logger.Log($"Number of articles: {articlesUrl.Count}");
int beforeLoad = 0;
if (workMode == WorkMode.Continuous)
{
beforeLoad = await _loader.GetNumgerOfRecords();
}
foreach (var url in articlesUrl)
{
var articleContent = await GetArticleContent(url);
if (articleContent == null)
{
continue;
}
await _sender.Send(articleContent);
}
if (workMode == WorkMode.Continuous)
{
var addedRecords = await _loader.GetNumgerOfRecords() - beforeLoad;
_logger.Log($"Load {addedRecords} records to database");
}
await Task.CompletedTask;
}
public void TestLoggerLogsLevelAndMessageAsString()
{
loggerSubject = new ConsoleLogger(LogLevel.Information, consoleWriterMock.Object);
loggerSubject.Log(LogLevel.Information, "Test Log");
consoleWriterMock.Verify(c => c.WriteLine(It.Is <string>(p => p.Equals("INFORMATION | Test Log"))));
}
public Order LoadOrderInfo(string orderCode)
{
if (string.IsNullOrEmpty(orderCode))
{
Context.Response.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
return(null);
}
//simple sql injection defense
orderCode = orderCode.Replace("'", "''");
try
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
lock (lockObj)
{
if (HttpRuntime.Cache.Get(orderCode) != null)
{
stopWatch.Stop();
logger.Log("INFO", "Elapsed - {0}", stopWatch.Elapsed);
return(HttpRuntime.Cache.Get(orderCode) as Order);
}
}
string queryTemplate =
"SELECT OrderID, CustomerID, TotalMoney" +
" FROM dbo.Orders where OrderCode='{0}'";
string query = string.Format(queryTemplate, orderCode);
SqlConnection connection =
new SqlConnection(this.connectionString);
SqlCommand command =
new SqlCommand(query, connection);
connection.Open();
SqlDataReader reader = command.ExecuteReader();
if (reader.Read())
{
//int.TryParse could be added for with custom handling when type cast fails
var orderId = (int)reader[0];
var customerId = (int)reader[1];
var totalMoney = (int)reader[2];
Order order = new Order(orderId, customerId, totalMoney);
lock (lockObj)
{
if (HttpRuntime.Cache.Get(orderCode) == null)
{
HttpRuntime.Cache.Insert(orderCode, order);
}
}
stopWatch.Stop();
logger.Log("INFO", "Elapsed - {0}", stopWatch.Elapsed);
return(order);
}
stopWatch.Stop();
logger.Log("INFO", "Elapsed - {0}", stopWatch.Elapsed);
Context.Response.StatusCode = (int)System.Net.HttpStatusCode.NotFound;
return(null);
}
catch (SqlException ex)
{
logger.Log("ERROR", ex.Message);
throw new ApplicationException("Error");
}
}
/// <summary>
/// Метод загружает аудиокнигу с сайта, в случае успешного скачивания книги,
/// сохраняет запись в таблицу DownloadAudiobook
/// </summary>
/// <param name="audiobook">Аудиокнига, которую необходимо загрузить</param>
/// <returns></returns>
private async Task Download(Audiobook audiobook, string filename = fileName)
{
try
{
logger.Log($"Проверяем, нет ли в БД в таблице скаченных аудиокниг информации об аудиокниге: {audiobook.Title}.");
// Проверяем не была ли загружена аудиокнига
bool isDownload = db.IsDownloadAudiobook(audiobook);
// Если нет, скачиваем
if (!isDownload)
{
logger.Log($"Аудиокнига {audiobook.Title} не скачивалась ранее, запускаем загрузку.");
logger.Log($"Абсолютный путь к файлу на диске: {$"{dirPath}/{filename}"}.");
using (var fs = new FileStream($"{dirPath}/{filename}", FileMode.Create, FileAccess.ReadWrite))
{
logger.Debug($"Запускаем скачивание аудиокниги {audiobook.Title}.");
await service.GetAudiobook(audiobook, fs);
logger.Success($"Аудиокнига {audiobook.Title} успешно скачена. " +
$"Сохраняем информацию в БД, в таблицу загруженных аудиокниг."
);
// В случае успешного скачивания сохраним информацию об аудиокниге в таблицке загрузок
await db.SaveDownloadAudiobook(audiobook);
logger.Success("Сохранение выполнено успешно.");
}
}
else
{
logger.Log($"Аудиокнига {audiobook.Title} существует в таблице скаченных аудиокниг, поэтому пропускаем скачивание.");
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// Handles the exception, logging the error.
/// </summary>
/// <param name="_logger"></param>
public override void HandleException(ICustomLogger _logger)
{
_logger.Log(LogLevel.Error, 0, this, "Audit can't be deleted in this state");
}
/// <summary>
/// Handles the exception, logging the error.
/// </summary>
/// <param name="_logger"></param>
public override void HandleException(ICustomLogger _logger)
{
_logger.Log(LogLevel.Error, 0, this, new { User, Password });
}
public void AddLog(int Level, int UserId, int OrgId, string MessageTemplate, Exception ex)
{
_customLogger.Log(Level, UserId, OrgId, MessageTemplate, ex);
}
public void ScopedService()
{
_logger.Log("Comando1::ScopedService " + _scopeSrv.GetHashCode());
_scopeSrv.Ejecutar();
}
public SingletonService(ICustomLogger logger)
{
_logger = logger;
_logger.Log("Instancia SingletonService");
Contador = 0;
}
public string Ejecutar()
{
_logger.Log("ScopedService::Ejecutar " + this.GetHashCode());
return(nameof(ScopedService));
}
/// <summary>
/// Handles the exception, logging the error.
/// </summary>
/// <param name="_logger"></param>
public override void HandleException(ICustomLogger _logger)
{
_logger.Log(LogLevel.Error, 0, this, "User does not have permissions");
}
public string Ejecutar()
{
_logger.Log("TransientService::Ejecutar " + this.GetHashCode());
return(nameof(TransientService));
}
public ScopedService(ICustomLogger logger)
{
_logger = logger;
_logger.Log("Instancia ScopedService " + this.GetHashCode());
}
/// <summary>
/// Handles the exception, logging the error.
/// </summary>
/// <param name="_logger"></param>
public override void HandleException(ICustomLogger _logger)
{
_logger.Log(LogLevel.Error, 0, this, new { Finding });
}
public TransientService(ICustomLogger logger)
{
_logger = logger;
_logger.Log("Instancia TransientService " + this.GetHashCode());
}
