private async Task AddFaultData(TaskByIdDto result, TaskDetailFromSql item)
        {
            var sqlRUsers     = new UserRepository(_logger);
            var attributeUser = await sqlRUsers.ById(item.AttributeUserId);

            var faultToAdd = new FaultTaskDto
            {
                User = attributeUser.Name,
                Date = item.AttributeUpdateDate,
                Id   = item.AttributeId,
                Text = item.FaultName
            };

            result.Faults.Add(faultToAdd);
        }
        private async Task AddInspectionData(TaskByIdDto result, TaskDetailFromSql item)
        {
            var sqlRInspection = new InspectionRepository(_logger);
            var sqlRUsers      = new UserRepository(_logger);
            var sqlRBrigade    = new BrigadeRepository(_logger);

            var inspection = await sqlRInspection.ById(item.AttributeInspectionId);

            var inspectionUser = await sqlRUsers.ById(inspection.UserId);

            int?inspectionBrigadeType = null;

            if (inspectionUser.BrigadeId.HasValue)
            {
                var inspectionBrigade = await sqlRBrigade.ById(inspectionUser.BrigadeId.Value);

                inspectionBrigadeType = (int)inspectionBrigade.BrigadeType;
            }

            var inspectionToAdd = new InspectionTaskDto
            {
                Id          = inspection.Id,
                DateStart   = inspection.DateStart,
                DateEnd     = inspection.DateEnd,
                User        = inspectionUser.Name,
                Type        = (int)inspection.CheckListType,
                BrigadeType = inspectionBrigadeType,
                Texts       = new List <string>()
            };

            if (item.AttributeCheckListEquipmentId.HasValue)
            {
                var toAddText                = $"{item.EquipmentName} -> {item.CheckListEquipmentTaskName} -> ";
                var checkListStringValue     = string.Empty;
                var taskAttributeStringValue = string.Empty;
                if (item.CheckListEquipmentValueType == 1)
                {
                    if (item.CheckListEquipmentValue == 0)
                    {
                        checkListStringValue = "Нет";
                    }
                    if (item.CheckListEquipmentValue == 1)
                    {
                        checkListStringValue = "Да";
                    }

                    if (item.AttributeValue == 0)
                    {
                        taskAttributeStringValue = "Нет";
                    }
                    if (item.AttributeValue == 1)
                    {
                        taskAttributeStringValue = "да";
                    }
                }
                else
                {
                    checkListStringValue     = item.CheckListEquipmentValue.ToString();
                    taskAttributeStringValue = item.AttributeValue.ToString();
                }

                toAddText += $"{checkListStringValue} -> {taskAttributeStringValue}";

                inspectionToAdd.Texts.Add(toAddText);
            }


            // Для ТО-1 ТО-2 и тд
            if (inspection.CheckListType == CheckListType.TO1 || inspection.CheckListType == CheckListType.TO2)
            {
                //  Уровень критичности → Высокий
                if (item.TaskLevel.HasValue)
                {
                    var toAddText = $"Уровень критичности -> {GetStringTaskLevel(item.TaskLevel.Value)}";
                    inspectionToAdd.Texts.Add(toAddText);
                }

                //Смотрим что добавилось в рамках мероприятия TaskLevel или FaultId, пишим в текст
                if (item.AttributeFaultId.HasValue)
                {
                    var toAddText = $"{item.FaultName} -> {item.EquipmentName}";
                    inspectionToAdd.Texts.Add(toAddText);
                }
            }

            result.Inspections.Add(inspectionToAdd);
        }
        public async Task <TaskByIdDto> GetTaskById(int id, int permissions = -1)
        {
            using (var conn = new SqlConnection(AppSettings.ConnectionString))
            {
                var sqlRExecutor   = new ExecutorRepository(_logger);
                var sqlRTaskStatus = new TaskStatusRepository(_logger);
                var sqlRTask       = new TaskSqls();


                var fromSql = (await conn.QueryAsync <TaskDetailFromSql>(sqlRTask.GetTrainTaskByIdAndAttributeId(id))).ToList();

                var task = fromSql.First();

                var result = new TaskByIdDto
                {
                    Id             = task.Id,
                    Data           = task.CreateDate,
                    InitiatorName  = task.InitiatorName,
                    TrainName      = task.TrainName,
                    EquipmentName  = task.EquipmentName,
                    CarriageSerial = task.CarriageSerial, //CreateCarriageName(task.TrainName, task.CarriageNumber),
                    TaskType       = task.TaskType
                };

                //Текущий статус
                var taskStatuses = await sqlRTaskStatus.ByTaskId(id);

                var currentTaskStatus = taskStatuses.Last().Status;
                result.StatusId = (int)currentTaskStatus;

                //Текущий исполнитель
                var taskExecutors = await sqlRExecutor.GetByTaskId(id);

                BrigadeType currentTaskExecutor = 0;
                if (taskExecutors.Count > 0)
                {
                    currentTaskExecutor = taskExecutors.Last().BrigadeType;
                    result.BrigadeType  = (int)currentTaskExecutor;
                }

                //Уровень задачи
                var taskLevel = fromSql.OrderBy(x => x.TaskLevel).Select(x => x.TaskLevel).First();
                result.TaskLevel = taskLevel.HasValue ? (int)taskLevel : 0;

                //Доступные статусы
                var possibleTaskStatuses = sqlRTaskStatus.GetAvailableStatusesNewTask(currentTaskStatus, currentTaskExecutor, permissions);
                result.PossibleTaskStatuses = possibleTaskStatuses.Select(x => (int)x).ToList();

                //Неисправности из атрибутов
                result.Faults      = new List <FaultTaskDto>();
                result.Inspections = new List <InspectionTaskDto>();
                foreach (var item in fromSql)
                {
                    if (item.AttributeFaultId != null)
                    {
                        await AddFaultData(result, item);
                    }

                    if (item.AttributeInspectionId != 0)
                    {
                        await AddInspectionData(result, item);
                    }
                }
                //Добавить в фаулты данные по чеклистам из инпекции
                var withCheckListEquipmentId = fromSql.Where(x => x.AttributeCheckListEquipmentId != null)
                                               .DistinctBy(y => y.AttributeCheckListEquipmentId).ToList();
                foreach (var item in withCheckListEquipmentId)
                {
                    await AddFaultDataFromCheckListEquipmentId(result, item);
                }

                result.History = await AddHistoryData(id);

                return(result);
            }
        }