protected internal virtual FilterQuery getQueryFromQueryParameters(MultivaluedMap <string, string> queryParameters)
{
ProcessEngine engine = ProcessEngine;
FilterQueryDto queryDto = new FilterQueryDto(ObjectMapper, queryParameters);
return(queryDto.toQuery(engine));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") private javax.ws.rs.core.MultivaluedMap<String, String> streamingHeader()
private MultivaluedMap <string, string> StreamingHeader()
{
MultivaluedMap <string, string> headers = mock(typeof(MultivaluedMap));
when(headers.getFirst(StreamingFormat_Fields.STREAM_HEADER)).thenReturn("true");
return(headers);
}
/// <exception cref="System.IO.IOException"/>
/// <exception cref="Javax.WS.RS.WebApplicationException"/>
public virtual IDictionary ReadFrom(Type type, Type genericType, Annotation.Annotation
[] annotations, MediaType mediaType, MultivaluedMap <string, string> httpHeaders,
InputStream entityStream)
{
ObjectMapper mapper = new ObjectMapper();
return(mapper.ReadValue(entityStream, type));
}
protected internal virtual string getReportResultAsCsv(UriInfo uriInfo)
{
IList <ReportResult> reports = queryHistoricProcessInstanceReport(uriInfo);
MultivaluedMap <string, string> queryParameters = uriInfo.QueryParameters;
string reportType = queryParameters.getFirst("reportType");
return(ReportResultToCsvConverter.convertReportResult(reports, reportType));
}
/// <exception cref="System.IO.IOException"/>
/// <exception cref="Javax.WS.RS.WebApplicationException"/>
public virtual void WriteTo(IDictionary map, Type aClass, Type type, Sharpen.Annotation.Annotation
[] annotations, MediaType mediaType, MultivaluedMap <string, object> stringObjectMultivaluedMap
, OutputStream outputStream)
{
TextWriter writer = new OutputStreamWriter(outputStream, Charsets.Utf8);
JSONObject.WriteJSONString(map, writer);
writer.Write(Enter);
writer.Flush();
}
public JaxRsResponse(ClientResponse response, string entity)
{
_status = response.Status;
_metaData = ExtractMetaData(response);
_headers = ExtractHeaders(response);
_location = response.Location;
_type = response.Type;
_data = entity;
response.close();
}
/// <exception cref="System.IO.IOException"/>
/// <exception cref="Javax.WS.RS.WebApplicationException"/>
public virtual void WriteTo(object obj, Type aClass, Type type, Annotation.Annotation
[] annotations, MediaType mediaType, MultivaluedMap <string, object> stringObjectMultivaluedMap
, OutputStream outputStream)
{
TextWriter writer = new OutputStreamWriter(outputStream, Extensions.GetEncoding
("UTF-8"));
ObjectMapper jsonMapper = new ObjectMapper();
jsonMapper.WriterWithDefaultPrettyPrinter().WriteValue(writer, obj);
}
public AbstractSearchQueryDto(ObjectMapper objectMapper, MultivaluedMap <string, string> queryParameters)
{
this.objectMapper = objectMapper;
foreach (KeyValuePair <string, IList <string> > param in queryParameters.entrySet())
{
string key = param.Key;
string value = param.Value.GetEnumerator().next();
this.setValueBasedOnAnnotation(key, value);
}
}
public ContainerRequest Filter(ContainerRequest request)
{
MultivaluedMap <string, string> parameters = request.GetQueryParameters();
if (ParamFilter.ContainsUpperCase(parameters.Keys))
{
//rebuild URI
URI lower = ParamFilter.RebuildQuery(request.GetRequestUri(), parameters);
request.SetUris(request.GetBaseUri(), lower);
}
return(request);
}
public OutputFormat OutputFormat(IList <MediaType> acceptable, URI baseUri, MultivaluedMap <string, string> requestHeaders)
{
RepresentationFormat format = ForHeaders(acceptable, requestHeaders);
if (format == null)
{
format = ForMediaTypes(acceptable);
}
if (format == null)
{
format = UseDefault(acceptable);
}
return(new OutputFormat(format, baseUri, ExtensionManager));
}
public virtual void CreateAUniqueRelationshipOrReturnFail__Create()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final String index = indexes.newInstance();
string index = _indexes.newInstance();
string key = "name";
string value = "Tobias";
_helper.createRelationshipIndex(index);
ResponseEntity response = GenConflict.get().expectedStatus(201).payloadType(MediaType.APPLICATION_JSON_TYPE).payload("{\"key\": \"" + key + "\", \"value\": \"" + value + "\", \"start\": \"" + _functionalTestHelper.nodeUri(_helper.createNode()) + "\", \"end\": \"" + _functionalTestHelper.nodeUri(_helper.createNode()) + "\", \"type\":\"" + MyRelationshipTypes.Knows + "\"}").post(_functionalTestHelper.relationshipIndexUri() + index + "?uniqueness=create_or_fail");
MultivaluedMap <string, string> headers = response.Response().Headers;
IDictionary <string, object> result = JsonHelper.jsonToMap(response.Entity());
assertEquals(result["indexed"], headers.getFirst("Location"));
}
/// <summary>Rebuild the URI query with lower case parameter names.</summary>
private static URI RebuildQuery(URI uri, MultivaluedMap <string, string> parameters
)
{
UriBuilder b = UriBuilder.FromUri(uri).ReplaceQuery(string.Empty);
foreach (KeyValuePair <string, IList <string> > e in parameters)
{
string key = StringUtils.ToLowerCase(e.Key);
foreach (string v in e.Value)
{
b = b.QueryParam(key, v);
}
}
return(b.Build());
}
private RepresentationFormat ForHeaders(IList <MediaType> acceptable, MultivaluedMap <string, string> requestHeaders)
{
if (requestHeaders == null)
{
return(null);
}
if (!ContainsType(acceptable, MediaType.APPLICATION_JSON_TYPE))
{
return(null);
}
string streamHeader = requestHeaders.getFirst(StreamingFormat_Fields.STREAM_HEADER);
if ("true".Equals(streamHeader, StringComparison.OrdinalIgnoreCase))
{
return(_formats[StreamingFormat_Fields.MediaType]);
}
return(null);
}
protected internal virtual void applyQueryParams(MetricsQuery query, UriInfo uriInfo)
{
MultivaluedMap <string, string> queryParameters = uriInfo.QueryParameters;
DateConverter dateConverter = new DateConverter();
dateConverter.ObjectMapper = objectMapper;
if (queryParameters.getFirst("startDate") != null)
{
DateTime startDate = dateConverter.convertQueryParameterToType(queryParameters.getFirst("startDate"));
query.startDate(startDate);
}
if (queryParameters.getFirst("endDate") != null)
{
DateTime endDate = dateConverter.convertQueryParameterToType(queryParameters.getFirst("endDate"));
query.endDate(endDate);
}
}
protected internal virtual void applyQueryParams(MetricsQuery query, MultivaluedMap <string, string> queryParameters)
{
DateConverter dateConverter = new DateConverter();
dateConverter.ObjectMapper = objectMapper;
if (queryParameters.getFirst(QUERY_PARAM_START_DATE) != null)
{
DateTime startDate = dateConverter.convertQueryParameterToType(queryParameters.getFirst(QUERY_PARAM_START_DATE));
query.startDate(startDate);
}
if (queryParameters.getFirst(QUERY_PARAM_END_DATE) != null)
{
DateTime endDate = dateConverter.convertQueryParameterToType(queryParameters.getFirst(QUERY_PARAM_END_DATE));
query.endDate(endDate);
}
IntegerConverter intConverter = new IntegerConverter();
intConverter.ObjectMapper = objectMapper;
if (queryParameters.getFirst(QUERY_PARAM_FIRST_RESULT) != null)
{
int firstResult = intConverter.convertQueryParameterToType(queryParameters.getFirst(QUERY_PARAM_FIRST_RESULT)).Value;
query.offset(firstResult);
}
if (queryParameters.getFirst(QUERY_PARAM_MAX_RESULTS) != null)
{
int maxResults = intConverter.convertQueryParameterToType(queryParameters.getFirst(QUERY_PARAM_MAX_RESULTS)).Value;
query.limit(maxResults);
}
if (queryParameters.getFirst(QUERY_PARAM_AGG_BY_REPORTER) != null)
{
query.aggregateByReporter();
}
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: private <T> java.util.Map<String, String> getHeaders(final javax.ws.rs.core.MultivaluedMap<String, T> headers, final java.util.List<String> filter, final java.util.Collection<String> additionalFilter)
private IDictionary <string, string> GetHeaders <T>(MultivaluedMap <string, T> headers, IList <string> filter, ICollection <string> additionalFilter)
{
IDictionary <string, string> filteredHeaders = new SortedDictionary <string, string>();
foreach (KeyValuePair <string, IList <T> > header in headers.entrySet())
{
string key = header.Key;
if (filter.Contains(key) || additionalFilter.Contains(key))
{
string values = "";
foreach (T value in header.Value)
{
if (values.Length > 0)
{
values += ", ";
}
values += value.ToString();
}
filteredHeaders[key] = values;
}
}
return(filteredHeaders);
}
public virtual IList <MetricsIntervalResultDto> interval(UriInfo uriInfo)
{
MultivaluedMap <string, string> queryParameters = uriInfo.QueryParameters;
MetricsQuery query = processEngine.ManagementService.createMetricsQuery().name(queryParameters.getFirst(QUERY_PARAM_NAME)).reporter(queryParameters.getFirst(QUERY_PARAM_REPORTER));
applyQueryParams(query, queryParameters);
IList <MetricIntervalValue> metrics;
LongConverter longConverter = new LongConverter();
longConverter.ObjectMapper = objectMapper;
if (queryParameters.getFirst(QUERY_PARAM_INTERVAL) != null)
{
long interval = longConverter.convertQueryParameterToType(queryParameters.getFirst(QUERY_PARAM_INTERVAL)).Value;
metrics = query.interval(interval);
}
else
{
metrics = query.interval();
}
return(convertToDtos(metrics));
}
public CaseExecutionQueryDto(ObjectMapper objectMapper, MultivaluedMap <string, string> queryParameters) : base(objectMapper, queryParameters)
{
}
public ExternalTaskQueryDto(ObjectMapper objectMapper, MultivaluedMap <string, string> queryParameters) : base(objectMapper, queryParameters)
{
}
public CleanableHistoricDecisionInstanceReportDto(ObjectMapper objectMapper, MultivaluedMap <string, string> queryParameters) : base(objectMapper, queryParameters)
{
}
protected internal virtual bool isQueryPropertyEnabled(UriInfo uriInfo, string property)
{
MultivaluedMap <string, string> queryParams = uriInfo.QueryParameters;
return(queryParams.containsKey(property) && queryParams.get(property).size() > 0 && "true".Equals(queryParams.get(property).get(0)));
}
public ProcessInstanceQueryDto(ObjectMapper objectMapper, MultivaluedMap <string, string> queryParameters) : base(objectMapper, queryParameters)
{
}
public AbstractQueryDto(ObjectMapper objectMapper, MultivaluedMap <string, string> queryParameters) : base(objectMapper, queryParameters)
{
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public MultipartFormData readFrom(Class<MultipartFormData> type, Type genericType, Annotation[] annotations, javax.ws.rs.core.MediaType mediaType, javax.ws.rs.core.MultivaluedMap<String, String> httpHeaders, java.io.InputStream entityStream) throws java.io.IOException, javax.ws.rs.WebApplicationException
public virtual MultipartFormData readFrom(Type type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap <string, string> httpHeaders, Stream entityStream)
{
type = typeof(MultipartFormData);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final MultipartFormData multipartFormData = createMultipartFormDataInstance();
MultipartFormData multipartFormData = createMultipartFormDataInstance();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.apache.commons.fileupload.FileUpload fileUpload = createFileUploadInstance();
FileUpload fileUpload = createFileUploadInstance();
string contentType = httpHeaders.getFirst("content-type");
RestMultipartRequestContext requestContext = createRequestContext(entityStream, contentType);
// parse the request (populates the multipartFormData)
parseRequest(multipartFormData, fileUpload, requestContext);
return(multipartFormData);
}
public UserOperationLogQueryDto(ObjectMapper objectMapper, MultivaluedMap <string, string> queryParameters) : base(objectMapper, queryParameters)
{
}
public JobDefinitionQueryDto(ObjectMapper objectMapper, MultivaluedMap <string, string> queryParameters) : base(objectMapper, queryParameters)
{
}
public HistoricVariableInstanceQueryDto(ObjectMapper objectMapper, MultivaluedMap <string, string> queryParameters) : base(objectMapper, queryParameters)
{
}
public HistoricJobLogQueryDto(ObjectMapper objectMapper, MultivaluedMap <string, string> queryParameters) : base(objectMapper, queryParameters)
{
}
public virtual IList <HistoricActivityStatisticsDto> getHistoricActivityStatistics(UriInfo uriInfo, string processDefinitionId, bool?includeCanceled, bool?includeFinished, bool?includeCompleteScope, string sortBy, string sortOrder)
{
HistoryService historyService = processEngine.HistoryService;
HistoricActivityStatisticsQuery query = historyService.createHistoricActivityStatisticsQuery(processDefinitionId);
if (includeCanceled != null && includeCanceled)
{
query.includeCanceled();
}
if (includeFinished != null && includeFinished)
{
query.includeFinished();
}
if (includeCompleteScope != null && includeCompleteScope)
{
query.includeCompleteScope();
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final javax.ws.rs.core.MultivaluedMap<String, String> queryParameters = uriInfo.getQueryParameters();
MultivaluedMap <string, string> queryParameters = uriInfo.QueryParameters;
DateConverter dateConverter = new DateConverter();
dateConverter.ObjectMapper = objectMapper;
if (queryParameters.getFirst(QUERY_PARAM_STARTED_AFTER) != null)
{
DateTime startedAfter = dateConverter.convertQueryParameterToType(queryParameters.getFirst(QUERY_PARAM_STARTED_AFTER));
query.startedAfter(startedAfter);
}
if (queryParameters.getFirst(QUERY_PARAM_STARTED_BEFORE) != null)
{
DateTime startedBefore = dateConverter.convertQueryParameterToType(queryParameters.getFirst(QUERY_PARAM_STARTED_BEFORE));
query.startedBefore(startedBefore);
}
if (queryParameters.getFirst(QUERY_PARAM_FINISHED_AFTER) != null)
{
DateTime finishedAfter = dateConverter.convertQueryParameterToType(queryParameters.getFirst(QUERY_PARAM_FINISHED_AFTER));
query.finishedAfter(finishedAfter);
}
if (queryParameters.getFirst(QUERY_PARAM_FINISHED_BEFORE) != null)
{
DateTime finishedBefore = dateConverter.convertQueryParameterToType(queryParameters.getFirst(QUERY_PARAM_FINISHED_BEFORE));
query.finishedBefore(finishedBefore);
}
setSortOptions(query, sortOrder, sortBy);
IList <HistoricActivityStatisticsDto> result = new List <HistoricActivityStatisticsDto>();
IList <HistoricActivityStatistics> statistics = query.list();
foreach (HistoricActivityStatistics currentStatistics in statistics)
{
result.Add(HistoricActivityStatisticsDto.fromHistoricActivityStatistics(currentStatistics));
}
return(result);
}
public CleanableHistoricBatchReportDto(ObjectMapper objectMapper, MultivaluedMap <string, string> queryParameters) : base(objectMapper, queryParameters)
{
}
