/// <summary>
/// Creates a response from the compatible headers.
/// </summary>
/// <param name="compatibleHeaders">The compatible headers.</param>
/// <param name="negotiationContext">The negotiation context.</param>
/// <param name="context">The context.</param>
/// <returns>A <see cref="Response"/>.</returns>
private Response CreateResponse(IList <CompatibleHeader> compatibleHeaders,
NegotiationContext negotiationContext,
NancyContext context)
{
var response = NegotiateResponse(compatibleHeaders, negotiationContext, context);
if (response == null)
{
context.WriteTraceLog(sb =>
sb.AppendLine("[DefaultResponseNegotiator] Unable to negotiate response - no processors returned valid response"));
response = new NotAcceptableResponse();
}
response.WithHeader("Vary", "Accept");
this.AddLinkHeader(compatibleHeaders, response, context.Request.Url);
SetStatusCode(negotiationContext, response);
SetReasonPhrase(negotiationContext, response);
AddCookies(negotiationContext, response);
if (response is NotAcceptableResponse)
{
return(response);
}
AddContentTypeHeader(negotiationContext, response);
AddNegotiatedHeaders(negotiationContext, response);
return(response);
}
private Response ProcessAsNegotiator(object routeResult, NancyContext context)
{
context.WriteTraceLog(sb => sb.AppendLine("[DefaultRouteInvoker] Processing as negotiation"));
var negotiator =
GetNegotiator(routeResult, context);
context.WriteTraceLog(sb =>
{
var allowableFormats = negotiator.NegotiationContext
.PermissableMediaRanges
.Select(mr => mr.ToString())
.Aggregate((t1, t2) => t1 + ", " + t2);
var acceptFormants = context.Request.Headers["accept"]
.Aggregate((t1, t2) => t1 + ", " + t2);
sb.AppendFormat("[DefaultRouteInvoker] Accept header: {0}\n", acceptFormants);
sb.AppendFormat("[DefaultRouteInvoker] Acceptable media ranges: {0}\n", allowableFormats);
});
var compatibleHeaders =
this.GetCompatibleHeaders(context, negotiator);
if (!compatibleHeaders.Any())
{
context.WriteTraceLog(sb => sb.AppendLine("[DefaultRouteInvoker] Unable to negotiate response - no headers compatible"));
return(new NotAcceptableResponse());
}
var response =
NegotiateResponse(compatibleHeaders, routeResult, negotiator, context);
if (response == null)
{
context.WriteTraceLog(sb => sb.AppendLine("[DefaultRouteInvoker] Unable to negotiate response - no processors returned valid response"));
response = new NotAcceptableResponse();
}
if (compatibleHeaders.Count() > 1)
{
response.WithHeader("Vary", "Accept");
}
AddLinkHeaders(context, compatibleHeaders, response);
if (!(response is NotAcceptableResponse))
{
AddNegotiatedHeaders(negotiator, response);
}
if (negotiator.NegotiationContext.StatusCode.HasValue)
{
response.StatusCode = negotiator.NegotiationContext.StatusCode.Value;
}
return(response);
}
/// <summary>
/// Creates a response from the compatible headers.
/// </summary>
/// <param name="compatibleHeaders">The compatible headers.</param>
/// <param name="negotiationContext">The negotiation context.</param>
/// <param name="context">The context.</param>
/// <returns>A <see cref="Response"/>.</returns>
private static Response CreateResponse(
IList<CompatibleHeader> compatibleHeaders,
NegotiationContext negotiationContext,
NancyContext context)
{
var response = NegotiateResponse(compatibleHeaders, negotiationContext, context);
if (response == null)
{
context.WriteTraceLog(sb =>
sb.AppendLine("[DefaultResponseNegotiator] Unable to negotiate response - no processors returned valid response"));
response = new NotAcceptableResponse();
}
response.WithHeader("Vary", "Accept");
AddLinkHeader(compatibleHeaders, response, context.Request.Url);
SetStatusCode(negotiationContext, response);
SetReasonPhrase(negotiationContext, response);
AddCookies(negotiationContext, response);
if (response is NotAcceptableResponse)
{
return response;
}
AddContentTypeHeader(negotiationContext, response);
AddNegotiatedHeaders(negotiationContext, response);
return response;
}
private Response ProcessAsNegotiator(object routeResult, NancyContext context)
{
context.WriteTraceLog(sb => sb.AppendLine("[DefaultRouteInvoker] Processing as negotiation"));
var negotiator = GetNegotiator(routeResult, context);
var coercedAcceptHeaders = this.GetCoercedAcceptHeaders(context).ToArray();
context.WriteTraceLog(
sb =>
{
var allowableFormats =
negotiator.NegotiationContext.PermissableMediaRanges.Select(mr => mr.ToString())
.Aggregate((t1, t2) => t1 + ", " + t2);
var originalAccept = context.Request.Headers["accept"].Any()
? string.Join(", ", context.Request.Headers["accept"])
: "None";
var coercedAccept = coercedAcceptHeaders.Any()
? coercedAcceptHeaders.Select(h => h.Item1)
.Aggregate((t1, t2) => t1 + ", " + t2)
: "None";
sb.AppendFormat("[DefaultRouteInvoker] Original accept header: {0}\n", originalAccept);
sb.AppendFormat("[DefaultRouteInvoker] Coerced accept header: {0}\n", coercedAccept);
sb.AppendFormat("[DefaultRouteInvoker] Acceptable media ranges: {0}\n", allowableFormats);
});
var compatibleHeaders = this.GetCompatibleHeaders(coercedAcceptHeaders, context, negotiator);
if (!compatibleHeaders.Any())
{
context.WriteTraceLog(
sb => sb.AppendLine("[DefaultRouteInvoker] Unable to negotiate response - no headers compatible"));
return(new NotAcceptableResponse());
}
var response = NegotiateResponse(compatibleHeaders, routeResult, negotiator, context);
if (response == null)
{
context.WriteTraceLog(
sb =>
sb.AppendLine(
"[DefaultRouteInvoker] Unable to negotiate response - no processors returned valid response"));
response = new NotAcceptableResponse();
}
response.WithHeader("Vary", "Accept");
AddLinkHeaders(context, compatibleHeaders, response);
if (!(response is NotAcceptableResponse))
{
CheckForContentTypeHeader(negotiator, response);
AddNegotiatedHeaders(negotiator, response);
}
if (negotiator.NegotiationContext.StatusCode.HasValue)
{
response.StatusCode = negotiator.NegotiationContext.StatusCode.Value;
}
foreach (var cookie in negotiator.NegotiationContext.Cookies)
{
response.Cookies.Add(cookie);
}
return(response);
}
private Response ProcessAsNegotiator(object routeResult, NancyContext context)
{
context.WriteTraceLog(sb => sb.AppendLine("[DefaultRouteInvoker] Processing as negotiation"));
var negotiator =
GetNegotiator(routeResult, context);
context.WriteTraceLog(sb =>
{
var allowableFormats = negotiator.NegotiationContext
.PermissableMediaRanges
.Select(mr => mr.ToString())
.Aggregate((t1, t2) => t1 + ", " + t2);
var acceptFormants = context.Request.Headers["accept"]
.Aggregate((t1, t2) => t1 + ", " + t2);
sb.AppendFormat("[DefaultRouteInvoker] Accept header: {0}\n", acceptFormants);
sb.AppendFormat("[DefaultRouteInvoker] Acceptable media ranges: {0}\n", allowableFormats);
});
var compatibleHeaders =
this.GetCompatibleHeaders(context, negotiator);
if (!compatibleHeaders.Any())
{
context.WriteTraceLog(sb => sb.AppendLine("[DefaultRouteInvoker] Unable to negotiate response - no headers compatible"));
return new NotAcceptableResponse();
}
var response =
NegotiateResponse(compatibleHeaders, routeResult, negotiator, context);
if (response == null)
{
context.WriteTraceLog(sb => sb.AppendLine("[DefaultRouteInvoker] Unable to negotiate response - no processors returned valid response"));
response = new NotAcceptableResponse();
}
if (compatibleHeaders.Count() > 1)
{
response.WithHeader("Vary", "Accept");
}
AddLinkHeaders(context, compatibleHeaders, response);
if (!(response is NotAcceptableResponse))
{
AddNegotiatedHeaders(negotiator, response);
}
return response;
}
/// <summary>
/// Asynchronously seed the data store.
/// </summary>
/// <returns>
/// The <see cref="Task{Response}"/>.
/// </returns>
internal async Task <Response> SeedDataStore()
{
if (!AppConfig.Current.Backtier.IsDbSeedEnabled)
{
Logger.Info(
"Data store seed API invoked but it was disabled from configuration, cancel further processing...");
var notAcceptableResponse = new Response().WithStatusCode(HttpStatusCode.NotAcceptable);
this.HeaderInfoProvider.RegisterResponseHeaders(notAcceptableResponse);
return(notAcceptableResponse);
}
Logger.Info("Starting data store seeding");
// bind the request to the specialized model
var exchangeFileRequest = this.Bind <ExchangeFileUploadRequest>();
// make sure there is only one file
if (exchangeFileRequest.File == null)
{
var badRequestResponse = new Response().WithStatusCode(HttpStatusCode.BadRequest);
this.HeaderInfoProvider.RegisterResponseHeaders(badRequestResponse);
return(badRequestResponse);
}
// stream the file to disk
var filePath = await this.LocalFileStorage.StreamFileToDisk(exchangeFileRequest.File.Value);
// drop existing data stores
this.DropDataStoreAndPrepareNew();
// handle exchange processing
if (!this.InsertModelData(filePath, exchangeFileRequest.Password))
{
var errorResponse = new NotAcceptableResponse();
this.HeaderInfoProvider.RegisterResponseHeaders(errorResponse);
return(errorResponse);
}
// Remove the exchange file after processing (saving space)
try
{
this.LocalFileStorage.RemoveFileFromDisk(filePath);
}
catch (Exception ex)
{
// swallow exception but log it
Logger.Error(ex, "Unable to remove file");
}
try
{
// Create a jsonb for each entry in the database
this.CreateRevisionHistoryForEachEntry();
// database was succesfully seeded
this.DataStoreController
.CloneDataStore(); // create a clone of the data store for future restore support
// reset the credential cache as the underlying datastore was reset
this.WebServiceAuthentication.ResetCredentialCache();
var response = new Response().WithStatusCode(HttpStatusCode.OK);
this.HeaderInfoProvider.RegisterResponseHeaders(response);
Logger.Info("Finished the data store seed");
return(response);
}
catch (Exception ex)
{
Logger.Error(ex, "Unable to dump the datastore");
var errorResponse = new Response().WithStatusCode(HttpStatusCode.InternalServerError);
this.HeaderInfoProvider.RegisterResponseHeaders(errorResponse);
return(errorResponse);
}
}
