public async Task <SoftwareDTO> ProcessRequest(SoftwareDTO dto)
        {
            logger.LogDebug($"ProcessRequest method fired {dto.JobID} and {dto.NodeID}");

            logger.LogDebug($"TakeActivity method fired {dto.SessionId} and {dto.DomainModel.JobId} and { dto.NodeID} and {dto.EPC}");

            if (dto.activity == null)
            {
                dto.activity = await KtaService.TakeActivityAsync(dto.SessionId, dto.DomainModel.JobId, dto.NodeID, dto.EPC);
            }
            if (dto.activity.Identity.NodeId == dto.NodeID && (dto.activity.Identity.NodeId == ConstantNodes.DirectManager_NodeId || dto.activity.Identity.NodeId == ConstantNodes.ITSolutions_NodeId || dto.activity.Identity.NodeId == ConstantNodes.NodeId_EmployeeUpdate || dto.activity.Identity.NodeId == ConstantNodes.HelpDesk_NodeId ||
                                                               dto.activity.Identity.NodeId == ConstantNodes.DepartmentManager_NodeId || dto.activity.Identity.NodeId == ConstantNodes.NodeId_EmployeeUpdate))
            {
                dto.DomainModel.ITSoftwareRequestItems = await Task.Run(() => SetSoftwareRequestItems(dto));

                var entity = FindOneById(dto.DomainModel.Id);
                if (dto.DomainModel.Id == entity.Id)
                {
                    Mapper.Map(dto.DomainModel, entity);
                }

                await UpdateRequest();
            }

            logger.LogDebug($"CompleteActivity method fired SessionId {dto.SessionId} and Username {dto.Requester.Username} and Id { dto.ManagerDecision.Id} and Comment {dto.ManagerDecision.Comment} and Identity {dto.activity.Identity}");

            await KtaService.CompleteActivityAsync(dto.SessionId, dto.Requester.Username, dto.ManagerDecision.Id, dto.ManagerDecision.Comment, dto.activity.Identity);

            return(dto);
        }
        //Update according to ur feature (service request)
        public async Task <ITServerAccessDTO> ProcessRequest(ITServerAccessDTO dto)
        {
            logger.LogDebug($"ProcessRequest method fired {dto.JobID} and {dto.NodeID}");

            if (dto.activity == null)
            {
                dto.activity = await KtaService.TakeActivityAsync(dto.SessionId, dto.DomainModel.JobId, dto.NodeID, dto.EPC);
            }

            if (dto.activity.Identity.NodeId == dto.NodeID && (dto.activity.Identity.NodeId == ConstantNodes.NodeId_ITSystems || dto.activity.Identity.NodeId == ConstantNodes.NodeId_EmployeeToUpdate))
            {
                if (dto.activity.Identity.NodeId == ConstantNodes.NodeId_EmployeeToUpdate)
                {
                    Mapper.Map(dto.ServerDetailsItems, dto.DomainModel.RequiredServersDetails);
                }
                var entity = FindOneById(dto.DomainModel.Id);
                Mapper.Map(dto.DomainModel, entity);
                await UpdateRequest();
            }
            logger.LogDebug($"CompleteActivity method fired SessionId {dto.SessionId} and Username {dto.Requester.Username} and Id { dto.ManagerDecision.Id} and Comment {dto.ManagerDecision.Comment} and Identity {dto.activity.Identity}");

            await KtaService.CompleteActivityAsync(dto.SessionId, dto.Requester.Username, dto.ManagerDecision.Id, dto.ManagerDecision.Comment, dto.activity.Identity);

            return(dto);
        }
示例#3
0
        public async Task <IActionResult> Cancel([FromBody] JobActivity activity, string jobID, short NodeID, short EPC)
        {
            if (activity == null)
            {
                activity = await KtaService.TakeActivityAsync(await getUserSession(), jobID, NodeID, EPC);
            }

            await KtaService.CancelActivityAsync(await getUserSession(), activity.Identity);

            return(Ok());
        }
