public async Task CreateIndex(CreateIndexParameters indexParm)
{
if (string.IsNullOrEmpty(indexParm.Taxonomy))
{
Exception error = new Exception($"Taxonomy not selected");
throw error;
}
Sources sr = new Sources(azureConnectionString);
ConnectParameters target = await sr.GetSourceParameters(indexParm.TargetName);
ConnectParameters source = await sr.GetSourceParameters(indexParm.SourceName);
Indexer index = new Indexer(azureConnectionString);
int parentNodes = await index.Initialize(target, source, indexParm.Taxonomy, indexParm.Filter);
List <ParentIndexNodes> nodes = await index.IndexParent(parentNodes, indexParm.Filter);
for (int j = 0; j < nodes.Count; j++)
{
ParentIndexNodes node = nodes[j];
for (int i = 0; i < node.NodeCount; i++)
{
await index.IndexChildren(j, i, node.ParentNodeId);
}
}
index.CloseIndex();
}
public static async Task <IActionResult> MakeIndex(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("CreateIndex: Starting");
try
{
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
CreateIndexParameters indexParm = JsonConvert.DeserializeObject <CreateIndexParameters>(requestBody);
if (indexParm == null)
{
log.LogError("CreateIndex: error missing index parameters");
return(new BadRequestObjectResult("Error missing index parameters"));
}
string storageAccount = Common.Helpers.Common.GetStorageKey(req);
IndexManagement im = new IndexManagement(storageAccount);
await im.CreateIndex(indexParm);
}
catch (Exception ex)
{
log.LogError($"CreateIndex: {ex}");
return(new BadRequestObjectResult($"Error creating index: {ex}"));
}
log.LogInformation("CreateIndex: Complete");
return(new OkObjectResult("OK"));
}
public async Task CreateChildIndexes(CreateIndexParameters iParams)
{
var response = await httpService.Post($"{url}/children", iParams);
if (!response.Success)
{
throw new ApplicationException(await response.GetBody());
}
}
public async Task <List <ParentIndexNodes> > CreateParentNodes(CreateIndexParameters iParameters)
{
var response = await httpService.Post <CreateIndexParameters, List <ParentIndexNodes> >(url, iParameters);
if (!response.Success)
{
throw new ApplicationException(await response.GetBody());
}
return(response.Response);
}
public async Task <ActionResult> Create(CreateIndexParameters iParameters)
{
logger.LogInformation("CreateIndexController: Starting index create");
try
{
string storageAccount = Common.Helpers.Common.GetStorageKey(Request);
IndexManagement im = new IndexManagement(storageAccount);
await im.CreateIndex(iParameters);
}
catch (Exception ex)
{
logger.LogInformation($"CreateIndexController: Error message = {ex}");
return(BadRequest(ex.ToString()));
}
return(NoContent());
}
public async Task Create(CreateIndexParameters iParameters)
{
if (string.IsNullOrEmpty(baseUrl))
{
url = "api/createindex";
}
else
{
url = baseUrl.BuildFunctionUrl("CreateIndex", $"", apiKey);
}
Console.WriteLine($"Create index: {url}");
var response = await httpService.Post(url, iParameters);
if (!response.Success)
{
throw new ApplicationException(await response.GetBody());
}
}
public async Task <ActionResult> CreateChildren(CreateIndexParameters iParams)
{
if (iParams == null)
{
return(BadRequest());
}
try
{
IndexBuilder iBuilder = new IndexBuilder();
string json = GetJsonIndexFile();
ConnectParameters connector = Common.GetConnectParameters(connectionString, container,
iParams.DataConnector);
iBuilder.InitializeIndex(connector, json);
iBuilder.PopulateIndex(iParams.ParentNodeNumber, iParams.ParentNumber, iParams.ParentNodeId);
}
catch (Exception ex)
{
return(BadRequest(ex.ToString()));
}
return(NoContent());
}
public static async Task <string> CreateIndex([ActivityTrigger] DataOpParameters pipe, ILogger log)
{
log.LogInformation($"CreateIndex: Starting");
CreateIndexParameters parms = JObject.Parse(pipe.JsonParameters).ToObject <CreateIndexParameters>();
try
{
Sources sr = new Sources(pipe.StorageAccount);
ConnectParameters target = await sr.GetSourceParameters(parms.TargetName);
ConnectParameters source = await sr.GetSourceParameters(parms.SourceName);
Indexer index = new Indexer(pipe.StorageAccount);
int parentNodes = await index.Initialize(target, source, parms.Taxonomy, parms.Filter);
List <ParentIndexNodes> nodes = await index.IndexParent(parentNodes, parms.Filter);
for (int j = 0; j < nodes.Count; j++)
{
ParentIndexNodes node = nodes[j];
for (int i = 0; i < node.NodeCount; i++)
{
await index.IndexChildren(j, i, node.ParentNodeId);
}
}
index.CloseIndex();
}
catch (Exception ex)
{
log.LogInformation($"CreateIndex: Serious exception {ex}");
}
log.LogInformation($"CreateIndex: Complete");
return($"Hello {pipe.Name}!");
}
public async Task <ActionResult <List <ParentIndexNodes> > > CreateParentNodes(CreateIndexParameters iParameters)
{
if (iParameters == null)
{
return(BadRequest());
}
List <ParentIndexNodes> nodes = new List <ParentIndexNodes>();
try
{
IndexBuilder iBuilder = new IndexBuilder();
string json = GetJsonIndexFile();
ConnectParameters connector = Common.GetConnectParameters(connectionString, container,
iParameters.DataConnector);
iBuilder.InitializeIndex(connector, json);
iBuilder.CreateRoot();
int parentNodes = iBuilder.JsonIndexArray.Count;
for (int k = 0; k < parentNodes; k++)
{
JToken token = iBuilder.JsonIndexArray[k];
int parentCount = iBuilder.GetObjectCount(token, k);
if (parentCount > 0)
{
int parentNodeId = iBuilder.CreateParentNodeIndex();
nodes.Add(new ParentIndexNodes()
{
NodeCount = parentCount,
ParentNodeId = parentNodeId,
Name = (string)token["DataName"]
});
}
}
iBuilder.CloseIndex();
}
catch (Exception ex)
{
return(BadRequest(ex.ToString()));
}
return(nodes);
}
