public async Task <IActionResult> StartFileUpload(string hash)
{
if (hash == null)
{
return(BadRequest());
}
NewUserData data = _context.NewUserData.FirstOrDefault(ud => ud.Hash.Equals(hash));
HttpResponseMessage taskResponse2 = await client.GetAsync($"{_configuration["url"]}/task?processDefinitionId={data.processDefinitionId}&&processInstanceId={data.processInstanceId}");
Task <string> jsonStringResult_22 = taskResponse2.Content.ReadAsStringAsync();
List <CamundaTask> tasks = JsonConvert.DeserializeObject <List <CamundaTask> >(jsonStringResult_22.Result);
if (tasks.Count == 0)
{
return(BadRequest());
}
HttpResponseMessage taskFormResponse = await client.GetAsync($"{_configuration["url"]}/task/{tasks[0].id}/form-variables");
Task <string> jsonStringResult = taskFormResponse.Content.ReadAsStringAsync();
FormVariables vars2 = JsonConvert.DeserializeObject <FormVariables>(jsonStringResult.Result);
return(Ok(ParseAndGetConstraints(vars2, data.processDefinitionId, data.processInstanceId, tasks[0].id, null)));
}
private void btVariables_Click(object sender, EventArgs e)
{
var formVariables = new FormVariables();
DialogResult dr = formVariables.ShowDialog();
if (dr == DialogResult.OK)
{
_focusedTextBox.Paste("{" + formVariables.ChosenVariable.UniqueName + "}");
}
}
private void buttonAddRuleImageFile_Click(object sender, EventArgs e)
{
DataGridViewRow row = new DataGridViewRow();
FormVariables formVaiables = new FormVariables();
for (int i = 0; i < map.LayerCount; i++)
{
string layerName = map.get_Layer(i).Name;
if ((layerName != trainingStartImageName) && (layerName != trainingEndImageName))
{
formVaiables.ListViewControl.Items.Add(layerName);
}
}
if (formVaiables.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
for (int i = 0; i < formVaiables.ListViewControl.SelectedItems.Count; i++)
{
dataGridViewVariableDatas.Rows.Add(formVaiables.ListViewControl.SelectedItems[i].Text);
}
}
}
public void SetUp()
{
variables = new FormVariables();
AddStuff();
}
private string ParseAndGetConstraints(FormVariables vars, string processDefinitionId, string processInstanceId, string taskId, List <string> genreNames)
{
//Parsiranjee XML-a za validaciju
Task <HttpResponseMessage> xml = client.GetAsync($"{_configuration["url"]}/process-definition/{processDefinitionId}/xml");
Task <string> xmlResullt = xml.Result.Content.ReadAsStringAsync();
CamundaDiagram result = JsonConvert.DeserializeObject <CamundaDiagram>(xmlResullt.Result);
XmlDocument doc = new XmlDocument();
doc.LoadXml(result.bpmn20Xml);
XmlNodeList nodes = doc.GetElementsByTagName("camunda:formField");
foreach (var prop in vars.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
foreach (XmlNode node in nodes)
{
if (node.OuterXml.Contains(prop.PropertyType.Name))
{
XmlNodeList xmlNodes = node.ChildNodes;
foreach (XmlNode xmlNode in xmlNodes)
{
CamundaConstraint camundaConstraint = new CamundaConstraint();
if (xmlNode.InnerXml.Contains("required"))
{
camundaConstraint.Required = true;
}
if (xmlNode.InnerXml.Contains("minlength"))
{
camundaConstraint.MinLength = xmlNode.InnerXml.Substring(xmlNode.InnerXml.LastIndexOf("minlength\" config=\"") + "minlength\" config=\"".Length, 1);
}
if (xmlNode.InnerXml.Contains("maxlength"))
{
int startIndex = xmlNode.InnerXml.IndexOf(""") + """.Length;
int endIndex = xmlNode.InnerXml.LastIndexOf(""");
camundaConstraint.MaxLength = xmlNode.InnerXml.Substring(startIndex, endIndex - startIndex);
}
if (xmlNode.InnerXml.Contains("min"))
{
camundaConstraint.Min = xmlNode.InnerXml.Substring(xmlNode.InnerXml.LastIndexOf("min\" config=\"") + "min\" config=\"".Length, 1);
}
if (prop.PropertyType.Name.Equals("FirstName"))
{
if (vars.firstName != null)
{
vars.firstName.value = camundaConstraint;
}
}
if (prop.PropertyType.Name.Equals("LastName"))
{
if (vars.lastName != null)
{
vars.lastName.value = camundaConstraint;
}
}
if (prop.PropertyType.Name.Equals("Email"))
{
if (vars.email != null)
{
camundaConstraint.value = camundaConstraint.MaxLength;
vars.email.value = camundaConstraint;
}
}
if (prop.PropertyType.Name.Equals("Password"))
{
if (vars.password != null)
{
vars.password.value = camundaConstraint;
}
}
if (prop.PropertyType.Name.Equals("Genre"))
{
if (vars.genre != null)
{
camundaConstraint.value = genreNames;
vars.genre.value = camundaConstraint;
}
}
if (prop.PropertyType.Name.Equals("Country"))
{
if (vars.country != null)
{
camundaConstraint.value = CountryService.GetCountryList();
vars.country.value = camundaConstraint;
}
}
if (prop.PropertyType.Name.Equals("City"))
{
if (vars.city != null)
{
vars.city.value = camundaConstraint;
}
}
if (prop.PropertyType.Name.Equals("CamundaFile"))
{
if (vars.camundaFile != null)
{
vars.camundaFile.value = camundaConstraint;
}
}
vars.TaskId = taskId;
vars.ProcessDefinitionId = processDefinitionId;
vars.ProcessInstanceId = processInstanceId;
}
}
}
}
var props = new Dictionary <string, object>();
foreach (var prop in vars.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
props.Add(prop.Name, prop.GetValue(vars, null));
}
return(JsonConvert.SerializeObject(props.ToArray()));
}
/// <summary>
/// Processes Update requests
/// </summary>
/// <param name="context">HTTP Context</param>
public void ProcessUpdateRequest(HttpServerContext context)
{
if (this._config.UpdateProcessor == null)
{
context.Response.StatusCode = (int)HttpStatusCode.NotImplemented;
return;
}
//Try and parse the Form Variables
FormVariables form = new FormVariables(context);
if (!form.IsValid)
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
if (context.Request.HttpMethod.Equals("OPTIONS"))
{
context.Response.StatusCode = (int)HttpStatusCode.NotImplemented;
return;
//TODO: Support Service Description?
////OPTIONS requests always result in the Service Description document
//IGraph svcDescrip = SparqlServiceDescriber.GetServiceDescription(context, this._config, UriFactory.Create(context.Request.Url.AbsoluteUri), ServiceDescriptionType.Update);
//HandlerHelper.SendToClient(context, svcDescrip, this._config);
//return;
}
//See if there has been an update submitted
String updateText = null;
if (context.Request.ContentType != null)
{
if (context.Request.ContentType.Equals(MimeTypesHelper.WWWFormURLEncoded))
{
updateText = form["update"];
}
else if (context.Request.ContentType.Equals(MimeTypesHelper.SparqlUpdate))
{
updateText = new StreamReader(context.Request.InputStream).ReadToEnd();
}
}
else
{
updateText = form["update"];
}
//If no Update sent either show Update Form or give a HTTP 400 response
if (updateText == null || updateText.Equals(String.Empty))
{
if (this._config.ShowUpdateForm)
{
this.ShowUpdateForm(context);
return;
}
else
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
}
//Get Other options associated with this update
List <String> userDefaultGraphs = new List <String>();
List <String> userNamedGraphs = new List <String>();
//Get the USING URIs (if any)
if (context.Request.QueryString["using-graph-uri"] != null)
{
userDefaultGraphs.AddRange(context.Request.QueryString.GetValues("using-graph-uri"));
}
else if (form["using-graph-uri"] != null)
{
userDefaultGraphs.AddRange(form.GetValues("using-graph-uri"));
}
//Get the USING NAMED URIs (if any)
if (context.Request.QueryString["using-named-graph-uri"] != null)
{
userNamedGraphs.AddRange(context.Request.QueryString.GetValues("using-named-graph-uri"));
}
else if (form["using-named-graph-uri"] != null)
{
userNamedGraphs.AddRange(form.GetValues("using-named-graph-uri"));
}
try
{
//Now we're going to parse the Updates
SparqlUpdateParser parser = new SparqlUpdateParser();
parser.ExpressionFactories = this._config.ExpressionFactories;
SparqlUpdateCommandSet commands = parser.ParseFromString(updateText);
//TODO: Support Authentication?
////Check whether we need to use authentication
////If there are no user groups then no authentication is in use so we default to authenticated with no per-action authentication needed
//bool isAuth = true, requireActionAuth = false;
//if (this._config.UserGroups.Any())
//{
// //If we have user
// isAuth = HandlerHelper.IsAuthenticated(context, this._config.UserGroups);
// requireActionAuth = true;
//}
//if (!isAuth) return;
//First check actions to see whether they are all permissible and apply USING/USING NAMED paramaters
foreach (SparqlUpdateCommand cmd in commands.Commands)
{
//TODO: Support Authentication?
////Authenticate each action
//bool actionAuth = true;
//if (requireActionAuth) actionAuth = HandlerHelper.IsAuthenticated(context, this._config.UserGroups, this.GetUpdatePermissionAction(cmd));
//if (!actionAuth)
//{
// throw new SparqlUpdatePermissionException("You are not authorised to perform the " + this.GetUpdatePermissionAction(cmd) + " action");
//}
//Check whether we need to (and are permitted to) apply USING/USING NAMED parameters
if (userDefaultGraphs.Count > 0 || userNamedGraphs.Count > 0)
{
BaseModificationCommand modify = cmd as BaseModificationCommand;
if (modify != null)
{
if (modify.GraphUri != null || modify.UsingUris.Any() || modify.UsingNamedUris.Any())
{
//Invalid if a command already has a WITH/USING/USING NAMED
throw new SparqlUpdateMalformedException("A command in your update request contains a WITH/USING/USING NAMED clause but you have also specified one/both of the using-graph-uri or using-named-graph-uri parameters which is not permitted by the SPARQL Protocol");
}
else
{
//Otherwise go ahead and apply
userDefaultGraphs.ForEach(u => modify.AddUsingUri(UriFactory.Create(u)));
userNamedGraphs.ForEach(u => modify.AddUsingNamedUri(UriFactory.Create(u)));
}
}
}
}
//Then assuming we got here this means all our actions are permitted so now we can process the updates
this._config.UpdateProcessor.ProcessCommandSet(commands);
//Flush outstanding changes
this._config.UpdateProcessor.Flush();
}
catch (RdfParseException parseEx)
{
HandleUpdateErrors(context, "Parsing Error", updateText, parseEx, (int)HttpStatusCode.BadRequest);
}
catch (SparqlUpdatePermissionException permEx)
{
HandleUpdateErrors(context, "Permissions Error", updateText, permEx, (int)HttpStatusCode.Forbidden);
}
catch (SparqlUpdateMalformedException malEx)
{
HandleUpdateErrors(context, "Malformed Update Error", updateText, malEx, (int)HttpStatusCode.BadRequest);
}
catch (SparqlUpdateException updateEx)
{
HandleUpdateErrors(context, "Update Error", updateText, updateEx);
}
catch (RdfException rdfEx)
{
HandleUpdateErrors(context, "RDF Error", updateText, rdfEx);
}
catch (Exception ex)
{
HandleUpdateErrors(context, "Error", updateText, ex);
}
}
/// <summary>
/// Processes Query requests
/// </summary>
/// <param name="context">HTTP Context</param>
public void ProcessQueryRequest(HttpServerContext context)
{
if (this._config.QueryProcessor == null)
{
context.Response.StatusCode = (int)HttpStatusCode.NotImplemented;
return;
}
//Try and parse the Form Variables
FormVariables form = new FormVariables(context);
if (!form.IsValid)
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
if (context.Request.HttpMethod.Equals("OPTIONS"))
{
context.Response.StatusCode = (int)HttpStatusCode.NotImplemented;
return;
//TODO: Support Service Description?
////OPTIONS requests always result in the Service Description document
//IGraph svcDescrip = SparqlServiceDescriber.GetServiceDescription(context, this._config, UriFactory.Create(context.Request.Url.AbsoluteUri), ServiceDescriptionType.Query);
//HandlerHelper.SendToClient(context, svcDescrip, this._config);
//return;
}
//See if there has been an query submitted
String queryText = context.Request.QueryString["query"];
if (queryText == null || queryText.Equals(String.Empty))
{
if (context.Request.ContentType != null)
{
if (context.Request.ContentType.Equals(MimeTypesHelper.WWWFormURLEncoded))
{
queryText = form["query"];
}
else if (context.Request.ContentType.Equals(MimeTypesHelper.SparqlQuery))
{
queryText = new StreamReader(context.Request.InputStream).ReadToEnd();
}
}
else
{
queryText = form["query"];
}
}
//If no Query sent either show Query Form or give a HTTP 400 response
if (queryText == null || queryText.Equals(String.Empty))
{
if (this._config.ShowQueryForm)
{
this.ShowQueryForm(context);
return;
}
else
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
}
//Get Other options associated with this query
List <String> userDefaultGraphs = new List <String>();
List <String> userNamedGraphs = new List <String>();
long timeout = 0;
bool partialResults = this._config.DefaultPartialResults;
//Get the Default Graph URIs (if any)
if (context.Request.QueryString["default-graph-uri"] != null)
{
userDefaultGraphs.AddRange(context.Request.QueryString.GetValues("default-graph-uri"));
}
else if (form["default-graph-uri"] != null)
{
userDefaultGraphs.AddRange(form.GetValues("default-graph-uri"));
}
//Get the Named Graph URIs (if any)
if (context.Request.QueryString["named-graph-uri"] != null)
{
userNamedGraphs.AddRange(context.Request.QueryString.GetValues("named-graph-uri"));
}
else if (form["named-graph-uri"] != null)
{
userNamedGraphs.AddRange(form.GetValues("named-graph-uri"));
}
//Get Timeout setting (if any)
if (context.Request.QueryString["timeout"] != null)
{
if (!Int64.TryParse(context.Request.QueryString["timeout"], out timeout))
{
timeout = this._config.DefaultTimeout;
}
}
else if (form["timeout"] != null)
{
if (!Int64.TryParse(form["timeout"], out timeout))
{
timeout = this._config.DefaultTimeout;
}
}
//Get Partial Results Setting (if any);
if (context.Request.QueryString["partialResults"] != null)
{
if (!Boolean.TryParse(context.Request.QueryString["partialResults"], out partialResults))
{
partialResults = this._config.DefaultPartialResults;
}
}
else if (form["partialResults"] != null)
{
if (!Boolean.TryParse(form["partialResults"], out partialResults))
{
partialResults = this._config.DefaultPartialResults;
}
}
try
{
//Now we're going to parse the Query
SparqlQueryParser parser = new SparqlQueryParser(this._config.QuerySyntax);
parser.ExpressionFactories = this._config.ExpressionFactories;
parser.QueryOptimiser = this._config.QueryOptimiser;
SparqlQuery query = parser.ParseFromString(queryText);
query.AlgebraOptimisers = this._config.AlgebraOptimisers;
query.PropertyFunctionFactories = this._config.PropertyFunctionFactories;
//TODO: Support Authentication?
////Check whether we need to use authentication
////If there are no user groups then no authentication is in use so we default to authenticated with no per-action authentication needed
//bool isAuth = true, requireActionAuth = false;
//if (this._config.UserGroups.Any())
//{
// //If we have user
// isAuth = HandlerHelper.IsAuthenticated(context, this._config.UserGroups);
// requireActionAuth = true;
//}
//if (!isAuth) return;
////Is this user allowed to make this kind of query?
//if (requireActionAuth) HandlerHelper.IsAuthenticated(context, this._config.UserGroups, this.GetQueryPermissionAction(query));
//Set the Default Graph URIs (if any)
if (userDefaultGraphs.Count > 0)
{
//Default Graph Uri specified by default-graph-uri parameter or Web.config settings
foreach (String userDefaultGraph in userDefaultGraphs)
{
if (!userDefaultGraph.Equals(String.Empty))
{
query.AddDefaultGraph(UriFactory.Create(userDefaultGraph));
}
}
}
else if (!this._config.DefaultGraphURI.Equals(String.Empty))
{
//Only applies if the Query doesn't specify any Default Graph
if (!query.DefaultGraphs.Any())
{
query.AddDefaultGraph(UriFactory.Create(this._config.DefaultGraphURI));
}
}
//Set the Named Graph URIs (if any)
if (userNamedGraphs.Count > 0)
{
foreach (String userNamedGraph in userNamedGraphs)
{
if (!userNamedGraph.Equals(String.Empty))
{
query.AddNamedGraph(UriFactory.Create(userNamedGraph));
}
}
}
//Set Timeout setting
if (timeout > 0)
{
query.Timeout = timeout;
}
else
{
query.Timeout = this._config.DefaultTimeout;
}
//Set Partial Results Setting
query.PartialResultsOnTimeout = partialResults;
//Set Describe Algorithm
query.Describer = this._config.DescribeAlgorithm;
//Now we can finally make the query and return the results
Object result = this._config.QueryProcessor.ProcessQuery(query);
this.ProcessQueryResults(context, result);
}
catch (RdfParseException parseEx)
{
HandleQueryErrors(context, "Parsing Error", queryText, parseEx, (int)HttpStatusCode.BadRequest);
}
catch (RdfQueryTimeoutException timeoutEx)
{
HandleQueryErrors(context, "Query Timeout Error", queryText, timeoutEx);
}
catch (RdfQueryException queryEx)
{
HandleQueryErrors(context, "Query Error", queryText, queryEx);
}
catch (RdfWriterSelectionException writerSelEx)
{
HandleQueryErrors(context, "Output Selection Error", queryText, writerSelEx, (int)HttpStatusCode.NotAcceptable);
}
catch (RdfException rdfEx)
{
HandleQueryErrors(context, "RDF Error", queryText, rdfEx);
}
catch (Exception ex)
{
HandleQueryErrors(context, "Error", queryText, ex);
}
}
public async Task <IActionResult> StartRegistration(string processDefinitionId, string processInstanceId)
{
try
{
List <ProcessDefinitionData> data;
List <string> genreNames = new List <string>();
_context.Genres.ToList().ForEach(x => genreNames.Add(x.Name));
if (processDefinitionId == null && processInstanceId == null)
{
HttpResponseMessage response = await client.GetAsync($"{_configuration["url"]}/process-definition");
Task <string> jsonStringResult_1 = response.Content.ReadAsStringAsync();
data = JsonConvert.DeserializeObject <List <ProcessDefinitionData> >(jsonStringResult_1.Result);
processDefinitionId = data[0].Id;
var jsonData = JsonConvert.SerializeObject(new StartProcess()
{
variables = new lit_udr.Camunda.Model.Variables()
{
Korisnik = new lit_udr.Camunda.Model.User()
{
value = "Nemanja"
}
}
});
var content = new StringContent(jsonData, Encoding.UTF8, "application/json");
HttpResponseMessage startResppponse = await client.PostAsync($"{_configuration["url"]}/process-definition/{data[0].Id}/start", content);
HttpResponseMessage taskResponse = await client.GetAsync($"{_configuration["url"]}/task?processDefinitionId={data[0].Id}&&name=Registracija");
Task <string> jsonStringResult_2 = taskResponse.Content.ReadAsStringAsync();
List <CamundaTask> tasks = JsonConvert.DeserializeObject <List <CamundaTask> >(jsonStringResult_2.Result);
HttpResponseMessage taskFormResponse = await client.GetAsync($"{_configuration["url"]}/task/{tasks[0].id}/form-variables");
Task <string> jsonStringResult_3 = taskFormResponse.Content.ReadAsStringAsync();
FormVariables vars = JsonConvert.DeserializeObject <FormVariables>(jsonStringResult_3.Result);
return(Ok(ParseAndGetConstraints(vars, processDefinitionId, tasks[0].processInstanceId, tasks[0].id, genreNames)));
}
HttpResponseMessage taskResponse2 = await client.GetAsync($"{_configuration["url"]}/task?processDefinitionId={processDefinitionId}&&processInstanceId={processInstanceId}");
Task <string> jsonStringResult_22 = taskResponse2.Content.ReadAsStringAsync();
List <CamundaTask> tasks2 = JsonConvert.DeserializeObject <List <CamundaTask> >(jsonStringResult_22.Result);
if (tasks2.Count == 0)
{
return(BadRequest());
}
HttpResponseMessage taskFormResponse2 = await client.GetAsync($"{_configuration["url"]}/task/{tasks2[0].id}/form-variables");
Task <string> jsonStringResult_32 = taskFormResponse2.Content.ReadAsStringAsync();
FormVariables vars2 = JsonConvert.DeserializeObject <FormVariables>(jsonStringResult_32.Result);
return(Ok(ParseAndGetConstraints(vars2, processDefinitionId, tasks2[0].processInstanceId, tasks2[0].id, genreNames)));
}
catch (Exception e)
{
return(BadRequest());
}
}
public void TestCurrentWebForm_WhenMultipleForms()
{
FormVariables unused = CurrentWebForm.Variables;
}
public void SetUp()
{
variables = new FormVariables();
AddStuff();
}
