public async Task <QuerySaveResult> InitialSaveAsync(QuerySave query)
{
var urn = QueryUrn.Create(query.QueryId);
var conceptids = query.Resources.Concepts.Select(c => c.Id.Value).Where(c => c != Guid.Empty);
var queryids = query.Resources.Queries.Select(q => q.Id.Value);
using (var cn = new SqlConnection(dbOpts.ConnectionString))
{
await cn.OpenAsync();
var qsr = await cn.QueryFirstOrDefaultAsync <QuerySaveResultRecord>(
initialQuerySave,
new
{
queryid = query.QueryId,
urn = urn.ToString(),
name = query.Name,
category = query.Category,
conceptids = ResourceIdTable.From(conceptids),
queryids = ResourceIdTable.From(queryids),
definition = query.Definition,
user = user.UUID
},
commandType : CommandType.StoredProcedure,
commandTimeout : dbOpts.DefaultTimeout
);
if (qsr == null)
{
return(null);
}
return(new QuerySaveResult(query.QueryId, QueryUrn.From(qsr.UniversalId), qsr.Ver));
}
}
async Task <QuerySaveResult> ImplSaveAsync(QuerySave query)
{
if (query.UniversalId == null)
{
return(await service.InitialSaveAsync(query));
}
return(await service.UpsertSaveAsync(query));
}
public async Task <QuerySaveResult> Save(QuerySave query)
{
if (query.UniversalId == null)
{
return(await InitialSave(query));
}
return(await UpsertSave(query));
}
async Task <QuerySaveResult> UpsertSave(QuerySave query)
{
var conceptids = query.Resources.Concepts.Select(c => c.Id.Value);
var queryids = query.Resources.Queries.Select(q => q.Id.Value);
try
{
using (var cn = new SqlConnection(dbOpts.ConnectionString))
{
await cn.OpenAsync();
var qsr = await cn.QueryFirstOrDefaultAsync <QuerySaveResultRecord>(
upsertQuerySave,
new
{
queryid = query.QueryId,
urn = query.UniversalId.ToString(),
ver = query.Ver,
name = query.Name,
category = query.Category,
conceptids = ResourceIdTable.From(conceptids),
queryids = ResourceIdTable.From(queryids),
definition = query.Definition,
user = user.UUID
},
commandType : CommandType.StoredProcedure,
commandTimeout : dbOpts.DefaultTimeout
);
if (qsr == null)
{
return(null);
}
return(new QuerySaveResult(query.QueryId, QueryUrn.From(qsr.UniversalId), qsr.Ver));
}
}
catch (SqlException se)
{
logger.LogError("Could not save query. Query:{@Query} Code:{Code} Error:{Error}", query, se.ErrorCode, se.Message);
se.MapThrow();
throw;
}
}
public async Task <ActionResult <QuerySaveResponseDTO> > Save(
string id,
[FromBody] QuerySaveDTO querySave,
[FromServices] IPanelConverterService panelConverter,
[FromServices] IPanelValidator panelValidator,
CancellationToken cancelToken
)
{
try
{
// federated user submitting an initial save request
if (!user.IsInstutional && QueryUrn.From(querySave.UniversalId) == null)
{
return(BadRequest("Initial save requests must be made to home node."));
}
var ctx = await panelConverter.GetPanelsAsync(querySave, cancelToken);
if (!ctx.PreflightPassed)
{
return(BadRequest(new QuerySaveResponseDTO {
Preflight = new PreflightCheckDTO(ctx.PreflightCheck)
}));
}
var query = panelValidator.Validate(ctx);
cancelToken.ThrowIfCancellationRequested();
if (!user.IsInstutional)
{
panelConverter.LocalizeDefinition(querySave, query);
}
var toSave = new QuerySave
{
QueryId = new Guid(id),
UniversalId = ctx.UniversalId,
Name = querySave.Name,
Category = querySave.Category,
Definition = QueryDefinitionDTO.JSON(querySave),
Resources = query.Panels.GetResources()
};
if (querySave.Ver.HasValue)
{
toSave.Ver = querySave.Ver.Value;
}
var saved = await queryService.Save(toSave);
if (saved == null)
{
return(NotFound());
}
var response = new QuerySaveResponseDTO
{
Preflight = new PreflightCheckDTO(ctx.PreflightCheck),
Query = new QuerySaveResultDTO(saved)
};
return(Ok(response));
}
catch (InvalidOperationException ie)
{
log.LogError("Unrecoverable validation error in query. Error:{Error}", ie.Message);
return(BadRequest());
}
catch (FormatException fe)
{
log.LogError("Malformed query identifier. Id:{Id} UniversalId:{UniversalId} Error:{Error}", id, querySave.UniversalId, fe.Message);
return(BadRequest());
}
catch (OperationCanceledException)
{
log.LogInformation("Request cancelled.");
return(NoContent());
}
catch (LeafDbException lde)
{
return(StatusCode(lde.StatusCode));
}
catch (Exception e)
{
log.LogError("Could not save query. QueryId:{QueryId} Query:{@Query} Error:{Error}", id, querySave, e.ToString());
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <SaveResult> SaveAsync(Guid id, IQuerySaveDTO ast, Func <IQueryDefinition, string> json, CancellationToken cancel)
{
log.LogInformation("Saving query. Id:{Id} Ast:{Ast}", id, ast);
var ctx = await converter.GetPanelsAsync(ast, cancel);
log.LogInformation("Save query panel validation context. Context:{@Context}", ctx);
if (!ctx.PreflightPassed)
{
return(new SaveResult {
State = SaveState.Preflight, Preflight = ctx.PreflightCheck
});
}
var query = validator.Validate(ctx);
cancel.ThrowIfCancellationRequested();
if (!user.IsInstitutional)
{
converter.LocalizeDefinition(ast, query);
log.LogInformation("Localized federated query. Id:{Id} Ast:{Ast}", id, ast);
}
var toSave = new QuerySave
{
QueryId = id,
UniversalId = ctx.UniversalId,
Name = ast.Name,
Category = ast.Category,
Definition = json(ast),
Resources = query.Panels.GetResources()
};
// if ast already has an assive version, use it
if (ast.Ver.HasValue)
{
toSave.Ver = ast.Ver.Value;
}
try
{
log.LogInformation("Saving query. Query:{Query} Payload:{@Payload}", id, toSave);
var saved = await ImplSaveAsync(toSave);
if (saved == null)
{
log.LogError("Could not save query, not found. Query:{Query}", id);
return(new SaveResult
{
State = SaveState.NotFound,
Preflight = ctx.PreflightCheck,
Result = null
});
}
log.LogInformation("Saved query. Query:{@Query}", toSave);
return(new SaveResult
{
State = SaveState.Ok,
Preflight = ctx.PreflightCheck,
Result = saved
});
}
catch (DbException de)
{
log.LogError("Failed to save query. Query:{@Query} Code:{Code} Error:{Error}", toSave, de.ErrorCode, de.Message);
de.MapThrow();
throw;
}
}
