private void FindRule(Option option, Func <IRule, bool> setter)
{
if (option.OptionValue.QualifiedIdentifier.Parts.Count == 1)
{
var identifier = option.OptionValue.QualifiedIdentifier.Parts[0];
if (Grammar.Attr.Rules.TryGetValue(identifier.Name, out var rule))
{
if (rule == null)
{
throw new InternalNullException();
}
if (!setter(rule))
{
Results.AddError(new MessageError(MessageCode.AlreadyDefinedOption, identifier));
}
else
{
rule.Attr.SetIsUsed(true);
return;
}
}
Results.AddError(new MessageError(MessageCode.UndefinedOptionValue, identifier));
return;
}
Results.AddError(new MessageError(MessageCode.IllegalOptionValue, option.OptionValue.QualifiedIdentifier));
}
protected override void VisitPlusExpression(PlusExpression expression)
{
base.VisitPlusExpression(expression);
if (expression.Expression.Attr.IsNullable)
{
Results.AddError(new MessageError(MessageCode.NullableManyContent, expression));
}
}
protected override void VisitNameExpression(NameExpression expression)
{
if (!Grammar.Attr.Rules.TryGetValue(expression.Identifier.Name, out var _))
{
Results.AddError(new MessageError(MessageCode.UndefinedRule, expression.Identifier));
return;
}
}
public void Check()
{
new Visitor(Grammar).VisitGrammarRules();
foreach (var rule in Grammar.Attr.Rules)
{
if (!rule.Attr.IsUsed)
{
Results.AddError(new MessageWarning(MessageCode.UnusedRule, rule.Identifier));
}
}
}
public async Task <Results <ProjectVm> > SaveAsync(ProjectSaveData saveData)
{
var results = new Results <ProjectVm>();
try
{
var userId = await _getCurrentUserProcessor.GetUserIdAsync();
var user = await _userContext.DataSet
.Include(u => u.Projects)
.FirstAsync(u => u.Id == userId);
var project = user
.Projects
.FirstOrDefault(p => p.Id == saveData.Id);
if (saveData.Id == null)
{
project = new Project()
{
UserId = userId
};
user.Projects.Add(project);
}
else if (project == null || project.UserId != userId)
{
results.AddError("This project could not be found or you do not own this project");
}
if (results.HasError)
{
return(results);
}
project.Name = saveData.Name;
await _userContext.SaveChangesAsync();
results.Data.Id = project.Id;
results.Data.Name = project.Name;
results.Data.NumberOfReferences = project.ProjectReferences.Count();
}
catch (Exception e)
{
results.AddException(new Exception("Could not save this project", e));
}
return(results);
}
public async Task <Results <Project> > GetAsync(int projectId, int?forUserId = null)
{
var results = new Results <Project>();
var userId = forUserId ?? await _getCurrentUserProcessor.GetUserIdAsync();
results.Data = await _projectContext.DataSet
.FirstOrDefaultAsync(p => p.Id == projectId && p.UserId == userId);
if (results.Data == null)
{
results.AddError($"Cannot find a project with the id {projectId}");
}
return(results);
}
public void TryAdd(IRule rule)
{
if (Grammar.Attr.Rules.TryGetValue(rule.Identifier.Name, out var already))
{
if (already == null)
{
throw new InternalNullException();
}
Results.AddError(new MessageError(MessageCode.AlreadyDefinedRule, already.Identifier));
Results.AddError(new MessageError(MessageCode.RedefinedRule, rule.Identifier));
}
else
{
Grammar.Attr.Rules.Add(rule);
}
}
protected override void VisitOption(Option option)
{
switch (option.Identifier.Name.ToUpperInvariant())
{
case "START":
FindRule(option, rule => Grammar.Attr.SetStart(rule));
break;
case "SPACING":
FindRule(option, rule => Grammar.Attr.SetSpacing(rule));
break;
default:
Results.AddError(new MessageError(MessageCode.UnknownOption, option.Identifier));
break;
}
}
public async Task <Results <bool> > RemoveAsync(int projectId, string documentId)
{
var results = new Results <bool>();
try
{
var projectResults = await _getProjectForUserProcessor.GetAsync(projectId);
if (results.HasProblem)
{
results.Merge(projectResults);
return(results);
}
var toRemove = projectResults.Data.ProjectReferences
.FirstOrDefault(pr => pr.ReferenceId == documentId);
if (toRemove == null)
{
results.AddError("Your project does not have that reference");
}
if (results.HasProblem)
{
return(results);
}
projectResults.Data.ProjectReferences.Remove(toRemove);
await _projectContext.SaveChangesAsync();
results.Data = true;
}
catch (System.Exception e)
{
results.AddException(new System.Exception("Failed to add this reference", e));
}
return(results);
}
public void Check()
{
var start = Grammar.Attr.Start;
start.Attr.SetIsReachable(true);
var spacing = Grammar.Attr.Spacing;
spacing.Attr.SetIsReachable(true);
var visitor = new Visitor(Grammar);
visitor.VisitExpression(start.Expression);
visitor.VisitExpression(spacing.Expression);
foreach (var rule in Grammar.Attr.Rules)
{
if (!rule.Attr.IsReachable)
{
Results.AddError(new MessageWarning(MessageCode.UnreachableRule, rule.Identifier));
}
}
}