public void Init(ParsingContext context, ParseTreeNode parseNode)
{
var multiplyString = parseNode.ChildNodes[0].Token.Text.ToUpper();
CollectionType collectionType;
switch (multiplyString)
{
case SonesGQLConstants.LISTOF:
collectionType = CollectionType.List;
break;
case SonesGQLConstants.SETOF:
collectionType = CollectionType.Set;
break;
case SonesGQLConstants.SETOFUUIDS:
default:
throw new InvalidOperationException(
String.Format("The specified command [{0}] is not valid.", multiplyString));
}
if (parseNode.ChildNodes[1].AstNode is TupleNode)
{
CollectionDefinition =
new CollectionDefinition(collectionType,
((TupleNode)parseNode.ChildNodes[1].AstNode).TupleDefinition);
}
else
{
throw new NotImplementedException("The following node cannot be created.");
}
}
public async Task <APIResponse> Get(string name)
{
_logger.LogInformation($"get request for id {name} recieved");
var id = CollectionDefinition.BuildId(name);
var response = await _collectionRepository.GetById(id).ConfigureAwait(false);
response.Data.ExampleJsonObject = JsonSerializer.Deserialize <object>(response.Data.ExampleJsonObjectString);
if (response.Ok)
{
_logger.LogInformation($"fetched collection {response.Id}");
return(new APIResponse
{
Request = Request.ToRequestString(),
Ok = true,
Result = "found",
Data = response.Data
});
}
_logger.LogInformation($"unable to fetch collection( for {id}");
return(APIResponse.NotOk(Request.ToRequestString(), "unable to fetch data from elasticsearch", HttpStatusCode.NotFound, response.Id));
}
public async Task <APIResponse> Post(string name, string exampleIdPattern, [FromBody] ExpandoObject exampleJsonObject)
{
_logger.LogInformation($"post request recieved");
var collectionDefinition = new CollectionDefinition
{
Name = name.ToLower(),
ExampleIdPattern = exampleIdPattern,
ExampleJsonObjectString = JsonSerializer.Serialize <object>(exampleJsonObject, new JsonSerializerOptions {
WriteIndented = true
})
};
var response = await _collectionRepository.Index(collectionDefinition.Id, collectionDefinition).ConfigureAwait(false);
if (response.Ok)
{
_logger.LogInformation($"posted collection {response.Result} {response.Id}");
return(new APIResponse
{
Request = Request.ToRequestString(),
Ok = true,
Result = response.Result,
StatusCode = response.StatusCode,
Data = response.Id
});
}
_logger.LogInformation($"unable to post collection to elasticsearch {response.StatusCode}");
return(APIResponse.NotOk(Request.ToRequestString(), "unable to post data to elasticsearch", HttpStatusCode.BadRequest, response.Id));
}
private async Task <CollectionDefinition> GetCollection(string collectionName)
{
var id = CollectionDefinition.BuildId(collectionName);
var response = await _collectionRepository.GetById(id).ConfigureAwait(false);
if (response.Ok)
{
return(response.Data);
}
return(null);
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
if (parseNode.ChildNodes[0].AstNode is TupleNode)
{
CollectionDefinition =
new CollectionDefinition(CollectionType.Set,
((TupleNode)parseNode.ChildNodes[0].AstNode).TupleDefinition);
}
else
{
CollectionDefinition =
new CollectionDefinition(CollectionType.Set,
(EdgeTypeEdgeIDCollectionNode)parseNode.ChildNodes[0].AstNode);
}
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
var multiplyString = parseNode.ChildNodes[0].Token.Text.ToUpper();
CollectionType collectionType;
switch (multiplyString)
{
case SonesGQLConstants.LISTOF:
collectionType = CollectionType.List;
break;
case SonesGQLConstants.SETOF:
collectionType = CollectionType.Set;
break;
case SonesGQLConstants.SETOFUUIDS:
collectionType = CollectionType.SetOfUUIDs;
break;
default:
throw new NotImplementedException("");
}
if (parseNode.ChildNodes[1].AstNode is TupleNode)
{
CollectionDefinition = new CollectionDefinition(collectionType, ((TupleNode)parseNode.ChildNodes[1].AstNode).TupleDefinition);
}
else
{
CollectionDefinition = new CollectionDefinition(collectionType, (VertexTypeVertexIDCollectionNode)parseNode.ChildNodes[1].AstNode);
}
}
public async Task <APIResponse> Delete(string name)
{
var id = CollectionDefinition.BuildId(name);
_logger.LogInformation($"delete request recieved for id {id}");
var collectionResponse = await _collectionRepository.GetById(id);
if (!collectionResponse.Ok)
{
return(APIResponse.NotOk(Request.ToRequestString(), $"unable to delete data from elasticsearch, collection {name} not found", HttpStatusCode.NotFound));
}
await _collectionRepository.GetElasticBand().GetClient().DeleteAsync(collectionResponse.Data.Index);
_logger.LogInformation($"deleted index {collectionResponse.Data.Index}");
var deleteResponse = await _collectionRepository.Delete(id).ConfigureAwait(false);
if (deleteResponse.Ok)
{
_logger.LogInformation($"deleted collection {name}");
return(new APIResponse
{
Request = Request.ToRequestString(),
Ok = true,
Result = "deleted",
Data = deleteResponse.Id
});
}
_logger.LogInformation($"unable to delete collection with id {name} {deleteResponse.StatusCode}");
return(APIResponse.NotOk(Request.ToRequestString(), "unable to delete data from elasticsearch", HttpStatusCode.NotFound, deleteResponse.Id));
// TODO could do with logging helper which creates a trace id and logs request and response data automatically?
// or stores up messages and appends them all as one log per request??
}
//-----------------------------------------------------------------------
private static DataDefinition CreateDefinitionFromElement(XElement el, DataDefinition existing)
{
if (!el.HasElements)
{
// we are a primitive
// are we a number?
float fval;
bool isFloat = float.TryParse(el.Value, out fval);
int ival;
bool isInt = int.TryParse(el.Value, out ival);
bool bval;
bool isBool = bool.TryParse(el.Value, out bval);
if (existing != null)
{
if (isFloat || isInt)
{
if (existing is NumberDefinition)
{
var def = existing as NumberDefinition;
if (!isInt)
{
def.UseIntegers = false;
}
if (fval < def.MinValue)
{
def.MinValue = fval;
}
if (fval > def.MaxValue)
{
def.MaxValue = fval;
}
return(def);
}
else
{
// we are actually a string
var def = new StringDefinition();
def.Name = el.Value.ToString();
return(def);
}
}
else if (isBool)
{
if (existing is BooleanDefinition)
{
return(existing);
}
else
{
// we are actually a string
var def = new StringDefinition();
def.Name = el.Value.ToString();
return(def);
}
}
else
{
if (existing is EnumDefinition)
{
if (el.Value.Contains("/") || el.Value.Contains(@"\\"))
{
var def = new FileDefinition();
def.Name = el.Name.ToString();
return(def);
}
else if (el.Value.Contains(" "))
{
var def = new StringDefinition();
def.Name = el.Name.ToString();
return(def);
}
else
{
var def = existing as EnumDefinition;
if (!def.EnumValues.Contains(el.Value))
{
def.EnumValues.Add(el.Value);
}
return(def);
}
}
else
{
return(existing);
}
}
}
else
{
if (isFloat || isInt)
{
var def = new NumberDefinition();
def.Name = el.Name.ToString();
def.UseIntegers = isInt;
def.MinValue = fval;
def.MaxValue = fval;
return(def);
}
else if (isBool)
{
var def = new BooleanDefinition();
def.Name = el.Name.ToString();
return(def);
}
else
{
if (el.Value.Contains("/") || el.Value.Contains(@"\\"))
{
var def = new FileDefinition();
def.Name = el.Name.ToString();
return(def);
}
else if (el.Value.Contains(" "))
{
var def = new StringDefinition();
def.Name = el.Name.ToString();
return(def);
}
else
{
var def = new EnumDefinition();
def.Name = el.Name.ToString();
def.EnumValues = new List <string>();
def.EnumValues.Add(el.Value);
return(def);
}
}
}
}
else if (el.Elements().Any(e => e.Name.ToString() != el.Elements().First().Name.ToString()))
{
// we are a struct
if (existing != null)
{
var def = existing as StructDefinition;
if (def != null)
{
foreach (var cel in el.Elements())
{
if (el.Elements(cel.Name).Count() > 1)
{
// this is actually a collection
var existingChild = def.Children.FirstOrDefault(e => e.Name == cel.Name.ToString());
CollectionDefinition coldef = null;
if (existingChild == null)
{
coldef = new CollectionDefinition();
coldef.Name = cel.Name.ToString();
coldef.ChildDefinitions.Add(new CollectionChildDefinition());
coldef.ChildDefinitions[0].Name = cel.Name.ToString();
def.Children.Add(coldef);
}
else if (existingChild is CollectionDefinition)
{
coldef = existingChild as CollectionDefinition;
}
else
{
coldef = new CollectionDefinition();
coldef.Name = cel.Name.ToString();
coldef.ChildDefinitions.Add(new CollectionChildDefinition());
coldef.ChildDefinitions[0].Name = cel.Name.ToString();
coldef.ChildDefinitions[0].WrappedDefinition = existingChild;
var index = def.Children.IndexOf(existingChild);
def.Children[index] = coldef;
}
coldef.ChildDefinitions[0].WrappedDefinition = CreateDefinitionFromElement(cel, coldef.ChildDefinitions[0].WrappedDefinition);
}
else
{
// find existing child
var ec = def.Children.FirstOrDefault(e => e.Name == cel.Name.ToString());
if (ec != null)
{
if (ec is CollectionDefinition)
{
var actualDef = CreateDefinitionFromElement(cel, null);
if (actualDef is CollectionDefinition)
{
var cdef = CreateDefinitionFromElement(cel, ec);
def.Children[def.Children.IndexOf(ec)] = cdef;
}
else
{
var coldef = ec as CollectionDefinition;
coldef.ChildDefinitions[0].WrappedDefinition = CreateDefinitionFromElement(cel, coldef.ChildDefinitions[0].WrappedDefinition);
}
}
else
{
var cdef = CreateDefinitionFromElement(cel, ec);
def.Children[def.Children.IndexOf(ec)] = cdef;
}
}
else
{
var cdef = CreateDefinitionFromElement(cel, null);
def.Children.Add(cdef);
}
}
}
}
return(existing);
}
else
{
var def = new StructDefinition();
def.Name = el.Name.ToString();
foreach (var cel in el.Elements())
{
if (el.Elements(cel.Name).Count() > 1)
{
// this is actually a collection
CollectionDefinition coldef = def.Children.FirstOrDefault(e => e.Name == cel.Name.ToString()) as CollectionDefinition;
if (coldef == null)
{
coldef = new CollectionDefinition();
coldef.Name = cel.Name.ToString();
coldef.ChildDefinitions.Add(new CollectionChildDefinition());
coldef.ChildDefinitions[0].Name = cel.Name.ToString();
def.Children.Add(coldef);
}
coldef.ChildDefinitions[0].WrappedDefinition = CreateDefinitionFromElement(cel, coldef.ChildDefinitions[0].WrappedDefinition);
}
else
{
var cdef = CreateDefinitionFromElement(cel, null);
def.Children.Add(cdef);
}
}
return(def);
}
}
else
{
// we are a collection
if (existing != null)
{
if (existing is CollectionDefinition)
{
var def = existing as CollectionDefinition;
foreach (var cel in el.Elements())
{
def.ChildDefinitions[0].WrappedDefinition = CreateDefinitionFromElement(cel, def.ChildDefinitions[0].WrappedDefinition);
}
return(def);
}
else
{
var def = new CollectionDefinition();
def.Name = el.Name.ToString();
def.ChildDefinitions.Add(new CollectionChildDefinition());
def.ChildDefinitions[0].Name = el.Elements().First().Name.ToString();
def.ChildDefinitions[0].WrappedDefinition = existing;
foreach (var cel in el.Elements())
{
def.ChildDefinitions[0].WrappedDefinition = CreateDefinitionFromElement(cel, def.ChildDefinitions[0].WrappedDefinition);
}
return(def);
}
}
else
{
var def = new CollectionDefinition();
def.Name = el.Name.ToString();
def.ChildDefinitions.Add(new CollectionChildDefinition());
def.ChildDefinitions[0].Name = el.Elements().First().Name.ToString();
foreach (var cel in el.Elements())
{
def.ChildDefinitions[0].WrappedDefinition = CreateDefinitionFromElement(cel, def.ChildDefinitions[0].WrappedDefinition);
}
return(def);
}
}
throw new Exception("Failed to parse element: " + el.Name);
}
public ArrayTypeMap(ISerializerCache serializerCache, CollectionDefinition collectionDefinition, ITypeMap elementTypeMap)
: base(collectionDefinition)
{
this.serializerCache = serializerCache;
this.elementTypeMap = elementTypeMap;
}
