private async Task ChangeStatusAndExecutors(UpdateTaskData data, User user, bool newtask, int permissions)
        {
            var needPermissionBits = -1;
            var res = permissions & needPermissionBits;

            //если админ то итак нихуя неизменится. нахера флаг с новой таской. хм
            //if (res != needPermissionBits && !newtask)
            if (res != needPermissionBits)
            {
                //Меняем статус
                if (data.StatusId != null)
                {
                    //меняем исполнителя, если статус подходящий

                    int brigadeType = 999;
                    //тут начинается ебоклюйство с правами.
                    // бригады локомативщиков 6
                    needPermissionBits = 64;
                    res = permissions & needPermissionBits;
                    if (res == needPermissionBits)
                    {
                        if (data.StatusId == (int)TaskStatus.Remake)
                        {
                            brigadeType = (int)BrigadeType.Depo;
                        }
                    }
                    // приемщиков 8
                    needPermissionBits = 256;
                    res = permissions & needPermissionBits;
                    if (res == needPermissionBits)
                    {
                        if (data.StatusId == (int)TaskStatus.Confirmation)
                        {
                            brigadeType = (int)BrigadeType.Locomotiv;
                        }
                        if (data.StatusId == (int)TaskStatus.Remake)
                        {
                            brigadeType = (int)BrigadeType.Depo;
                        }
                    }

                    if (brigadeType != 999)
                    {
                        var trainTaskExecutor = new TrainTaskExecutor
                        {
                            TrainTaskId = data.TraintaskId,
                            BrigadeType = (BrigadeType)brigadeType,
                            UserId      = user.Id
                        };
                        var sqlRExecutor = new ExecutorRepository(_logger);
                        await sqlRExecutor.AddNewExecutorToTask(trainTaskExecutor, user, false);
                    }
                }
            }
        }
Exemple #2
0
        //TODO переделать на юзинг
        public async Task <TrainTaskExecutor> AddTransaction(TrainTaskExecutor ex, bool timeShift = false)
        {
            var sql = Sql.SqlQueryCach["Executor.Add"];

            if (timeShift)
            {
                sql = Sql.SqlQueryCach["Executor.Add-5"];
            }

            var id = await _db.Connection.QueryAsync <int>(sql,
                                                           new { task_id = ex.TrainTaskId, brigade_type = ex.BrigadeType, user_id = ex.UserId }, _db.Transaction.Transaction);

            ex.Id = id.First();

            return(ex);
        }
Exemple #3
0
        public async Task <TrainTaskExecutor> AddNewExecutorToTask(TaskService.UpdateTaskData data, User user, bool timeShift)
        {
            if (data.TrainTaskExecutorsId != null)
            {
                var executor = new TrainTaskExecutor
                {
                    BrigadeType = (BrigadeType)data.TrainTaskExecutorsId,
                    TrainTaskId = data.TraintaskId,
                    UserId      = user.Id
                };
                var result = await AddNewExecutorToTask(executor, user, timeShift);

                return(result);
            }
            return(new TrainTaskExecutor());
        }
Exemple #4
0
        public async Task <TrainTaskExecutor> AddNewExecutorToTask(TrainTaskExecutor data, User user, bool timeShift)
        {
            using (var conn = new SqlConnection(AppSettings.ConnectionString))
            {
                var sql   = new ExecutorSqls();
                var query = sql.AddExecutorToTask;
                if (timeShift)
                {
                    query = sql.AddExecutorToTaskTimeShift;
                }

                var id = await conn.QueryFirstOrDefaultAsync <int>(query,
                                                                   new { task_id = data.TrainTaskId, brigade_type = data.BrigadeType, user_id = data.UserId }
                                                                   );

                var result = await GetExecutorById(id);

                return(result);
            }
        }
Exemple #5
0
        private static UpdateUserDateDto GetTaskLastUpdate(TrainTaskComment lastComment, TrainTaskExecutor lastExecutor,
                                                           TrainTaskStatus lastStatus)
        {
            var items = new List <UpdateUserDateDto>();

            if (lastComment != null)
            {
                items.Add(new UpdateUserDateDto
                {
                    Date = lastComment.Date,
                    User = lastComment.User
                });
            }

            if (lastExecutor != null)
            {
                items.Add(new UpdateUserDateDto
                {
                    Date = lastExecutor.Date,
                    User = lastExecutor.User
                });
            }

            if (lastStatus != null)
            {
                items.Add(new UpdateUserDateDto
                {
                    Date = lastStatus.Date,
                    User = lastStatus.User
                });
            }

            return(items.Any() ? items.OrderBy(o => o.Date).Last() : null);
        }
        public async Task <List <HistoryTaskDto> > AddHistoryData(int id)
        {
            var list = new List <HistoryTaskDto>();

            var cr = new CommentRepository(_logger);
            var dr = new DocumentRepository(_logger);
            var er = new ExecutorRepository(_logger);
            var sr = new TaskStatusRepository(_logger);

            var comments = await cr.GetByTaskId(id);

            var docs = await dr.GetByTaskId(id);

            var executors = await er.GetByTaskId(id);

            var statuses = await sr.ByTaskId(id);

            foreach (var comment in comments)
            {
                var docsComment = docs.Where(item => item.TrainTaskCommentId == comment.Id).ToList();
                var filesDto    = new List <FileTaskDto>();
                foreach (var item in docsComment)
                {
                    var toAdd = new FileTaskDto
                    {
                        DocumentType = (int)item.DocumentType,
                        Id           = item.Id,
                        Name         = item.Name
                    };
                    filesDto.Add(toAdd);
                }

                if (filesDto.Count != 0 || !string.IsNullOrWhiteSpace(comment.Text))
                {
                    list.Add(new HistoryTaskDto
                    {
                        Date            = comment.Date,
                        Files           = filesDto,
                        Type            = TaskHistoryType.Comment.ToString(),
                        User            = comment.User.Name,
                        UserBrigadeType = (int?)comment.User.Brigade?.BrigadeType,
                        Text            = comment.Text
                    });
                }
            }

            TrainTaskExecutor prevExec = null;

            foreach (var exec in executors)
            {
                list.Add(new HistoryTaskDto
                {
                    Date = exec.Date,
                    NewExecutorBrigadeType = (int)exec.BrigadeType,
                    OldExecutorBrigadeType = prevExec == null ? null : (int?)prevExec.BrigadeType,
                    Type            = TaskHistoryType.Executor.ToString(),
                    User            = exec.User.Name,
                    UserBrigadeType = (int?)exec.User.Brigade?.BrigadeType,
                });
                prevExec = exec;
            }

            TrainTaskStatus prevSt = null;

            foreach (var st in statuses)
            {
                list.Add(new HistoryTaskDto
                {
                    Date            = st.Date,
                    NewStatus       = (int)st.Status,
                    OldStatus       = prevSt == null ? null : (int?)prevSt.Status,
                    Type            = TaskHistoryType.Status.ToString(),
                    User            = st.User.Name,
                    UserBrigadeType = (int?)st.User.Brigade?.BrigadeType,
                });
                prevSt = st;
            }

            var ret = list.OrderBy(o => o.Date).ToList();

            return(ret);
        }