public void UpdateProcessedTask(SendingTask task, TaskStatus status)
{
lock (_lockDb)
{
var taskInDb = _dbContext.SendingTasks.Single(x => x.Id == task.Id);
taskInDb.Status = status;
_dbContext.SaveChanges();
}
}
public override void Send()
{
InlineKeyboardMarkup mark = this.keyboardMarkup as InlineKeyboardMarkup;
if (mark != null)
{
SendingTask = client.EditMessageReplyMarkupAsync(this.ChatID, this.message_id, mark);
SendingTask.ContinueWith(LogResult);
}
}
/// <summary>
/// Shutdown this appender - stop the sending task
/// </summary>
protected override void OnClose()
{
// Stop the sending task
Buffer.CompleteAdding();
if (SendingTask != null)
{
SendingTask.Wait();
}
SendingTask = null;
base.OnClose();
}
private static IntegrationModel CastSendingTasksListToIntegrationModel(SendingTask task, string recipient,
string method, string uid)
{
var model = new IntegrationModel()
{
dataModel = new Models.FileInfo()
{
name = task.Name,
path = task.Path
},
recipient = recipient,
uid = uid.ToString(),
method = method,
envCode = _config.FileMonitoringEnvCode
};
return(model);
}
public override void Send()
{
SendingTask = client.SendAnimationAsync(ChatID, inputOnlineFile,
replyToMessageId: inReplyOf, caption: text, parseMode: ParseMode.Html);
SendingTask.ContinueWith(LogResult);
}
public override void Send()
{
SendingTask = client.SendStickerAsync(ChatID, inputOnlineFile,
replyToMessageId: inReplyOf);
SendingTask.ContinueWith(LogResult);
}
public override void Send()
{
SendingTask = client.SendPhotoAsync(ChatID, inputOnlineFile, caption: text,
replyToMessageId: inReplyOf, parseMode: ParseMode.Html, replyMarkup: keyboardMarkup);
SendingTask.ContinueWith(LogResult);
}
public override void Send()
{
SendingTask = this.client.ForwardMessageAsync(To, From, MessageID);
SendingTask.ContinueWith(LogResult);
}
public ApiResponseStatus SendFileInfoRequest(SendingTask task, string recipient, string uid)
{
var model = CastSendingTasksListToIntegrationModel(task, recipient, _config.Method, uid);
var jsonBody = JsonHelper.ConvertIntegrationModelToJson(model);
try
{
var request = WebRequest.Create(_config.ServiceIntegrationUrl);
request.Method = "POST";
var byteArray = Encoding.UTF8.GetBytes(jsonBody);
request.ContentType = "application/json";
request.ContentLength = byteArray.Length;
request.Timeout = _config.ApiTimeout;
using (var dataStream = request.GetRequestStream())
{
dataStream.Write(byteArray, 0, byteArray.Length);
}
var address = $"Адрес шины. :\n {_config.ServiceIntegrationUrl}";
_logger.LogInformation($"Запрос пытается отправиться на шину. JSON body:\n {jsonBody}");
_logger.LogInformation(address);
if (!GetResponse(request))
{
FailedApiIntegration.WithLabels($"JSON body:\n {jsonBody}").Set(1);
throw new ApplicationException($"Ошибка при отправке запроса. JSON body:\n {jsonBody}");
}
_logger.LogInformation($"Запрос успешно отправлен на шину. JSON body:\n {jsonBody}");
return(ApiResponseStatus.SuccessfullyProcessed);
}
catch (WebException webException)
{
try
{
using (var webResponse = webException.Response)
{
if (webResponse != null)
{
using (var receiveStream = webResponse.GetResponseStream())
{
var encode = Encoding.GetEncoding("utf-8");
using (var readStream = new StreamReader(receiveStream, encode))
{
//длина строки в консоли
var readBytes = new char[256];
var errorMessageBuilder = new StringBuilder();
var count = readStream.Read(readBytes, 0, 256);
while (count > 0)
{
errorMessageBuilder.Append(new string(readBytes, 0, count));
count = readStream.Read(readBytes, 0, 256);
}
readStream.Close();
webResponse.Close();
var rawResponse = errorMessageBuilder.ToString();
FailedApiIntegration.WithLabels(webException.Message + $"Response: {rawResponse}\n Request Body: {jsonBody}").Set(1);
_logger.LogError(webException, $"Ошибка при отправке запроса.Response: {rawResponse}\n Request Body: {jsonBody}");
return(rawResponse.Contains(Constants.ConnectExceptionMessage)
? ApiResponseStatus.BusConnectException
: ApiResponseStatus.InternalBusError);
}
}
}
else
{
FailedApiIntegration.WithLabels(webException.Message + $"{_config.ServiceIntegrationUrl}, Request Body: {jsonBody}").Set(1);
_logger.LogError(webException, $"Сервер не отвечает по адресу {_config.ServiceIntegrationUrl}, Request Body: {jsonBody}");
return(ApiResponseStatus.ServerIsNotAvailable);
}
}
}
catch (Exception ex)
{
FailedApiIntegration.WithLabels($"Request Body: {jsonBody}. {webException.Message}").Set(1);
throw new ApplicationException(
$"Ошибка обработки ошибки с сервера, Request Body: {jsonBody}. Ошибка сервера {webException.ToString()}", ex);
}
}
}
public DataShareState ProccessData(string nowDataStr, List <DataShareImage> images)
{
if (InternalState == DataShareInternalState.Error)
{
return(ExternalState);
}
if (DelayTimer != null)
{
DelayTimer.Dispose();
DelayTimer = null;
}
if (SendingTask.Status == TaskStatus.Faulted || SendingTask.Status == TaskStatus.Canceled || (SendingTask.Status == TaskStatus.RanToCompletion && !SendingTask.Result))
{
InternalState = DataShareInternalState.Error;
DelayTimer = new Timer(DelayTimerCallback, null, 1 * 1 * 1000, Timeout.Infinite);
return(ExternalState);
}
if (InternalState == DataShareInternalState.Reconnect)
{
if (SendingTask.Status != TaskStatus.RanToCompletion)
{
return(ExternalState);
}
else
{
InternalState = DataShareInternalState.Worked;
}
}
if (String.IsNullOrEmpty(nowDataStr))
{
if (DataList.Count == 0)
{
return(ExternalState);
}
}
else
{
if (DataList.Count < 10000)
{
string dataShareDataStr = CreateDataShareDataStr(nowDataStr, images);
//Console.WriteLine("\ndataShareDataStr: " + dataShareDataStr);
DataList.Add(dataShareDataStr);
}
}
if (SendingTask.Status == TaskStatus.Running)
{
return(ExternalState);
}
if (SendingTask.Status == TaskStatus.RanToCompletion)
{
SendingTask = new Task <bool>(() => DataShareTaskCode.TaskProccessData(cts.Token, TaskState), cts.Token);
}
if (SendingTask.Status == TaskStatus.Created)
{
TaskState.Message = CreateMessage();
DataList.Clear();
SendingTask.Start();
}
return(ExternalState);
}
