public IHttpActionResult Update(UpdateRestaurant model, string id)
{
IHttpActionResult httpActionResult;
ErrorsModel errors = new ErrorsModel();
Restaurants gv = this._db.Restaurants.FirstOrDefault(x => x.id == id);
if (gv == null)
{
errors.Add("Nhà hàng này không tồn tại hoặc rỗng");
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.NotFound, errors);
}
else
{
gv.name = model.name ?? model.name;
gv.address = model.address ?? model.address;
gv.type = model.type ?? model.type;
this._db.Entry(gv).State = System.Data.Entity.EntityState.Modified;
this._db.SaveChanges();
httpActionResult = Ok(new RestaurantModel(gv));
}
return(httpActionResult);
}
public IHttpActionResult Update(UpdateClass model)
{
IHttpActionResult httpActionResult;
ErrorsModel errors = new ErrorsModel();
Classes l = this._db.Classes.FirstOrDefault(x => x.Id == model.Id);
if (l == null)
{
errors.Add("Id lớp không tồn tại");
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.NotFound, errors);
}
else
{
l.Code = model.Code ?? model.Code;
l.Name = model.Name ?? model.Name;
l.HomeroomTeacher = _db.Teachers.FirstOrDefault(x => x.Id == model.HomeroomTeacher_Id) ?? _db.Teachers.FirstOrDefault(x => x.Id == model.HomeroomTeacher_Id);
l.Teacher = _db.Teachers.FirstOrDefault(x => x.Id == model.Teacher_Id) ?? _db.Teachers.FirstOrDefault(x => x.Id == model.Teacher_Id);
this._db.Entry(l).State = System.Data.Entity.EntityState.Modified;
this._db.SaveChanges();
httpActionResult = Ok(new ClassModel(l));
}
return(httpActionResult);
}
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] 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
}
private ErrorsModel GetErrorsModel(MessageException exception)
{
var errorsModel = new ErrorsModel();
errorsModel.AddError(exception.GetType().Name, exception.Message);
return(errorsModel);
}
private async Task <ApiResponse <T> > InitalizeAsync(HttpResponseMessage response)
{
StatusCode = response.StatusCode;
HasSuccessStatusCode = response.IsSuccessStatusCode;
Errors = new ErrorsModel();
Value = default(T);
var data = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
Value = JsonConvert.DeserializeObject <T>(data);
}
else
{
try
{
ErrorResponse errors = JsonConvert.DeserializeObject <ErrorResponse>(data);
Errors = errors?.Errors;
}
catch
{
Console.WriteLine(data);
}
}
return(this);
}
public IHttpActionResult Update(UpdateStudentModel model)
{
IHttpActionResult httpActionResult;
ErrorsModel errors = new ErrorsModel();
Students sv = this._db.Students.FirstOrDefault(x => x.Id == model.Id);
if (sv == null)
{
errors.Add("Không tìm thấy mã sinh viên này");
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.NotFound, errors);
}
else
{
sv.Code = model.Code ?? model.Code;
sv.Name = model.Name ?? model.Name;
sv.BirthDay = model.BirthDay ?? model.BirthDay;
sv.Address = model.Address ?? model.Address;
this._db.Entry(sv).State = System.Data.Entity.EntityState.Modified;
this._db.SaveChanges();
httpActionResult = Ok(new StudentModel(sv));
}
return(httpActionResult);
}
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 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 IHttpActionResult Create(CreateRestaurant model)
{
IHttpActionResult httpActionResult;
ErrorsModel errors = new ErrorsModel();
if (string.IsNullOrEmpty(model.name))
{
errors.Add("Tên nhà hàng là trường bắt buộc");
}
if (errors.Errors.Count == 0)
{
Restaurants t = new Restaurants();
t.id = model.id;
t.name = model.name;
t.address = model.address;
t.type = model.type;
t = _db.Restaurants.Add(t);
this._db.SaveChanges();
RestaurantModel viewModel = new RestaurantModel(t);
httpActionResult = Ok(viewModel);
}
else
{
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.BadRequest, errors);
}
return(httpActionResult);
}
public IHttpActionResult Update(UpdateTeacher model)
{
IHttpActionResult httpActionResult;
ErrorsModel errors = new ErrorsModel();
Teachers gv = this._db.Teachers.FirstOrDefault(x => x.Id == model.Id);
if (gv == null)
{
errors.Add("Mã giảng viên không tồn tại hoặc rỗng");
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.NotFound, errors);
}
else
{
gv.Code = model.Code ?? model.Code;
gv.Name = model.Name ?? model.Name;
this._db.Entry(gv).State = System.Data.Entity.EntityState.Modified;
this._db.SaveChanges();
httpActionResult = Ok(new TeacherModel(gv));
}
return(httpActionResult);
}
public IHttpActionResult Create(CreateTeacher model)
{
IHttpActionResult httpActionResult;
ErrorsModel errors = new ErrorsModel();
if (string.IsNullOrEmpty(model.Code))
{
errors.Add("Mã giảng viên là trường bắt buộc");
}
if (string.IsNullOrEmpty(model.Name))
{
errors.Add("Tên giảng viên là trường bắt buộc");
}
if (errors.Errors.Count == 0)
{
Teachers t = new Teachers();
t.Code = model.Code;
t.Name = model.Name;
t = _db.Teachers.Add(t);
this._db.SaveChanges();
TeacherModel viewModel = new TeacherModel(t);
httpActionResult = Ok(viewModel);
}
else
{
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.BadRequest, errors);
}
return(httpActionResult);
}
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());
}
private async Task <ApiResponse <T> > InitalizeAsync(HttpResponseMessage response)
{
StatusCode = response.StatusCode;
HasSuccessStatusCode = response.IsSuccessStatusCode;
Errors = new ErrorsModel();
Value = default(T);
var data = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
try
{
Value = JsonSerializer.Deserialize <T>(data, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
});
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
else
{
try
{
ErrorResponse errors = JsonSerializer.Deserialize <ErrorResponse>(data, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
});
Errors = errors?.Errors;
}
catch (Exception ex)
{
Errors = new ErrorsModel
{
Other = new string[]
{
data
}
};
}
}
return(this);
}
public IHttpActionResult Create(CreateAccountModel acc)
{
IHttpActionResult httpActionResult;
Accounts account = new Accounts()
{
UserName = acc.username,
Email = acc.email,
};
IdentityResult result = _userManager.Create(account, acc.password);
/*
*
*/
if (!result.Succeeded)
{
ErrorsModel error = new ErrorsModel();
error.Errors = result.Errors.ToList();
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.BadRequest, error);
}
else
{
var result_2 = _userManager.AddToRole(account.Id, "User");
if (!result_2.Succeeded)
{
ErrorsModel error = new ErrorsModel();
error.Errors = result.Errors.ToList();
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.BadRequest, error);
}
else
{
AccountModel accountModel = new AccountModel(account);
httpActionResult = Ok(accountModel);
}
}
return(httpActionResult);
}
public IHttpActionResult GetById(int id)
{
IHttpActionResult httpActionResult;
var sv = _db.Students.FirstOrDefault(x => x.Id == id);
if (sv == null)
{
ErrorsModel errors = new ErrorsModel();
errors.Add("Không tìm thấy mã sinh viên này");
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.NotFound, errors);
}
else
{
httpActionResult = Ok(new StudentModel(sv));
}
return(httpActionResult);
}
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 IHttpActionResult GetById(int id)
{
IHttpActionResult httpActionResult;
var l = _db.Classes.FirstOrDefault(x => x.Id == id);
if (l == null)
{
ErrorsModel errors = new ErrorsModel();
errors.Add("Không tìm thấy lớp này");
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.NotFound, errors);
}
else
{
httpActionResult = Ok(new ClassModel(l));
}
return(httpActionResult);
}
public IHttpActionResult GetById(int id)
{
IHttpActionResult httpActionResult;
var gv = _db.Teachers.FirstOrDefault(x => x.Id == id);
if (gv == null)
{
ErrorsModel errors = new ErrorsModel();
errors.Add("Không tìm thấy giảng viên này");
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.NotFound, errors);
}
else
{
httpActionResult = Ok(new TeacherModel(gv));
}
return(httpActionResult);
}
public IHttpActionResult GetById(string id)
{
IHttpActionResult httpActionResult;
var gv = _db.Restaurants.FirstOrDefault(x => x.id == id);
if (gv == null)
{
ErrorsModel errors = new ErrorsModel();
errors.Add("Không tìm thấy nhà hàng này");
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.NotFound, errors);
}
else
{
httpActionResult = Ok(new RestaurantModel(gv));
}
return(httpActionResult);
}
public IHttpActionResult Create(CreateClass model)
{
IHttpActionResult httpActionResult;
ErrorsModel errors = new ErrorsModel();
if (string.IsNullOrEmpty(model.Code))
{
errors.Add("Mã lớp là trường bắt buộc");
}
if (string.IsNullOrEmpty(model.Name))
{
errors.Add("Tên lớp là trường bắt buộc");
}
if (_db.Teachers.FirstOrDefault(m => m.Id == model.HomeroomTeacher_Id) == null)
{
errors.Add("Id giảng viên chu nhiệm không tồn tại");
}
if (errors.Errors.Count == 0)
{
Classes l = new Classes();
l.Code = model.Code;
l.Name = model.Name;
l.HomeroomTeacher = _db.Teachers.FirstOrDefault(x => x.Id == model.HomeroomTeacher_Id);
l.Teacher = _db.Teachers.FirstOrDefault(x => x.Id == model.Teacher_Id);
l = _db.Classes.Add(l);
this._db.SaveChanges();
ClassModel viewModel = new ClassModel(l);
httpActionResult = Ok(viewModel);
}
else
{
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.BadRequest, errors);
}
return(httpActionResult);
}
public IHttpActionResult Create(CreateStudentMdoel model)
{
IHttpActionResult httpActionResult;
ErrorsModel errors = new ErrorsModel();
if (string.IsNullOrEmpty(model.Code))
{
errors.Add("Mã sinh viên là trường bắt buộc");
}
if (string.IsNullOrEmpty(model.Name))
{
errors.Add("Tên sinh viên là trường bắt buộc");
}
if (_db.Classes.FirstOrDefault(m => m.Id == model.Class_Id) == null)
{
errors.Add("Không tìm thấy lớp này");
}
if (errors.Errors.Count == 0)
{
Students sv = new Students();
sv.Code = model.Code;
sv.Name = model.Name;
sv.BirthDay = model.BirthDay;
sv.Address = model.Address;
sv = _db.Students.Add(sv);
this._db.SaveChanges();
StudentModel viewModel = new StudentModel(sv);
httpActionResult = Ok();
}
else
{
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.BadRequest, errors);
}
return(httpActionResult);
}
public static async Task AddOrUpdateAsync_NotValid_ReturnsExpectedResponse(
[Frozen] Mock <IDefaultDeliveryDateService> service,
[Frozen] CallOffId callOffId,
CatalogueItemId catalogueItemId,
Order order,
DefaultDeliveryDateModel model,
[Frozen] Mock <IDefaultDeliveryDateValidator> validator,
ErrorsModel errors,
DefaultDeliveryDateController controller)
{
service.Setup(o => o.GetOrder(callOffId, catalogueItemId)).ReturnsAsync(order);
validator.Setup(v => v.Validate(model, order.CommencementDate)).Returns((false, errors));
var response = await controller.AddOrUpdateAsync(callOffId, catalogueItemId, model);
service.Verify(o => o.GetOrder(callOffId, catalogueItemId));
response.Should().BeOfType <BadRequestObjectResult>();
response.As <BadRequestObjectResult>().Value.Should().Be(errors);
}
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 IHttpActionResult Delete(string id)
{
IHttpActionResult httpActionResult;
ErrorsModel errors = new ErrorsModel();
Restaurants gv = this._db.Restaurants.FirstOrDefault(x => x.id == id);
if (gv == null)
{
errors.Add("Nhà hàng này không tồn tại hoặc rỗng");
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.NotFound, errors);
}
else
{
this._db.Entry(gv).State = System.Data.Entity.EntityState.Deleted;
this._db.SaveChanges();
httpActionResult = Ok(new RestaurantModel(gv));
}
return(httpActionResult);
}
/// <summary>
/// Initialize a new instance of the <see cref="SecurityController"/> class.
/// </summary>
/// <param name="model">Database context to use.</param>
public SecurityController(ErrorsModel model)
{
this.Model = model;
}
