/// <summary>
/// Creates a new workpacket using request and existing workpacket
/// by updating existing workpacket with request into new workpacket
/// </summary>
/// <param name="sessionTokenHeader">p360 login session</param>
/// <param name="workpacket">model workpacket retrieved from p360</param>
/// <param name="request">request with updates to apply to workpacket</param>
/// <returns></returns>
public async Task <Workpacket> CreateFromWorkpacketAsync(SessionTokenHeader sessionTokenHeader, string workpacketId, Workpacket workpacket, UpdateRequest request)
{
// Create merged request from workpacket and request
var fileUpdates = _workpacketUpdateDomainService.CreateFromFiles(new Files(workpacket?.Folder?.FolderItems).Add(request.GetFiles()));
var dataUpdates = _workpacketUpdateDomainService.CreateFromDataAndWorkpacket(workpacketId, request, workpacket);
// create p360 request
WorkpacketUpdate[] workpacketUpdates = new WorkpacketUpdate[fileUpdates.Length + 1];
fileUpdates.CopyTo(workpacketUpdates, 0);
workpacketUpdates[workpacketUpdates.Length - 1] = 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);
}
/// <summary>
/// Searches P360 worklists for workpacket with WEB_ID property equals to <paramref name="workpacketId"/>
/// </summary>
/// <param name="sessionTokenHeader"></param>
/// <param name="workpacketId"></param>
/// <returns></returns>
public async Task <P360FormService.Models.Responses.Workpacket> SearchAsync(SessionTokenHeader sessionTokenHeader, string workpacketId)
{
P360FormService.Models.Responses.Workpacket result = null;
var searchSettings = _p360SearchDomainService.CreateSearchCriteria(new Dictionary <string, string> {
{ "DOCUMENT_NAME", $"={workpacketId}" }
});
// search
var searchWorklistResponses = new List <RecordSet>();
var worklists = await Service.GetAvailableWorklistNamesAsync(sessionTokenHeader);
foreach (var worklist in worklists.GetAvailableWorklistNamesResult)
{
var searchResult = await Service.SearchWorklistAsync(sessionTokenHeader, worklist.Name, searchSettings);
if (searchResult?.SearchWorklistResult?.Rows != null && searchResult.SearchWorklistResult.Rows.Count() > 0)
{
// filter to account for P360 bug whereas if a workpacket is searched by a field it doesn't have it will be a valid match.
if (searchResult.SearchWorklistResult.Rows.SelectMany(r => r.Data).Any(d => d.ToString() == workpacketId))
{
searchWorklistResponses.Add(searchResult.SearchWorklistResult);
}
}
}
if (searchWorklistResponses == null || searchWorklistResponses.Count == 0)
{
throw new NotFoundException($"Search for {workpacketId} returned no results.", workpacketId);
}
// open
var workPackets = new ConcurrentBag <Workpacket>();
var tasks = searchWorklistResponses.SelectMany(swr => swr.Rows).Select(async worklistRow =>
{
var wp = await Service.OpenWorkpacketByIdAsync(sessionTokenHeader, worklistRow.RowId, WorklistOpenMode.ReadOnly, true);
if (wp != null)
{
workPackets.Add(wp.OpenWorkpacketByIdResult);
}
});
await Task.WhenAll(tasks);
// take most recent one
var mostRecentWorkpacket = workPackets.OrderByDescending(w => w.GetProperty <DateTime>("SCANNED_DATE")).FirstOrDefault();
if (mostRecentWorkpacket != null)
{
result = _mapper.Map <P360FormService.Models.Responses.Workpacket>(mostRecentWorkpacket);
}
return(result);
}
public async Task <bool> DeleteWorkPacketAsync(SessionTokenHeader sessionTokenHeader, string workpacketId)
{
try
{
var result = await Service.DeleteWorkpacketAsync(sessionTokenHeader, workpacketId);
return(true);
}
catch
{
return(false);
}
}
/// <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);
}
/// <summary>
/// Performs in-place update of an existing workpacket with WEB_ID property equals to <paramref name="workpacketId"/>
/// if workpacket exists
/// </summary>
/// <param name="sessionTokenHeader"></param>
/// <param name="workpacketId"></param>
/// <param name="request">Changes/Updates to perform to workpacket</param>
/// <returns></returns>
public async Task <AttributeValidationError[]> UpdateWorkpacketAsync(SessionTokenHeader sessionTokenHeader, string workpacketId, WorkpacketBaseRequest request)
{
UpdateAndForwardWorkpacketResponse result = null;
List <WorkpacketUpdate> workpacketUpdates = new List <WorkpacketUpdate>();
// add data
workpacketUpdates.Add(
new SetPropertiesUpdate
{
Properties = request.FormData.GetType().GetProperties().Select(p => new Property {
Name = p.Name, Value = p.GetValue(request.FormData)
}).ToArray(),
Target = PropertyUpdateTarget.FolderAttributes
});
var updateWorkpacketResponse = await Service.UpdateWorkpacketAsync(sessionTokenHeader, workpacketId, workpacketUpdates.ToArray());
result = await Service.UpdateAndForwardWorkpacketAsync(sessionTokenHeader, workpacketId, workpacketUpdates.ToArray(), ValidationOption.ValidAttributes);
return(result?.UpdateAndForwardWorkpacketResult);
}
public async Task <Workpacket> CreateAsync(SessionTokenHeader sessionTokenHeader, BaseForm request)
{
//-Adds a dummy file if wp doesn't contain file attachments
if (!request.Files.Any() && _dummyFileInformation.CurrentValue.EnableDummyFile)
{
request.Files.Add(CreateDummyFile(_dummyFileInformation.CurrentValue.FileName));
}
// convert to p360 input
var fileUpdates = _workpacketUpdateDomainService.CreateFromFiles(request.GetFiles());
var dataUpdates = _workpacketUpdateDomainService.CreateFromData(request);
// create p360 request
WorkpacketUpdate[] workpacketUpdates = new WorkpacketUpdate[fileUpdates.Length + 1];
fileUpdates.CopyTo(workpacketUpdates, 0);
workpacketUpdates[workpacketUpdates.Length - 1] = 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);
if (response?.Folder?.Attributes?.Properties?.FirstOrDefault(x => x.Name == "DOCUMENT_NAME") != null)
{
response.WorkpacketId = response?.Folder?.Attributes?.Properties?.FirstOrDefault(x => x.Name == "DOCUMENT_NAME").Value.ToString();
}
else
{
response.WorkpacketId = response?.TrackingId.ToString();
}
return(response);
}
public async Task <bool> CloseWorkpacketAsync(SessionTokenHeader sessionTokenHeader, Workpacket workpacket)
{
await Service.CloseWorkpacketAsync(sessionTokenHeader, workpacket.Id, true);
return(true);
}
public async Task <LogoutResponse> LogoutAsync(SessionTokenHeader sessionTokenHeader, P360LoginData p360LoginData)
{
var service = new P360WebReference.ViewStarServiceSoapClient(EndpointConfiguration.ViewStarServiceSoap, p360LoginData.Url);
return(await service.LogoutAsync(sessionTokenHeader));
}
/// <summary>
/// Searches P360 worklists for workpacket with property ACCOUNT_NUMBER equals to <paramref name="account"/>
/// </summary>
/// <param name="sessionTokenHeader"></param>
/// <param name="account"></param>
/// <returns></returns>
public async Task <List <P360FormService.Models.Responses.Workpacket> > SearchByAccountAsync(SessionTokenHeader sessionTokenHeader, long account)
{
var searchSettings = new SearchSettings
{
SkipCount = 0,
Limit = 100,
FullTextScope = FullTextScope.None,
Settings = new SearchSetting[]
{
new SearchSetting
{
FieldName = "ACCOUNT_NUMBER",
Condition = $"={account}"
}
}
};
// get search results
List <RecordSet> recordSets = new List <RecordSet>();
var searchWorklistResponses = new ConcurrentBag <RecordSet>();
var worklists = await Service.GetAvailableWorklistNamesAsync(sessionTokenHeader);
var searchTasks = worklists.GetAvailableWorklistNamesResult.Select(async worklist =>
{
var searchResult = await Service.SearchWorklistAsync(sessionTokenHeader, worklist.Name, searchSettings);
if (searchResult?.SearchWorklistResult?.Rows != null && searchResult.SearchWorklistResult.Rows.Count() > 0)
{
searchWorklistResponses.Add(searchResult.SearchWorklistResult);
}
});
await Task.WhenAll(searchTasks);
// get workpackets from search results
var workpackets = new List <CreditOne.P360FormService.Models.Responses.Workpacket>();
foreach (var worklistRow in searchWorklistResponses.SelectMany(swr => swr.Rows))
{
var wp = await Service.OpenWorkpacketByIdAsync(sessionTokenHeader, worklistRow.RowId, WorklistOpenMode.ReadWrite, true);
if (wp != null)
{
workpackets.Add(_mapper.Map <CreditOne.P360FormService.Models.Responses.Workpacket>(wp.OpenWorkpacketByIdResult));
}
}
return(workpackets);
}
/// <summary> /// Search both archive and worklists for workpacket /// </summary> /// <param name="sessionTokenHeader">sessionTokenHeader used for login</param> /// <param name="workpacketId">WEB_ID property of workpacket</param> /// <returns></returns> public async Task <P360FormService.Models.Responses.Workpacket> SearchAllAsync(SessionTokenHeader sessionTokenHeader, (string formName, string workpacketId) request)
/// <summary>
/// Searches P360 archives for workpackets with ACCOUNT_NUMBER property equals to <paramref name="creditAccountId"/>
/// </summary>
/// <param name="sessionTokenHeader"></param>
/// <param name="creditAccountId"></param>
/// <returns></returns>
public async Task <P360FormService.Models.Responses.Workpacket> SearchArchiveByAccountAsync(SessionTokenHeader sessionTokenHeader, long creditAccountId)
{
var searchSettings = _p360SearchDomainService.CreateSearchCriteria(new Dictionary <string, string> {
{ "ACCOUNT_NUMBER", $"={creditAccountId}" }
});
var searchResult = await Service.SearchCatalogAsync(sessionTokenHeader, "TS_A_GLOBAL_SEARCH_C", searchSettings, SearchScope.DocumentsAndData);
if (searchResult.SearchCatalogResult.Rows.Count() > 0)
{
var catalogItem = await Service.GetCatalogItemAsync(sessionTokenHeader, searchResult.SearchCatalogResult.Rows[0].RowId, true);
return(_mapper.Map <P360FormService.Models.Responses.Workpacket>(catalogItem.GetCatalogItemResult));
}
return(null);
}
