public async Task <JsonResult> Delete(RequestById model)
{
ResJsonOutput result = new ResJsonOutput();
try
{
if (ModelState.IsValid)
{
result = await PostDataAsync("/API/Products/DeleteProduct", new RequestById { ProductId = model.ProductId });
if (result.Status.IsSuccess)
{
return(Json(new { Success = true, Message = "Product deleted successfully." }));
}
}
else
{
ViewBag.ErrMsg = GetModelStateErrors(ModelState);
}
}
catch (Exception)
{
throw;
}
return(Json(new AjaxResposnse {
Message = result.Status.Message
}));
}
public async Task <IActionResult> StartLesson([FromBody] RequestById request)
{
var user = HttpContext.User.Claims.ElementAt(0);
var lesson = await _lessonService.StartLessonAsync(
request.Id, uint.Parse(user.Value)
);
if (!String.IsNullOrEmpty(lesson.Error))
{
return(BadRequest(
new ErrorPayload
{
Error = lesson.Error
}
));
}
var payload = new NamePayload
{
Id = lesson.Id,
Name = lesson.Name
};
return(Ok(payload));
}
public IActionResult DeleteVideoById([FromBody] RequestById request)
{
try
{
var video = _fileSaveRepository.GetById(request.Id);
if (video == null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "Video not found"
}));
}
var response = _fileSaveServices.DeleteFileSave(video);
if (response != "OK")
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = response
}));
}
return(Ok(response));
}
catch (Exception e)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = $"Server Error: {e.Message}"
}));
}
}
public ActionResult Get(RequestById request)
{
var place = dbContext.Places.Where(p => p.Id == request.Id).FirstOrDefault();
//If null return empty object
var output = place == null ? new ObjectViewModel() : (ObjectViewModel)place;
return(Json(output));
}
public ActionResult GetVideoById([FromBody] RequestById request)
{
var response = _fileSaveRepository.GetById(request.Id);
if (response == null)
{
return(BadRequest("Video not found"));
}
return(File(response.FileData, response.FileType));
}
//[Authorize(AuthenticationSchemes = "Bearer", Roles = RoleDefine.Admin)]
public IActionResult GetUserById([FromBody] RequestById request)
{
var response = _userRepository.FindById(request.Id);
if (response == null)
{
return(BadRequest("User not found"));
}
return(Ok(response));
}
public async Task <ActionResult <Users> > Delete(RequestById req)
{
var delUser = await _mediator.Send(new DeleteUserQuery(req.Id));
if (delUser)
{
return(Ok(true));
}
return(BadRequest());
}
public async Task <IActionResult> Get([FromQuery] RequestById req)
{
var university = await _mediator.Send(new GetUniversityByIdQuery(req.Id));
if (university != null)
{
return(Ok(university));
}
return(NoContent());
}
public async Task <ActionResult <University> > Delete([FromQuery] RequestById req)
{
var delUniversity = await _mediator.Send(new DeleteUniversityQuery(req.Id));
if (delUniversity)
{
return(Ok(true));
}
return(BadRequest());
}
public async Task <IActionResult> Get([FromQuery] RequestById req)
{
var user = await _mediator.Send(new GetUserByIdQuery(req.Id));
if (user != null)
{
return(Ok(user));
}
return(NoContent());
}
public ActionResult <ResJsonOutput> GetProductDetails([FromBody] RequestById model)
{
ResJsonOutput result = new ResJsonOutput();
try
{
result.Data = product.Get(model.ProductId);
result.Status.IsSuccess = true;
}
catch (Exception ex)
{
result = GetException(ex);
}
return(result);
}
public async Task <IActionResult> GetTypesByCategory([FromQuery] RequestById request)
{
var types = await _lessonService.GetTypesByCategoryAsync(request.Id);
var payload = new NameListPayload
{
Names = types.Select(type => new NamePayload
{
Id = type.Id,
Name = type.Name
}).ToList()
};
return(Ok(payload));
}
public ActionResult <ResJsonOutput> DeleteProduct([FromBody] RequestById model)
{
ResJsonOutput result = new ResJsonOutput();
try
{
Product _product = product.Get(model.ProductId);
product.Delete(_product);
result.Status.IsSuccess = true;
}
catch (Exception ex)
{
result = GetException(ex);
}
return(result);
}
public async Task <IActionResult> GetByTypeAll([FromQuery] RequestById request)
{
var lessons = await _lessonService.GetByTypeAllAsync(request.Id);
var payload = lessons.Select(
lesson => new LessonListPayload
{
Id = lesson.Id,
Name = lesson.Name,
OwnerId = lesson.OwnerId,
OwnerName = lesson.OwnerName,
State = lesson.State,
BadgeBase64 = $"data:image/png;base64,{System.Convert.ToBase64String(lesson.Badge)}",
Status = lesson.Status,
Modified = lesson.Modified
}).ToList();
return(Ok(payload));
}
public async Task <IActionResult> GetLesson([FromQuery] RequestById request)
{
var lesson = await _lessonService.GetAsync(
request.Id,
HttpContext.User.Claims.Any()?(uint.Parse(HttpContext.User.Claims.ElementAt(0).Value)) : 0
);
if (!String.IsNullOrEmpty(lesson.Error))
{
return(BadRequest(
new ErrorPayload
{
Error = lesson.Error
}
));
}
var payload = new LessonPayload
{
OwnerId = lesson.OwnerId,
OwnerName = lesson.OwnerName,
State = lesson.State,
Id = lesson.Id,
Name = lesson.Name,
Category = lesson.Category,
Description = lesson.Description,
Type = lesson.Type,
Status = lesson.Status,
Progress = lesson.Progress,
Assignments = lesson.Assignments.Select(assignment => new AssignmentPayload
{
Id = assignment.Id,
Description = assignment.Description,
Experience = assignment.Experience,
Progress = assignment.Progress,
}).ToList(),
BadgeBase64 = $"data:image/png;base64,{System.Convert.ToBase64String(lesson.Badge)}"
};
return(Ok(payload));
}
public async Task ReturnsResult()
{
var optionsBuilder = new DbContextOptionsBuilder().UseInMemoryDatabase("test");
var options = optionsBuilder.Options;
Func <Task <FakeDbContext> > dbContextFactory = () => Task.FromResult(new FakeDbContext(options));
var instance =
new FuncFetchFromEntityFrameworkByInt32IdRequestHandler <RequestById, FakeDbContext, FakeAddAuditDbSet, int>(
dbContextFactory,
context => context.FakeAddAudit,
set => set.Id);
var request = new RequestById
{
Id = 1
};
var response = await instance.Handle(
request,
CancellationToken.None).ConfigureAwait(false);
}
public async Task <IActionResult> Profile([FromQuery] RequestById request)
{
var user = await _userService.GetProfileAsync(request.Id);
if (!String.IsNullOrEmpty(user.Error))
{
return(BadRequest(
new ErrorPayload
{
Error = user.Error
}
));
}
return(Ok(
new ProfilePayload
{
Id = user.Id,
Name = user.Name,
Level = user.Level,
Experience = user.Experience,
NextExperience = user.NextExperience,
Role = user.Role,
Lessons = user.Lessons.Select(lesson => new LessonPayload
{
OwnerId = lesson.OwnerId,
OwnerName = lesson.OwnerName,
State = lesson.State,
Id = lesson.Id,
Name = lesson.Name,
Category = lesson.Category,
Description = lesson.Description,
Type = lesson.Type,
Status = lesson.Status,
Progress = lesson.Progress,
BadgeBase64 = $"data:image/png;base64,{System.Convert.ToBase64String(lesson.Badge)}"
}).ToList()
}
));
}
public async Task <IActionResult> Get([FromBody] RequestById request)
{
var user = await _userService.GetAsync(request.Id);
if (!String.IsNullOrEmpty(user.Error))
{
return(BadRequest(
new ErrorPayload
{
Error = user.Error
}
));
}
return(Ok(
new NamePayload
{
Id = user.Id,
Name = user.Name
}
));
}
public IActionResult GetUserById([FromBody] RequestById request)
{
try
{
var response = _userRepository.FindById(request.Id);
if (response == null)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = "User not found"
}));
}
return(Ok(response));
}
catch (Exception e)
{
return(BadRequest(new ErrorViewModel
{
ErrorCode = "400",
ErrorMessage = $"Server Error: {e.Message}"
}));
}
}
public string updateEmployee(int id, NameValueCollection new_data)
{
// update an employee record
RequestById bData = new RequestById();
bData.token = Token;
bData.output = OutPut;
employee objrequest = new employee();
objrequest.method = "UPDATE";
objrequest.module = "staff.employees";
objrequest.nick_name = "sherwood";
objrequest.id = id.ToString();
bData.request = objrequest;
NameValueCollection RequestApi = new NameValueCollection();
JavaScriptSerializer js = new JavaScriptSerializer();
RequestApi.Add("data", js.Serialize(bData));
return perform_request(RequestApi);
}