示例#4
0
        public async Task <SPSiteCreationDTO> GetRequestData(RequestDataModel data)
        {
            var activity = await KtaService.TakeActivityAsync(data.SessionId, data.JobId, data.NodeId, data.epc);

            var dto = await GetSPSiteCreation(data);

            dto.Decisions = decisionService.GetDecisionList(activity.HelpText);
            dto.Requester = await employeeService.FindEmployeeWithEmailAsync(dto.DomainModel.EmployeeEmail);

            dto.activity = activity;
            return(dto);
        }
        //Mapping between parameters and method (get joibid node epc)
        //Get request include request details
        public async Task <ITServerAccessDTO> GetRequestData(RequestDataModel data)
        {
            logger.LogDebug("GetRequestData method fired with these parameters", data);
            var activity = await KtaService.TakeActivityAsync(data.SessionId, data.JobId, data.NodeId, data.epc);

            var dto = await PrepareDTO(data);

            dto.Requester = await employeeService.FindEmployeeWithEmailAsync(dto.DomainModel.EmployeeEmail);

            dto.Decisions = decisionService.GetDecisionList(activity.HelpText);
            dto.activity  = activity;
            return(dto);
        }
        public async Task <ITResignationDTO> GetRequestData(RequestDataModel data)
        {
            logger.LogDebug("GetRequestData method fired with these parameters", data);

            var activity = await KtaService.TakeActivityAsync(data.SessionId, data.JobId, data.NodeId, data.epc);

            var dto = await PrepareDTO(data);

            dto.Decisions = decisionService.GetDecisionList(activity.HelpText);

            dto.activity = activity;

            return(dto);
        }
        public async Task <ConsultationCompletionDTO> GetRequestData(RequestDataModel data)
        {
            var activity = await KtaService.TakeActivityAsync(data.SessionId, data.JobId, data.NodeId, data.epc);

            ConsultationCompletionDTO dto = new ConsultationCompletionDTO();

            dto.DomainModel = FindOneByJobId(data.JobId);
            dto.Requester   = await employeeService.FindEmployeeWithEmailAsync(dto.DomainModel.EmployeeEmail);

            dto.ConsultantEvaluation = await GetConsultantEvaluation(dto);

            dto.Decisions = decisionService.GetDecisionList(activity.HelpText);
            dto.activity  = activity;
            return(dto);
        }
        public async Task <EmailGroupDTO> GetRequestData(RequestDataModel data)
        {
            var activity = await KtaService.TakeActivityAsync(data.SessionId, data.JobId, data.NodeId, data.epc);

            var dto = await GetEmailGroup(data);

            dto.AddGroupEmail();
            if (data.NodeId == ConstantNodes.NodeId_ITSystems)
            {
                dto.createEmailGroup = true;
            }
            dto.Decisions = decisionService.GetDecisionList(activity.HelpText);
            dto.Requester = await employeeService.FindEmployeeWithEmailAsync(dto.DomainModel.EmployeeEmail);

            dto.activity = activity;
            return(dto);
        }
        public async Task <ITAccountDTO> ProcessRequest(ITAccountDTO dto)
        {
            if (dto.activity == null)
            {
                dto.activity = await KtaService.TakeActivityAsync(dto.SessionId, dto.DomainModel.JobId, dto.NodeID, dto.EPC);
            }

            if (dto.activity.Identity.NodeId == dto.NodeID && (dto.activity.Identity.NodeId == ConstantNodes.NodeId_ITSystemsHead || dto.activity.Identity.NodeId == ConstantNodes.NodeId_ITSystemsTeam || dto.activity.Identity.NodeId == ConstantNodes.NodeId_ITSystemEmployeeToUpdate))
            {
                var entity = FindOneById(dto.DomainModel.Id);
                Mapper.Map(dto.DomainModel, entity);
                await UpdateRequest();
            }

            await KtaService.CompleteActivityAsync(dto.SessionId, dto.Requester.Username, dto.ManagerDecision.Id, dto.ManagerDecision.Comment, dto.activity.Identity);

            return(dto);
        }
        public async Task <ITAccountDTO> GetRequestData(RequestDataModel data)
        {
            var activity = await KtaService.TakeActivityAsync(data.SessionId, data.JobId, data.NodeId, data.epc);

            ITAccountDTO dto = new ITAccountDTO();

            dto.DomainModel = FindOneByJobId(data.JobId);
            dto.AddNewAccount();
            if (data.NodeId == ConstantNodes.NodeId_ITSystemsHead || data.NodeId == ConstantNodes.NodeId_ITSystemsTeam)
            {
                dto.createUser = true;
            }
            dto.Decisions = decisionService.GetDecisionList(activity.HelpText);
            dto.Requester = await employeeService.FindEmployeeWithEmailAsync(dto.DomainModel.EmployeeEmail);

            dto.activity = activity;
            return(dto);
        }
        public async Task <AdminTranslationDTO> ProcessRequest(AdminTranslationDTO dto)
        {
            logger.LogDebug($"ProcessRequest method fired {dto.JobID} and {dto.NodeID}");
            if (dto.activity == null)
            {
                dto.activity = await KtaService.TakeActivityAsync(dto.SessionId, dto.DomainModel.JobId, dto.NodeID, dto.EPC);
            }



            if (dto.activity.Identity.NodeId == dto.NodeID && (dto.activity.Identity.NodeId == ConstantNodes.NodeId_TransManager))
            {
                var entity = FindOneById(dto.DomainModel.Id);
                if (dto.DomainModel.Id == entity.Id)
                {
                    // entity.AssignedTo = dto.DomainModel.AssignedTo;
                    entity.Status       = dto.ManagerDecision.Id;
                    entity.ManagerNotes = dto.DomainModel.ManagerNotes;
                }
                await UpdateRequest();
            }
            if (dto.activity.Identity.NodeId == dto.NodeID && (dto.activity.Identity.NodeId == ConstantNodes.NodeId_Translator))
            {
                var entity = FindOneById(dto.DomainModel.Id);
                if (dto.DomainModel.Id == entity.Id)
                {
                    entity.AssignedTo = dto.Requester.Username;
                    entity.Status     = dto.ManagerDecision.Id;
                    entity.DoneDate   = DateTime.Now;
                }
                await UpdateRequest();
            }

            await KtaService.CompleteActivityAsync(dto.SessionId, dto.Requester.Username, dto.ManagerDecision.Id, dto.ManagerDecision.Comment, dto.activity.Identity);

            FileService.UploadRequestFiles(typeof(AdminTranslationDTO), dto,
                                           AppConfiguaraton.TranslationAttachementPath,
                                           dto.DomainModel.JobId, AppConfiguaraton.TranslationAttachementListName,
                                           string.Empty, dto.Requester.Username, multiTypes: false,
                                           uploadToSharepoint: true, multi: true);

            return(dto);
        }
        public async Task <ConsultationCompletionDTO> ProcessRequest(ConsultationCompletionDTO dto)
        {
            if (dto.activity == null)
            {
                dto.activity = await KtaService.TakeActivityAsync(dto.SessionId, dto.DomainModel.JobId, dto.NodeID, dto.EPC);
            }

            if (dto.activity.Identity.NodeId == dto.NodeID && (dto.activity.Identity.NodeId == ConstantNodes.Research_Collaboration_Committee) && dto.ManagerDecision.Id == ((int)ConstantNodes.ConsultationDecisions.Approved).ToString())
            {
                if (dto.DomainModel.Status != "Terminated")
                {
                    dto.DomainModel.StatusId = ((int)ConstantNodes.ConsultationStatus.Completed);
                    dto.DomainModel.Status   = "Completed";
                }


                var entity = FindOneById(dto.DomainModel.Id);
                if (dto.DomainModel.Id == entity.Id)
                {
                    Mapper.Map(dto.DomainModel, entity);
                }
                await UpdateRequest();

                var ConsulationCompletionViewModel = new EditConsultationDataViewModel();

                Mapper.Map(dto.DomainModel, ConsulationCompletionViewModel);

                var jsonPatch = new JsonPatchDocument <EditConsultationDataViewModel>();
                jsonPatch.Replace(m => m.ActualCost, ConsulationCompletionViewModel.ActualCost);
                jsonPatch.Replace(m => m.ActualDeliverables, ConsulationCompletionViewModel.ActualDeliverables);
                jsonPatch.Replace(m => m.ActualDuration, ConsulationCompletionViewModel.ActualDuration);
                jsonPatch.Replace(m => m.DurationNotes, ConsulationCompletionViewModel.DurationNotes);
                jsonPatch.Replace(m => m.Status, ConsulationCompletionViewModel.Status);

                string jobId = dto.ConsultationJobId;

                var responce = await _uacService.PatchConsultationData(jsonPatch, jobId);
            }

            await KtaService.CompleteActivityAsync(dto.SessionId, dto.Requester.Username, dto.ManagerDecision.Id, dto.ManagerDecision.Comment, dto.activity.Identity);

            return(dto);
        }
