Esempio n. 1
0
        public async Task <ActionResult <Workpacket> > Search(string workpacketId)
        {
            Workpacket result = null;

            var p360loginResponse = await _p360AuthenticationService.LoginAsync(_p360LoginData.CurrentValue);

            try
            {
                result = await _workpacketSearchService.SearchAsync(p360loginResponse.SessionTokenHeader, workpacketId);
            }
            finally
            {
                var p360logoutResponse = await _p360AuthenticationService.LogoutAsync(p360loginResponse.SessionTokenHeader, _p360LoginData.CurrentValue);
            }
            return(result);
        }
Esempio n. 2
0
        /// <summary>
        /// Creates new workpacket based on existing workpacket with property WEB_ID equals to <paramref name="workpacketId"/>
        /// if one exists;
        /// The new workpacket will have all the same attributes as base attributes with whatever changes are in <paramref name="request"/>
        /// </summary>
        /// <param name="sessionTokenHeader"></param>
        /// <param name="workpacketId"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task <Workpacket> UpdateFromWorkpacketAsync(SessionTokenHeader sessionTokenHeader, string workpacketId, BaseForm request)
        {
            // search for existing workpacket to update from
            var workpacket = await _workpacketSearchService.SearchAsync(sessionTokenHeader, workpacketId);

            if (workpacket == null)
            {
                workpacket = await _workpacketSearchService.SearchArchiveAsync(sessionTokenHeader, (request.FormName, workpacketId));

                if (workpacket == null)
                {
                    throw new ArgumentException($"{nameof(workpacketId)} could not be found.");
                }
            }

            // map to p360 request
            WorkpacketUpdate[] workpacketUpdates = null;
            var dataUpdates = _workpacketUpdateDomainService.CreateFromData(request);

            if (request.Files != null && request.Files.Count > 0)
            {
                var fileUpdates = _workpacketUpdateDomainService.CreateFromFiles(new Files(request.Files));
                workpacketUpdates = new WorkpacketUpdate[fileUpdates.Length + 1];
                fileUpdates.CopyTo(workpacketUpdates, 0);
                workpacketUpdates[workpacketUpdates.Length - 1] = dataUpdates;
            }
            else
            {
                workpacketUpdates = new WorkpacketUpdate[] { dataUpdates };
            }

            // execute request
            var result = await Service.CreateWorkpacketAsync(
                sessionTokenHeader,
                _p360ServiceData.CurrentValue.ProcessName,
                _p360ServiceData.CurrentValue.NodeName,
                workpacketUpdates
                );

            await Service.ForwardWorkpacketAsync(sessionTokenHeader, result.CreateWorkpacketResult.Id);

            // map
            var response = _mapper.Map <Workpacket>(result.CreateWorkpacketResult);

            return(response);
        }
        public async Task <bool> DeleteWorkPacket(string workpacketId)
        {
            var p360loginResponse = await _p360AuthenticationService.LoginAsync(_p360LoginData.CurrentValue);

            bool response = false;

            try
            {
                var workpacketResult = await _workpacketSearchService.SearchAsync(p360loginResponse.SessionTokenHeader, workpacketId);

                response = await _workpacketDeletionService.DeleteWorkPacketAsync(p360loginResponse.SessionTokenHeader, workpacketResult.Id);
            }
            finally
            {
                var p360logoutResponse = await _p360AuthenticationService.LogoutAsync(p360loginResponse.SessionTokenHeader, _p360LoginData.CurrentValue);
            }

            return(response);
        }