public async Task FailedAsync(string message)
        {
            await FailedAsync().ConfigureAwait(false);

            string errorMessage = string.Empty;

            if (_block.RangeType == BlockType.DateRange)
            {
                errorMessage = string.Format("BlockId {0} From: {1} To: {2} Error: {3}",
                                             _block.RangeBlockId,
                                             _block.RangeBeginAsDateTime().ToString("yyyy-MM-dd HH:mm:ss"),
                                             _block.RangeEndAsDateTime().ToString("yyyy-MM-dd HH:mm:ss"),
                                             message);
            }
            else
            {
                errorMessage = string.Format("BlockId {0} From: {1} To: {2} Error: {3}",
                                             _block.RangeBlockId,
                                             _block.RangeBeginAsLong(),
                                             _block.RangeEndAsLong(),
                                             message);
            }


            var errorRequest = new TaskExecutionErrorRequest()
            {
                TaskId            = new TaskId(_applicationName, _taskName),
                TaskExecutionId   = _taskExecutionId,
                TreatTaskAsFailed = false,
                Error             = errorMessage
            };
            await _taskExecutionRepository.ErrorAsync(errorRequest).ConfigureAwait(false);
        }
        public async Task ErrorAsync(TaskExecutionErrorRequest taskExecutionErrorRequest)
        {
            if (taskExecutionErrorRequest.TreatTaskAsFailed)
            {
                await SetTaskExecutionAsFailedAsync(taskExecutionErrorRequest.TaskId, taskExecutionErrorRequest.TaskExecutionId).ConfigureAwait(false);
            }

            await RegisterEventAsync(taskExecutionErrorRequest.TaskId, taskExecutionErrorRequest.TaskExecutionId, EventType.Error, taskExecutionErrorRequest.Error).ConfigureAwait(false);
        }
        public void Error(TaskExecutionErrorRequest taskExecutionErrorRequest)
        {
            if (taskExecutionErrorRequest.TreatTaskAsFailed)
            {
                SetTaskExecutionAsFailed(taskExecutionErrorRequest.TaskId, taskExecutionErrorRequest.TaskExecutionId);
            }

            RegisterEvent(taskExecutionErrorRequest.TaskId, taskExecutionErrorRequest.TaskExecutionId, EventType.Error, taskExecutionErrorRequest.Error);
        }
        public async Task FailedAsync(string message)
        {
            await FailedAsync().ConfigureAwait(false);

            string errorMessage = string.Format("BlockId {0} Error: {1}", ListBlockId, message);
            var    errorRequest = new TaskExecutionErrorRequest()
            {
                TaskId            = new TaskId(_applicationName, _taskName),
                TaskExecutionId   = _taskExecutionId,
                TreatTaskAsFailed = false,
                Error             = errorMessage
            };
            await _taskExecutionRepository.ErrorAsync(errorRequest).ConfigureAwait(false);
        }
        public void Failed(string message)
        {
            Failed();

            string errorMessage = string.Format("BlockId {0} Error: {1}", ListBlockId, message);
            var    errorRequest = new TaskExecutionErrorRequest()
            {
                TaskId            = new TaskId(_applicationName, _taskName),
                TaskExecutionId   = _taskExecutionId,
                TreatTaskAsFailed = false,
                Error             = errorMessage
            };

            _taskExecutionRepository.Error(errorRequest);
        }
        public async Task ErrorAsync(string errorMessage, bool treatTaskAsFailed)
        {
            if (!IsExecutionContextActive)
            {
                throw new ExecutionException(NotActiveMessage);
            }

            _executionHasFailed = treatTaskAsFailed;

            var request = new TaskExecutionErrorRequest()
            {
                TaskId            = new TaskId(_taskExecutionInstance.ApplicationName, _taskExecutionInstance.TaskName),
                TaskExecutionId   = _taskExecutionInstance.TaskExecutionId,
                Error             = errorMessage,
                TreatTaskAsFailed = treatTaskAsFailed
            };
            await _taskExecutionRepository.ErrorAsync(request).ConfigureAwait(false);
        }