示例#13
0
        public async Task <SPSiteCreationDTO> ProcessRequest(SPSiteCreationDTO dto)
        {
            if (dto.activity == null)
            {
                dto.activity = await KtaService.TakeActivityAsync(dto.SessionId, dto.DomainModel.JobId, dto.NodeID, dto.EPC);
            }
            if (dto.activity.Identity.NodeId == dto.NodeID && (dto.activity.Identity.NodeId == ConstantNodes.NodeId_SPAdminNodeId || dto.activity.Identity.NodeId == ConstantNodes.NodeId_SPAdminExecutionNodeId))
            {
                Mapper.Map(dto.MembersList, dto.DomainModel.ITSPSiteMember);
                Mapper.Map(dto.ListsAndLibraries, dto.DomainModel.ITSPSiteListsAndLibraries);
                var entity = FindOneById(dto.DomainModel.Id);
                Mapper.Map(dto.DomainModel, entity);

                await UpdateRequest();
            }

            await KtaService.CompleteActivityAsync(dto.SessionId, dto.Requester.Username, dto.ManagerDecision.Id, dto.ManagerDecision.Comment, dto.activity.Identity);

            return(dto);
        }
        public async Task <ITResignationDTO> ProcessRequest(ITResignationDTO dto)
        {
            logger.LogDebug($"ProcessRequest method fired {dto.JobID} and {dto.NodeID}");

            logger.LogDebug($"TakeActivity method fired {dto.SessionId} and {dto.DomainModel.JobId} and { dto.NodeID} and {dto.EPC}");

            if (dto.activity == null)
            {
                dto.activity = await KtaService.TakeActivityAsync(dto.SessionId, dto.DomainModel.JobId, dto.NodeID, dto.EPC);
            }

            if (dto.activity.Identity.NodeId == dto.NodeID && (dto.activity.Identity.NodeId == ConstantNodes.NodeId_SharePoint || dto.activity.Identity.NodeId == ConstantNodes.NodeId_VPN || dto.activity.Identity.NodeId == ConstantNodes.NodeId_Email_AD ||
                                                               dto.activity.Identity.NodeId == ConstantNodes.NodeId_Software_Licenses || dto.activity.Identity.NodeId == ConstantNodes.NodeId_SFTP || dto.activity.Identity.NodeId == ConstantNodes.NodeId_ERP ||
                                                               dto.activity.Identity.NodeId == ConstantNodes.NodeId_FAX || dto.activity.Identity.NodeId == ConstantNodes.NodeId_TelePhone || dto.activity.Identity.NodeId == ConstantNodes.NodeId_Port || dto.activity.Identity.NodeId == ConstantNodes.NodeId_Muraslat))
            {
                await AddResignationItems(dto);
            }
            logger.LogDebug($"CompleteActivity method fired SessionId {dto.SessionId} and Username {dto.Requester.Username} and Id { dto.ManagerDecision.Id} and Comment {dto.ManagerDecision.Comment} and Identity {dto.activity.Identity}");

            await KtaService.CompleteActivityAsync(dto.SessionId, dto.Requester.Username, dto.ManagerDecision.Id, dto.ManagerDecision.Comment, dto.activity.Identity);

            return(dto);
        }
        public async Task <ConsultationDTO> ProcessRequest(ConsultationDTO dto)
        {
            logger.LogDebug("activity", (dto.activity));

            if (dto.activity == null)
            {
                dto.activity = await KtaService.TakeActivityAsync(dto.SessionId, dto.DomainModel.JobId, dto.NodeID, dto.EPC);
            }


            if (dto.activity.Identity.NodeId == dto.NodeID && dto.activity.Identity.NodeId == ConstantNodes.Research_Collaboration_Committee)
            {
                if (dto.ManagerDecision.Id == ((int)ConstantNodes.ConsultationDecisions.Approved).ToString())
                {
                    dto.DomainModel.Status = "Approved";;
                }
                else if (dto.ManagerDecision.Id == ((int)ConstantNodes.ConsultationDecisions.Rejected).ToString())
                {
                    dto.DomainModel.Status = "Rejected";
                }
            }
            else if (dto.activity.Identity.NodeId == dto.NodeID && (dto.activity.Identity.NodeId == ConstantNodes.UCP_Admin__NodeId || dto.activity.Identity.NodeId == ConstantNodes.DM_NodeID) && dto.ManagerDecision.Id == ((int)ConstantNodes.EnumITStatus.Rejected).ToString())
            {
                dto.DomainModel.Status = "Rejected";
            }

            var entity = FindOneById(dto.DomainModel.Id);

            if (dto.DomainModel.Id == entity.Id)
            {
                Mapper.Map(dto.DomainModel, entity);
            }

            await UpdateRequest();

            if (dto.DomainModel.Status == "Rejected")
            {
                await DeleteAvailability(dto);
            }

            var ConsulationCompletionViewModel = new EditConsultationDataViewModel();

            if (dto.DomainModel.Status != null)
            {
                Mapper.Map(dto.DomainModel, ConsulationCompletionViewModel);

                var jsonPatch = new JsonPatchDocument <EditConsultationDataViewModel>();
                jsonPatch.Replace(m => m.Status, ConsulationCompletionViewModel.Status);
                jsonPatch.Replace(m => m.IsConfidential, ConsulationCompletionViewModel.IsConfidential);
                logger.LogDebug("jsonPatch", (jsonPatch));

                var responce = await _uacService.PatchConsultationData(jsonPatch, dto.DomainModel.JobId);

                logger.LogDebug("responce", (responce));
            }
            if (dto.Attachement != null)
            {
                FileService.UploadRequestFiles(typeof(ConsultationDTO), dto,
                                               AppConfiguaraton.ConsultaionAttachementPath,
                                               dto.DomainModel.JobId, AppConfiguaraton.ConsultaionAttachementListName,
                                               string.Empty, dto.Requester.Username, multiTypes: false,
                                               uploadToSharepoint: true, multi: true);
            }
            await KtaService.CompleteActivityAsync(dto.SessionId, dto.Requester.Username, dto.ManagerDecision.Id, dto.ManagerDecision.Comment, dto.activity.Identity);

            return(dto);
        }