public CecilType Get(TypeReference reference)
{
if (reference.GetType() == typeof(TypeReference))
{
reference = reference.Resolve();
}
var definition = reference.Resolve();
var asm = TypeSystem.FindAsm(definition.Module.Assembly);
if (!_definitions.TryGetValue(definition, out var dentry))
{
_definitions[definition] = dentry = new DefinitionEntry();
}
if (reference is TypeDefinition def)
{
return(dentry.Direct ?? (dentry.Direct = new CecilType(TypeSystem, asm, def)));
}
var rtype = reference.GetType();
if (!dentry.References.TryGetValue(rtype, out var rlist))
{
dentry.References[rtype] = rlist = new List <CecilType>();
}
var found = rlist.FirstOrDefault(t => CecilHelpers.Equals(t.Reference, reference));
if (found != null)
{
return(found);
}
var rv = new CecilType(TypeSystem, asm, definition, reference);
rlist.Add(rv);
return(rv);
}
public async Task <ActionResult <DefinitionEntry> > PostDefinition([FromBody] DefinitionEntry definition)
{
_context.Definitions.Add(definition);
await _context.SaveChangesAsync();
return(CreatedAtAction(
"GetDefinition",
new { id = definition.Id },
definition
));
}
public async Task <QueryResult> AddCharacterDefinition(string character, DefinitionEntry entry)
{
if (string.IsNullOrEmpty(character))
{
return(QueryResult.EmptyField(nameof(character)));
}
if (entry == null)
{
return(QueryResult.EmptyField(nameof(entry)));
}
if (string.IsNullOrEmpty(entry.Definition) || string.IsNullOrEmpty(entry.PartOfSpeech))
{
return(QueryResult.InvalidField(nameof(entry)));
}
return(QueryResult.QueryFailed(await _characterManager.UpdateDefinitionAsync(character, entry)));
}
public async Task <QueryResult> AddPhraseDefinition(string phrase, DefinitionEntry entry)
{
if (string.IsNullOrEmpty(entry.Definition))
{
return(QueryResult.EmptyField(nameof(entry)));
}
if (string.IsNullOrEmpty(entry.PartOfSpeech))
{
return(QueryResult.EmptyField(nameof(entry)));
}
if (string.IsNullOrEmpty(phrase))
{
return(QueryResult.EmptyField(nameof(phrase)));
}
return(QueryResult.QueryFailed(await Manager.UpdateDefinitionAsync(phrase, entry)));
}
public async Task <bool> UpdateDefinitionAsync(string phrase, DefinitionEntry definition)
{
if (string.IsNullOrEmpty(phrase) || string.IsNullOrEmpty(definition.Definition) || string.IsNullOrEmpty(definition.PartOfSpeech))
{
return(false);
}
var c = await FindPhraseAsync(phrase);
if (c == null)
{
return(false);
}
c.Definitions.Add(definition);
await Save();
return(true);
}
public async Task <IActionResult> PutDefinition([FromRoute] int id, [FromBody] DefinitionEntry definition)
{
if (id != definition.Id)
{
return(BadRequest());
}
_context.Entry(definition).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (_context.Definitions.Find(id) == null)
{
return(NotFound());
}
throw;
}
return(NoContent());
}
