Пример #1
0
        public async Task <OperationResult> PairSingle(PlanningAssignSitesModel requestModel)
        {
            var sdkCore =
                await _coreService.GetCore();

            await using var sdkDbContext = sdkCore.DbContextHelper.GetDbContext();
            try
            {
                var planning = await _dbContext.Plannings
                               .Include(x => x.PlanningSites)
                               .Where(x => x.Id == requestModel.PlanningId)
                               .Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
                               .FirstOrDefaultAsync();

                if (planning == null)
                {
                    return(new OperationResult(false,
                                               _itemsPlanningLocalizationService.GetString("PlanningNotFound")));
                }

                // for remove
                var assignmentsRequestIds = requestModel.Assignments
                                            .Select(x => x.SiteId)
                                            .ToList();

                var forRemove = planning.PlanningSites
                                .Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
                                .Where(x => !assignmentsRequestIds.Contains(x.SiteId))
                                .ToList();

                foreach (var planningSite in forRemove)
                {
                    await planningSite.Delete(_dbContext);
                }

                var planningCases = await _dbContext.PlanningCases
                                    .Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
                                    .Where(x => assignmentsRequestIds.Contains(x.DoneByUserId))
                                    .ToListAsync();

                foreach (var planningCase in planningCases)
                {
                    var planningCaseSites = await _dbContext.PlanningCaseSites
                                            .Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
                                            .Where(x => x.PlanningCaseId == planningCase.Id)
                                            .ToListAsync();

                    foreach (var planningCaseSite in planningCaseSites.Where(planningCaseSite => planningCaseSite.MicrotingSdkCaseId != 0))
                    {
                        var theCase =
                            await sdkDbContext.Cases.SingleOrDefaultAsync(x => x.Id == planningCaseSite.MicrotingSdkCaseId);

                        if (theCase != null)
                        {
                            if (theCase.MicrotingUid != null)
                            {
                                await sdkCore.CaseDelete((int)theCase.MicrotingUid);
                            }
                        }
                        else
                        {
                            var checkListSite =
                                await sdkDbContext.CheckListSites.SingleOrDefaultAsync(x =>
                                                                                       x.Id == planningCaseSite.MicrotingCheckListSitId);

                            if (checkListSite != null)
                            {
                                await sdkCore.CaseDelete(checkListSite.MicrotingUid);
                            }
                        }
                    }
                    // Delete planning case
                    await planningCase.Delete(_dbContext);
                }
                // for create
                var assignmentsIds = planning.PlanningSites
                                     .Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
                                     .Select(x => x.SiteId)
                                     .ToList();

                var assignmentsForCreate = requestModel.Assignments
                                           .Where(x => !assignmentsIds.Contains(x.SiteId))
                                           .Select(x => x.SiteId)
                                           .ToList();

                foreach (var assignmentSiteId in assignmentsForCreate)
                {
                    var planningSite = new PlanningSite
                    {
                        CreatedByUserId = _userService.UserId,
                        UpdatedByUserId = _userService.UserId,
                        PlanningId      = planning.Id,
                        SiteId          = assignmentSiteId,
                    };

                    await planningSite.Create(_dbContext);

                    var dataResult = await _planningService.Read(planning.Id);

                    if (dataResult.Success)
                    {
                        await _pairItemWichSiteHelper.Pair(dataResult.Model, assignmentSiteId, planning.RelatedEFormId, planning.Id);
                    }
                }

                return(new OperationResult(true,
                                           _itemsPlanningLocalizationService.GetString("PairingUpdatedSuccessfully")));
            }
            catch (Exception e)
            {
                Trace.TraceError(e.Message);
                return(new OperationResult(false,
                                           _itemsPlanningLocalizationService.GetString("ErrorWhileUpdatingItemsPlanning") + $" {e.Message}"));
            }
        }
 public async Task <OperationResult> AssignPlanning([FromBody] PlanningAssignSitesModel requestModel)
 {
     return(await _pairingService.PairSingle(requestModel));
 }