public IActionResult Put(string id, [FromBody] object document)
{
var documentOriginal = documentService.Get(DataSetName, id);
if (documentOriginal == null)
{
return(new HttpStatusCodeWithErrorResult(StatusCodes.Status404NotFound,
string.Format(DocumentResources.DocumentWithId_0_DoesNotFound, id)));
}
var validateResult = documentService.ValidateUpdateDocument(DataSetName, document);
if (validateResult.IsFailure)
{
return(BadRequest(ErrorsModel.Create(validateResult.Error)));
}
var newId = documentService.GetIdValue(DataSetName, document) ?? id;
var updateResult = documentService.Update(DataSetName, id, documentOriginal, newId, document);
if (updateResult.IsFailure)
{
return(HttpErrorResult(StatusCodes.Status400BadRequest, updateResult.Error));
}
return(new OkObjectResult(documentService.Get(DataSetName, newId)?.DocumentObject));
}
public override void OnActionExecuting(ActionExecutingContext context)
{
if (!context.HttpContext.Request.Headers.ContainsKey(DataSetHeader) || string.IsNullOrEmpty(context.HttpContext.Request.Headers[DataSetHeader]))
{
context.Result = new BadRequestObjectResult(
new SDK.Net.Models.ErrorsModel
{
Errors = new List <string> {
string.Format(Missing_0_Header, DataSetHeader)
}
});
return;
}
var dataSetName = context.HttpContext.Request.Headers[DataSetHeader];
var globalStore = (IGlobalStoreManager)context.HttpContext.RequestServices.GetService(typeof(IGlobalStoreManager));
if (!globalStore.DataSets.IsExist(dataSetName))
{
context.Result = new BadRequestObjectResult(ErrorsModel.Create(string.Format(DataSet_0_NotFound, dataSetName)));
return;
}
context.RouteData.Values.Add(DataSetHeader, dataSetName);
base.OnActionExecuting(context);
}
public IActionResult Post([FromBody] object document)
{
var validateResult = documentService.ValidateDocument(DataSetName, document);
if (validateResult.IsFailure)
{
return(BadRequest(ErrorsModel.Create(validateResult.Error)));
}
var id = documentService.GetIdValue(DataSetName, document);
if (documentService.IsExists(DataSetName, id))
{
return(new HttpStatusCodeWithErrorResult(StatusCodes.Status409Conflict,
string.Format(DocumentResources.DocumentWithId_0_IsAlreadyExist, id)));
}
var indexResult = documentService.Index(DataSetName, document, id);
if (indexResult.IsFailure)
{
return(HttpErrorResult(StatusCodes.Status400BadRequest, indexResult.Error));
}
return(new StatusCodeResult(StatusCodes.Status201Created));
}
public IActionResult Post([FromBody] DataSet dataSet)
{
dataSetService.ThrowIfDataSetIsBusy(dataSet.Name);
if (dataSetService.IsExists(dataSet.Name))
{
return(HttpErrorResult(StatusCodes.Status409Conflict,
string.Format(DataSetResources.DataSet_0_IsAlreadyExist, dataSet.Name)));
}
// In rare cases it could be string instead of object
if (dataSet.SampleDocument is string)
{
dataSet.SampleDocument = JsonConvert.DeserializeObject((string)dataSet.SampleDocument);
}
if (dataSet.SampleDocument == null)
{
return(BadRequest(ErrorsModel.Create(DataSetResources.SampleDocumentIsEmpty)));
}
var validateResult = documentService.ValidateSampleDocument(dataSet);
if (validateResult.IsFailure)
{
return(BadRequest(ErrorsModel.Create(validateResult.Error)));
}
dataSetService.Create(dataSet, withSchema: false);
return(new StatusCodeResult(StatusCodes.Status201Created));
}
public void OnException(ExceptionContext context)
{
var message = "Internal Server Error";
if (context.Exception is Common.Exceptions.SlambyException)
{
message = context.Exception.Message;
}
var response = ErrorsModel.Create(message);
context.Result = new ObjectResult(response)
{
StatusCode = 500,
DeclaredType = typeof(ErrorsModel)
};
logger.LogError(new EventId(0), context.Exception, "GlobalExceptionFilter");
//log the request for this error if it had
// Replace Request Body with own MemoryStream
var originalRequestBody = context.HttpContext.Request.Body;
var requestBodyStream = new MemoryStream();
context.HttpContext.Request.Body.CopyTo(requestBodyStream);
requestBodyStream.Seek(0, SeekOrigin.Begin);
logger.LogInformation(RequestLoggerHelper.Format(context.HttpContext.Request, "GlobalExceptionFilter", requestBodyStream, siteConfig.BaseUrlPrefix));
requestBodyStream.Seek(0, SeekOrigin.Begin);
context.HttpContext.Request.Body = requestBodyStream;
context.Exception = null; // mark exception as handled
}
public async Task Invoke(HttpContext context)
{
if (context.Request.Path == "/")
{
await next.Invoke(context);
return;
}
var jsonResponse = JsonConvert.SerializeObject(
ErrorsModel.Create("Endpoint not found"),
Formatting.Indented);
context.Response.StatusCode = StatusCodes.Status404NotFound;
await context.Response.WriteAsync(jsonResponse);
}
public async Task <IActionResult> Post([FromBody] ChangeLicense model)
{
if (string.IsNullOrEmpty(model.License))
{
return(BadRequest(ErrorsModel.Create(GlobalResources.LicenseIsEmpty)));
}
var validation = await licenseManager.SaveAsync(model.License);
if (validation.Any())
{
return(BadRequest(ErrorsModel.Create(validation.Select(v => $"{v.Message} {v.HowToResolve}"))));
}
return(Ok());
}
public override void OnActionExecuting(ActionExecutingContext context)
{
if (context.HttpContext.Request.Headers.ContainsKey(Constants.SdkVersionHeader))
{
var sdkVersion = TakeMajorMinor(context.HttpContext.Request.Headers[Constants.SdkVersionHeader].ToString());
var apiVersion = TakeMajorMinor(siteConfig.Version);
if (!string.Equals(sdkVersion, apiVersion))
{
context.Result = new Microsoft.AspNetCore.Mvc.BadRequestObjectResult(
ErrorsModel.Create(string.Format(GlobalResources.SdkApiVersionMismatch, sdkVersion, apiVersion))
);
return;
}
}
base.OnActionExecuting(context);
}
public async Task Invoke(HttpContext context, [FromServices] SiteConfig siteConfig, [FromServices] ISecretManager secretManager)
{
if (!secretManager.IsSet() && !IsPathInWhiteList(context.Request.Path))
{
var hostUrl = HostUrlHelper.GetHostUrl(context.Request, siteConfig.BaseUrlPrefix);
var model = ErrorsModel.Create(string.Format(GlobalResources.SecretIsNotSetVisit_0_ForSetup, $"{hostUrl}/setup"));
var response = JsonConvert.SerializeObject(model);
context.Response.StatusCode = StatusCodes.Status412PreconditionFailed;
context.Response.ContentType = "application/json";
context.Response.ContentLength = response.Length;
await context.Response.WriteAsync(response);
return;
}
await _next.Invoke(context);
}
public IActionResult PostWithSchema([FromBody] DataSet dataSet, [FromServices] DataSetSchemaValidatorService jsonValidator)
{
dataSetService.ThrowIfDataSetIsBusy(dataSet.Name);
if (dataSetService.IsExists(dataSet.Name))
{
return(HttpErrorResult(StatusCodes.Status409Conflict,
string.Format(DataSetResources.DataSet_0_IsAlreadyExist, dataSet.Name)));
}
// In rare cases it could be string instead of object
if (dataSet.Schema is string)
{
dataSet.Schema = JsonConvert.DeserializeObject((string)dataSet.Schema);
}
if (dataSet.Schema == null)
{
return(BadRequest(ErrorsModel.Create(DataSetResources.SchemaIsEmpty)));
}
var validateResult = jsonValidator.Validate(dataSet.Schema);
if (validateResult.Any())
{
return(BadRequest(ErrorsModel.Create(validateResult.Select(error =>
string.Format(DocumentResources.JsonSchemaValidationError_0, error)
))));
}
var validateSchemaResult = documentService.ValidateSchema(dataSet);
if (validateSchemaResult.IsFailure)
{
return(BadRequest(ErrorsModel.Create(validateSchemaResult.Error)));
}
dataSetService.Create(dataSet, withSchema: true);
return(new StatusCodeResult(StatusCodes.Status201Created));
}
public override void OnActionExecuting(ActionExecutingContext context)
{
List <string> errors = new List <string>();
var actionArguments = ((Dictionary <string, object>)context.ActionArguments);
if (actionArguments.ContainsValue(null))
{
foreach (var argument in actionArguments.Where(kv => kv.Value == null))
{
var parameterDescriptor = context.ActionDescriptor.Parameters
.Where(w => w.Name == argument.Key)
.Cast <ControllerParameterDescriptor>()
.FirstOrDefault();
if (!parameterDescriptor.ParameterInfo.HasDefaultValue)
{
errors.Add(string.Format(GlobalResources.TheArgumentCannotBeNull_0, argument.Key));
}
}
}
if (!context.ModelState.IsValid)
{
errors.AddRange(context.ModelState.SelectMany(m => m.Value.Errors.Select(e =>
{
return(string.IsNullOrEmpty(e.ErrorMessage)
? e?.Exception.Message ?? string.Empty
: e.ErrorMessage);
}
)));
}
if (errors.Any())
{
context.Result = new BadRequestObjectResult(ErrorsModel.Create(errors));
}
base.OnActionExecuting(context);
}
public IActionResult Post([FromBody] FileParser fileParser)
{
if (fileParser?.Content == null)
{
return(BadRequest(
ErrorsModel.Create(
string.Format(GlobalResources.TheArgumentCannotBeNull_0, nameof(FileParser.Content))
)));
}
var content = fileParser.Content.CleanBase64();
if (!content.IsBase64())
{
return(BadRequest(
ErrorsModel.Create(
string.Format(GlobalResources.TheArgument_0_IsNot_1_Type, nameof(FileParser.Content), "base64")
)));
}
var fieldValues = fileParserQuery.ParseDocument(content);
var result = new FileParserResult();
foreach (var field in fieldValues)
{
var key = field.Key;
var values = field.Value;
switch (key)
{
case "content_type":
result.ContentType = string.Concat(values.Cast <string>());
break;
case "content":
result.Content = string.Concat(values.Cast <string>());
break;
case "content_length":
result.ContentLength = (int)values.Cast <double>().Sum();
break;
case "language":
result.Language = string.Concat(values.Cast <string>());
break;
case "keywords":
result.Keywords = string.Concat(values.Cast <string>());
break;
case "author":
result.Author = string.Concat(values.Cast <string>());
break;
case "date":
if (values.Any())
{
var pattern = CultureInfo.InvariantCulture.DateTimeFormat.UniversalSortableDateTimePattern;
result.Date = values.Cast <DateTime>().First().ToString(pattern);
}
break;
case "title":
result.Title = string.Concat(values.Cast <string>());
break;
}
}
return(Ok(result));
}
public HttpStatusCodeWithErrorResult(int statusCode, string value) :
base(statusCode, ErrorsModel.Create(value))
{
}
public static ErrorsModel ToErrorsModel(this NestBulkResponse response)
{
return(ErrorsModel.Create(response.ToList()));
}
public static string ErrorsModelResponse(string errorMessage)
{
return(JsonConvert.SerializeObject(
ErrorsModel.Create(errorMessage),
Formatting.Indented));
}
public HttpStatusCodeWithErrorResult(int statusCode, IEnumerable <string> values) :
base(statusCode, ErrorsModel.Create(values))
{
}
internal async Task <ClientResponseWithObject <T> > SendAsync <T>(HttpMethod method, object body, string urlPart, Dictionary <string, string> queryParameters, Dictionary <string, string> headers, bool useGzip = false)
{
ClientResponseWithObject <T> clientResponse = null;
var messageHandler = new ApiHttpMessageHandler(useGzip);
var jsonSerializerSettings = new JsonSerializerSettings();
jsonSerializerSettings.Converters.Add(new StringEnumConverter());
using (var client = new HttpClient(messageHandler))
{
client.BaseAddress = _configuration.ApiBaseEndpoint;
client.Timeout = _configuration.Timeout;
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.TryAddWithoutValidation(Constants.AuthorizationHeader, string.Format("{0} {1}", Constants.AuthorizationMethodSlamby, _configuration.ApiSecret));
client.DefaultRequestHeaders.TryAddWithoutValidation(Constants.SdkVersionHeader, GetType().GetTypeInfo().Assembly.GetName().Version.ToString());
if (_configuration.ParallelLimit > 0)
{
client.DefaultRequestHeaders.TryAddWithoutValidation(Constants.ApiParallelLimitHeader, _configuration.ParallelLimit.ToString());
}
if (useGzip)
{
client.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
}
if (headers != null)
{
foreach (var header in headers)
{
client.DefaultRequestHeaders.Add(header.Key, header.Value);
}
}
HttpContent content = null;
if (body != null)
{
var json = JsonConvert.SerializeObject(body, jsonSerializerSettings);
content = new StringContent(json, Encoding.UTF8, "application/json");
if (useGzip)
{
content = new CompressedContent(content, "gzip");
}
}
else
{
content = new StringContent(string.Empty, Encoding.UTF8, "application/json");
}
HttpResponseMessage responseMsg = null;
var appendedUri = _appendQueryString(_endpoint, urlPart, queryParameters);
if (method == HttpMethod.Get)
{
responseMsg = await client.GetAsync(appendedUri);
}
else if (method == HttpMethod.Post)
{
responseMsg = await client.PostAsync(appendedUri, content);
}
else if (method == HttpMethod.Delete)
{
responseMsg = await client.DeleteAsync(appendedUri);
}
else if (method == HttpMethod.Put)
{
responseMsg = await client.PutAsync(appendedUri, content);
}
else
{
throw new NotImplementedException();
}
clientResponse = new ClientResponseWithObject <T>
{
HttpStatusCode = responseMsg.StatusCode,
IsSuccessful = responseMsg.IsSuccessStatusCode,
ServerMessage = responseMsg.ReasonPhrase
};
var respString = await responseMsg.Content.ReadAsStringAsync();
try
{
if (!string.IsNullOrEmpty(respString))
{
if (responseMsg.IsSuccessStatusCode)
{
clientResponse.ResponseObject = JsonConvert.DeserializeObject <T>(respString, jsonSerializerSettings);
}
else
{
clientResponse.Errors = JsonConvert.DeserializeObject <ErrorsModel>(respString, jsonSerializerSettings);
}
}
}
catch (JsonSerializationException ex)
{
Debug.WriteLine(ex.Message);
clientResponse.IsSuccessful = false;
clientResponse.Errors = ErrorsModel.Create("Response is not a Valid or Expected Type of JSON:\n" + respString);
}
clientResponse.ApiVersion = responseMsg.Headers.Where(header => string.Equals(header.Key, Constants.ApiVersionHeader, StringComparison.OrdinalIgnoreCase))
.SelectMany(header => header.Value)
.FirstOrDefault() ?? string.Empty;
return(clientResponse);
}
}
