/// <summary>
/// Add new record or Save update record
/// </summary>
/// <returns></returns>
public async Task <bool> SaveRecord()
{
return(await Task.Factory.StartNew(() =>
{
if (!Validate(hasErrors))
{
MessageBox.Show("Ошибка валидации данных!");
return false;
}
bool cmd_res = false;
if (DataList == null)
{
return false;
}
var ia = DataList.Where(i => i.Id == SelectedDataModel.Id).FirstOrDefault();
if (ia == null)
{
cmd_res = new InsertDataCommand(dataAPI, new DataRecord(SelectedDataModel.Name, SelectedDataModel.Surname, SelectedDataModel.Patronymic, SelectedDataModel.Email)).Execute();
}
else
{
cmd_res = new UpdateDataCommand(dataAPI, new DataRecord(SelectedDataModel.Id, SelectedDataModel.Name, SelectedDataModel.Surname, SelectedDataModel.Patronymic, SelectedDataModel.Email)).Execute();
}
if (cmd_res)
{
GetRecordList();
MessageBox.Show("Данные успешно обновлены");
}
return cmd_res;
}));
}
private SparqlUpdateCommand TryParseInsertDataCommand(SparqlUpdateParserContext context)
{
InsertDataCommand cmd;
SparqlQueryParserContext subContext = new SparqlQueryParserContext(context.Tokens);
subContext.Query.BaseUri = context.BaseUri;
subContext.Query.NamespaceMap = context.NamespaceMap;
subContext.ExpressionParser.NamespaceMap = context.NamespaceMap;
subContext.ExpressionParser.ExpressionFactories = context.ExpressionFactories;
subContext.ExpressionFactories = context.ExpressionFactories;
GraphPattern gp = context.QueryParser.TryParseGraphPattern(subContext, context.Tokens.LastTokenType != Token.LEFTCURLYBRACKET);
//Validate that the Graph Pattern is simple
//Check it doesn't contain anything other than Triple Patterns or if it does it just contains a single GRAPH Pattern
if (gp.IsFiltered)
{
throw new RdfParseException("A FILTER Clause cannot occur in a INSERT DATA Command");
}
else if (gp.IsOptional)
{
throw new RdfParseException("An OPTIONAL Clause cannot occur in a INSERT DATA Command");
}
else if (gp.IsUnion)
{
throw new RdfParseException("A UNION Clause cannot occur in a INSERT DATA Command");
}
else if (gp.HasChildGraphPatterns)
{
if (!gp.ChildGraphPatterns.All(p => p.IsGraph || (!p.IsExists && !p.IsMinus && !p.IsNotExists && !p.IsOptional && !p.IsOptional && !p.IsService && !p.IsSubQuery && !p.IsUnion)))
{
throw new RdfParseException("An INSERT DATA Command may only contain a combination of Triple Patterns and GRAPH clauses");
}
else if (gp.ChildGraphPatterns.Any(p => p.HasChildGraphPatterns))
{
throw new RdfParseException("An INSERT DATA Command may not contain nested Graph Patterns");
}
else if (gp.HasChildGraphPatterns && gp.TriplePatterns.Count > 0)
{
cmd = new InsertDataCommand(gp);
}
else if (gp.ChildGraphPatterns.Count == 1 && gp.ChildGraphPatterns[0].IsGraph)
{
cmd = new InsertDataCommand(gp.ChildGraphPatterns[0]);
}
else
{
throw new RdfParseException("Nested Graph Patterns cannot occur in a INSERT DATA Command");
}
}
else
{
//OK
cmd = new InsertDataCommand(gp);
}
return(cmd);
}
public async Task <JsonResult> InsertRow([FromRoute] int id, [FromBody] InsertDataCommand command)
{
if (command.TableId != id)
{
command.TableId = id;
}
var insertedRowId = await Mediator.Send(command);
return(new JsonResult(insertedRowId));
}
/// <summary>
/// Processes an INSERT DATA command
/// </summary>
/// <param name="cmd">Insert Data Command</param>
public void ProcessInsertDataCommand(InsertDataCommand cmd)
{
this.ProcessCommand(cmd);
}
/// <summary>
/// Processes an INSERT DATA command.
/// </summary>
/// <param name="cmd">Insert Data Command.</param>
/// <param name="context">SPARQL Update Evaluation Context.</param>
protected virtual void ProcessInsertDataCommandInternal(InsertDataCommand cmd, SparqlUpdateEvaluationContext context)
{
cmd.Evaluate(context);
}
/// <summary>
/// Processes an INSERT DATA command.
/// </summary>
/// <param name="cmd">Insert Data Command.</param>
public void ProcessInsertDataCommand(InsertDataCommand cmd)
{
ProcessInsertDataCommandInternal(cmd, GetContext());
}
private SparqlUpdateCommand TryParseInsertDataCommand(SparqlUpdateParserContext context)
{
InsertDataCommand cmd;
SparqlQueryParserContext subContext = new SparqlQueryParserContext(context.Tokens);
subContext.Query.BaseUri = context.BaseUri;
subContext.Query.NamespaceMap = context.NamespaceMap;
subContext.ExpressionParser.NamespaceMap = context.NamespaceMap;
subContext.ExpressionParser.ExpressionFactories = context.ExpressionFactories;
subContext.ExpressionFactories = context.ExpressionFactories;
subContext.CheckBlankNodeScope = false;
GraphPattern gp = context.QueryParser.TryParseGraphPattern(subContext, context.Tokens.LastTokenType != Token.LEFTCURLYBRACKET);
//Validate use of Blank Nodes in INSERT DATA, same BNode MAY be used within different graph patterns in a single command
//though each represents a fresh blank node
//The same BNode MAY NOT be used across separate commands
if (context.DataBNodes.Count == 0)
{
//First INSERT DATA so simply register all the BNodes
foreach (String var in gp.Variables.Where(v => v.StartsWith("_:")))
{
context.DataBNodes.Add(var);
}
}
else
{
//Some INSERT DATA commands have already occurred, validate that newly introduced variables are not already present
foreach (String var in gp.Variables.Where(v => v.StartsWith("_:")).Distinct())
{
if (context.DataBNodes.Contains(var))
{
throw new RdfParseException("An INSERT DATA command used the BNode " + var + " which has been used in previous INSERT DATA commands and is not permitted per Section 19.6 of the specification");
}
else
{
context.DataBNodes.Add(var);
}
}
}
//Validate that the Graph Pattern is simple
//Check it doesn't contain anything other than Triple Patterns or if it does it just contains a single GRAPH Pattern
if (gp.IsFiltered)
{
throw new RdfParseException("A FILTER Clause cannot occur in a INSERT DATA Command");
}
else if (gp.IsOptional)
{
throw new RdfParseException("An OPTIONAL Clause cannot occur in a INSERT DATA Command");
}
else if (gp.IsUnion)
{
throw new RdfParseException("A UNION Clause cannot occur in a INSERT DATA Command");
}
else if (gp.HasChildGraphPatterns)
{
if (!gp.ChildGraphPatterns.All(p => (p.IsGraph && p.GraphSpecifier.TokenType != Token.VARIABLE) || (!p.IsExists && !p.IsMinus && !p.IsNotExists && !p.IsOptional && !p.IsOptional && !p.IsService && !p.IsSubQuery && !p.IsUnion && !p.IsGraph)))
{
throw new RdfParseException("An INSERT DATA Command may only contain a combination of Triple Patterns and GRAPH clauses, GRAPH clauses must specify a Graph URI");
}
else if (gp.ChildGraphPatterns.Any(p => p.HasChildGraphPatterns))
{
throw new RdfParseException("An INSERT DATA Command may not contain nested Graph Patterns");
}
else if (gp.ChildGraphPatterns.Count == 1 && gp.ChildGraphPatterns[0].IsGraph && gp.TriplePatterns.Count == 0)
{
cmd = new InsertDataCommand(gp.ChildGraphPatterns[0]);
}
else if (gp.HasChildGraphPatterns)
{
cmd = new InsertDataCommand(gp);
}
else
{
throw new RdfParseException("Nested Graph Patterns cannot occur in a INSERT DATA Command");
}
}
else
{
//OK
cmd = new InsertDataCommand(gp);
}
return(cmd);
}
private void SanitizeInsertDataCommand(ICollection <SparqlUpdateCommand> toBeRemoved, InsertDataCommand insertDataCommand)
{
for (var index = insertDataCommand.DataPattern.ChildGraphPatterns.Count - 1; index >= 0; index--)
{
if (insertDataCommand.DataPattern.ChildGraphPatterns[index].TriplePatterns.Count == 0)
{
insertDataCommand.DataPattern.ChildGraphPatterns.RemoveAt(index);
}
}
if (!insertDataCommand.DataPattern.ChildGraphPatterns.SelectMany(graph => graph.TriplePatterns).Union(insertDataCommand.DataPattern.TriplePatterns).Any())
{
toBeRemoved.Add(insertDataCommand);
}
}
