public async Task <IActionResult> Delete([FromHeader] string authToken, string id)
{
if (!await _authenticationService.CheckAccess(authToken, "ppEventMgr"))
{
return(Unauthorized());
}
var ppEvent = await _ppEventService.Get(id);
if (ppEvent == null)
{
return(NotFound());
}
await _ppEventService.Delete(id);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Document deleted.",
"pp.events",
id,
null
));
return(Ok());
}
public OperationResult ReceiveData([FromBody] SubmissionProcessViewModel input)
{
Stopwatch sw = new Stopwatch();
sw.Start();
OperationResult result = new OperationResult();
result.Status = _submissionservice.ReturnLoginnerId();
sw.Stop();
//Console.WriteLine($"{sw.ElapsedMilliseconds}ms");
var first = sw.ElapsedMilliseconds;
sw.Restart();
result = _submissionservice.ReceiveSubmissionData(input, result.Status);
sw.Stop();
//Console.WriteLine($"{sw.ElapsedMilliseconds}ms");
var second = sw.ElapsedMilliseconds;
// if(ModelState.IsValid) 前端做
if (result.IsSuccessful)
{
return(result);
}
else
{
Log entity = new Log()
{
DateTime = result.DateTime
};
_logservice.Create(entity);
return(result);
}
}
public async Task <ActionResult <Order> > Create([FromHeader] string authToken, bool stockroom, OrderCreate create)
{
if (stockroom)
{
if (!await _authenticationService.CheckAccess(authToken, "orderMgr"))
{
return(Unauthorized());
}
Order created = await _orderService.CreateStockroom(create);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Order Placed",
"orders",
created.Id,
JsonSerializer.Serialize(created)
));
return(Ok(created));
}
else
{
if (!await _authenticationService.CheckAccess(authToken, "orderView"))
{
return(Unauthorized());
}
LabGroup group = await _labGroupService.GetByMemberId(AuthenticationHelpers.GetUserIdFromToken(authToken));
Order created = await _orderService.Create(create, group.Id);
group.BudgetBalance = group.BudgetBalance - (created.UnitCost * created.Quantity);
group.Transactions.Add(new Transaction(
created.Id,
"Remove",
"Order Submitted",
(created.UnitCost * created.Quantity),
DateTime.UtcNow
));
_labGroupService.Update(group, group.Id);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Order Placed",
"orders",
created.Id,
JsonSerializer.Serialize(created)
));
return(Ok(created));
}
}
// CheckMemberUrl View 重設密碼 post 傳入這裡 --input ajax要再處理
public String ResetPassword(MemberViewModel input)
{
int getMemberId = 0;
if (!VerifyPasswordResetHmacCode(input.ResetPasswordCode, out Int32 userId))
{
return("失敗");
}
else
{
getMemberId = userId;
}
input.MemberId = getMemberId;
var result = new OperationResult();
result = _memberservice.ResetPassWord(input);
if (result.IsSuccessful)
{
return("成功");
}
else
{
Log entity = new Log()
{
DateTime = result.DateTime
};
_logservice.Create(entity);
return("失敗");
}
}
public async Task Invoke(HttpContext context)
{
var request = await FormatRequest(context.Request);
var originalBodyStream = context.Response.Body;
using (var responseBody = new MemoryStream())
{
context.Response.Body = responseBody;
await _next(context);
var response = await FormatResponse(context.Response);
Log log = new Log
{
request = request,
response = response
};
await db.Create(log);
//await logRepository.Add(log);
//await unitOfWork.CompleteAsync();
await responseBody.CopyToAsync(originalBodyStream);
}
}
public void Should_Return_Log_When_Create_With_Manager_And_Specified_UserId()
{
// Arrange
var fakes = new Fakes();
var fakeHttp = fakes.FakeHttpContextAccessor(true).Object;
var fakeRepository = fakes.FakeLogRepository().Object;
var fakeUserRepository = fakes.FakeUserRepository().Object;
var hashService = new HashService();
var userService = new UserService(fakes.Mapper, fakeHttp, fakeUserRepository, hashService);
var request = fakes.Get <CreateLogRequest>().First();
var log = fakes.Get <Log>().First();
var response = fakes.Mapper.Map <LogResponse>(log);
response.Id = 999; // Mocked id when creating a new log
response.Archived = false; // By default, log is created as unarchived
response.UserId = request.UserId.Value; // UserId were specified, so it should be equal to the UserId in request
// Act
var service = new LogService(fakes.Mapper, fakeRepository, userService);
var actual = service.Create(request).Result;
response.CreatedAt = (actual.Data as LogResponse).CreatedAt;
var expected = Responses.OkResponse(null, response);
// Assert
Assert.IsType <Response>(actual);
Assert.NotNull(actual);
Assert.Equal(expected, actual, new LogResponseComparer());
}
public void Should_Create_New_Log()
{
var fakeContext = new FakeContext("CreateNewLog");
var fakeLog = new Log();
fakeLog.Name = "full name";
using (var context = new MainContext(fakeContext.FakeOptions))
{
var repository = new LogRepository(context);
var mockValidator = new Mock <IValidator <Log> >(MockBehavior.Strict);
mockValidator
.Setup(x => x.Validate(fakeLog))
.Returns(new FluentValidation.Results.ValidationResult());
var service = new LogService(repository, mockValidator.Object, context);
var actual = service.Create(fakeLog);
var id = actual.Id;
Assert.NotEqual(0, id);
repository.Dispose();
}
}
public IActionResult Post(LogErrorCreateRequestModel model)
{
try
{
if (model == null)
{
return(BadRequest());
}
LogCreateRequestModel createErrorModel = _service.ParseExceptionToExceptionModel(model);
if (createErrorModel == null)
{
return(BadRequest(model));
}
var result = _service.Create(createErrorModel);
return(Ok(result));
}
catch (Exception e)
{
try { _service.SendLogError(e); } catch (System.Exception ex) { return(StatusCode(503, ex.Message)); }
return(StatusCode(503, e));
}
}
public async Task <ActionResult <Role> > Create([FromHeader] string authToken, RoleCreate role)
{
if (!await _authenticationService.CheckAccess(authToken, "roleMgr"))
{
return(Unauthorized());
}
Role created = await _roleService.Create(role);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Document created.",
"auth.roles",
created.Id,
JsonSerializer.Serialize(created)
));
return(Ok(role));
}
public async Task <ActionResult <LabCourse> > Create([FromHeader] string authToken, LabCourseCreate create)
{
if (!await _authenticationService.CheckAccess(authToken, "courseMgr"))
{
return(Unauthorized());
}
LabCourse created = await _labCourseService.Create(create);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Course created.",
"labCourses",
created.Id,
JsonSerializer.Serialize(created)
));
return(Ok(created));
}
public async Task <ActionResult <LabBench> > Create([FromHeader] string authToken, LabBenchCreate bench)
{
if (!await _authenticationService.CheckAccess(authToken, "benchMgr"))
{
return(Unauthorized());
}
LabBench created = await _labBenchService.Create(bench);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Document created.",
"labBenches",
created.Id,
JsonSerializer.Serialize(created)
));
return(Ok(created));
}
//toDO.... HttpResposeMessage.... Request.CreateResponse(HttpStatusCode.OK,)
public string CreateMember([FromBody] MemberViewModel input)
{
// if(ModelState.IsValid) 前端做
var result = new OperationResult();
result = _memberService.Create(input);
if (result.IsSuccessful)
{
return("成功");
}
else
{
Log entity = new Log()
{
//Path = result.WriteLog(HostingEnvironment.MapPath("~/Assets/Log/")),
DateTime = result.DateTime
};
_logservice.Create(entity);
return("失敗");
}
}
public void Should_Return_BadRequest_When_Create_And_Exception_Is_Thrown()
{
// Arrange
var fakes = new Fakes();
var fakeHttp = fakes.FakeHttpContextAccessor(true).Object;
var fakeRepository = fakes.FakeLogRepositoryException().Object;
var fakeUserRepository = fakes.FakeUserRepository().Object;
var hashService = new HashService();
var userService = new UserService(fakes.Mapper, fakeHttp, fakeUserRepository, hashService);
var request = fakes.Get <CreateLogRequest>().First();
var expected = Responses.BadRequestResponse("Test Exception");
// Act
var service = new LogService(fakes.Mapper, fakeRepository, userService);
var actual = service.Create(request).Result;
// Assert
Assert.ThrowsAnyAsync <Exception>(() => service.Create(request));
Assert.IsType <Response>(actual);
Assert.NotNull(actual);
Assert.Equal(expected, actual, new ResponseComparer());
}
public ActionResult <User> LogIn(string email, string password)
{
try
{
User user = _userService.Validate(email, password);
if (user == null)
{
return(NotFound("Usuario no encontrado."));
}
//Log de log in
_logService.Create(new Log {
UserId = user.Id, TimeStamp = DateTime.Now, Action = "Inicio de Sesion."
});
return(Ok(user));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(Problem(ex.ToString()));
}
}
public async Task <ActionResult <LabGroup> > Create([FromHeader] string authToken, LabGroupCreate create)
{
if (!await _authenticationService.CheckAccess(authToken, "groupMgr"))
{
return(Unauthorized());
}
List <string> members = new List <string>();
foreach (string techId in create.Members)
{
User temp = await _userService.GetByTechId(techId);
members.Add(temp.Id);
}
LabCourse course = await _labCourseService.Get(create.LabCourseId);
LabGroupCreate editCreate = create;
editCreate.Members = members;
editCreate.Budget = course.InitialBudget;
editCreate.BudgetBalance = course.InitialBudget;
editCreate.GroupNumber = (course.LabGroups == null) ? 1 : course.LabGroups.Count + 1;
editCreate.Transactions = new List <Transaction>();
editCreate.Transactions.Add(new Transaction(null, "Add", "Initial Budget", course.InitialBudget, DateTime.UtcNow));
LabGroup created = await _labGroupService.Create(editCreate);
await _labCourseService.AddGroup(course, created.Id);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Group created.",
"labGroups",
created.Id,
JsonSerializer.Serialize(created)
));
foreach (string id in created.Members)
{
User temp = await _userService.Get(id);
temp.Permissions.Add("61db5dde3fb8d66a6bbdde3b");
temp.Permissions.Add("61db59a03fb8d66a6bbdde34");
temp.Permissions.Add("61db5a813fb8d66a6bbdde36");
await _tokenService.InvalidateUserTokens(temp.Id);
_userService.Update(temp.Id, temp);
}
return(Ok(created));
}
public void CreateLogTest(string title, string details, int systemId, int levelId)
{
var fakeContext = new FakeContext();
fakeContext.FillWithAll();
using (ApplicationDbContext dbContext = new ApplicationDbContext(fakeContext.FakeOptions)) {
var fakeLog = new LogModel()
{
Title = title, Details = details, CreatedAt = DateTime.UtcNow, SystemId = systemId, LevelId = levelId
};
var service = new LogService(dbContext);
service.Create(fakeLog);
var result = dbContext.Set <LogModel>().FirstOrDefault(l => l.Title == title);
result.Should().NotBeNull();
}
}
public void Should_Get_Log_Properties_After_Creation()
{
var fakeContext = new FakeContext("LogGetter");
fakeContext.FillWithAll();
using (var context = new MainContext(fakeContext.FakeOptions))
{
var logbuilder = new LogBuilder(context);
var repository = new LogRepository(context);
var validator = new LogValidator();
var service = new LogService(repository, validator, context);
var logTest = new Log();
logTest.Name = "Error testing";
logTest.Description = "Testing log getter and setters";
logTest.UserId = 1;
logTest.LevelId = 2;
logTest.LayerId = 2;
logTest.EnvironmentId = 2;
logTest.StatusId = 1;
logTest.CreatedAt = new DateTime(2020, 05, 21, 14, 35, 01);
service.Create(logTest);
var createdLog = (from l in service.GetAllFull()
where l.Name == "Error testing"
select l).FirstOrDefault();
Assert.Equal("Error testing", createdLog.Name);
Assert.Equal("Testing log getter and setters", createdLog.Description);
Assert.Equal(1, createdLog.UserId);
Assert.Equal(2, createdLog.LevelId);
Assert.Equal(2, createdLog.LayerId);
Assert.Equal(2, createdLog.EnvironmentId);
Assert.Equal(1, createdLog.StatusId);
Assert.Equal(new DateTime(2020, 05, 21, 14, 35, 01), createdLog.CreatedAt);
Assert.Equal("José da Silva", createdLog.User.FullName);
Assert.Equal("Warning", createdLog.Level.Name);
Assert.Equal("Frontend", createdLog.Layer.Name);
Assert.Equal("Homologação", createdLog.Environment.Name);
Assert.Equal("Arquivado", createdLog.Status.Name);
context.Dispose();
}
}
public IActionResult Purchase(PurchaseProduct purchase)
{
try
{
//Acá iría toda la logica de la compra del producto.
//Como pago y envio de mail.
//Logueo la compra.
_logService.Create(new Log {
UserId = purchase.User.Id, TimeStamp = DateTime.Now, Action = $"Compra del producto {purchase.Product.Id}"
});
return(Ok("Producto comprado."));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
}
return(NoContent());
}
public async Task <ActionResult <LabGroup> > Create([FromHeader] string authToken, QuizQuestionCreate create)
{
if (!await _authenticationService.CheckAccess(authToken, "userMgr"))
{
return(Unauthorized());
}
QuizQuestion created = await _quizQuestionService.Create(create);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Quiz Question created.",
"quizQuestions",
created.Id,
JsonSerializer.Serialize(created)
));
return(Ok(created));
}
public async Task <IActionResult> CreateBook([FromBody] LogBook book)
{
var inserted = await _logService.Create(book);
return(Ok(inserted));
}
public async Task <ActionResult> SwipeIn([FromHeader] string authToken, string techId, string eventId)
{
if (!await _authenticationService.CheckAccess(authToken, "ppSwipe"))
{
return(Unauthorized());
}
User user = await _userService.GetByTechId(techId);
PPEvent ppEvent = await _ppEventService.Get(eventId);
if (user == null)
{
user = await _userService.Create(new User(
null,
techId,
null,
null,
null,
null,
null,
null,
null,
null,
false,
null,
null,
null,
null,
null,
new List <PPUserEntry>(),
null,
"Active - ProPoint Account Creation"
));
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"User created for Pro Point Event.",
"auth.users",
user.Id,
JsonSerializer.Serialize(user)
));
//return NotFound("tech id not found");
}
if (ppEvent == null)
{
return(NotFound("pro point event not found"));
}
if (user.ProPoints.Find(entry => entry.EventId == eventId) != null)
{
return(Problem("user is already checked in"));
}
user.ProPoints.Add(new PPUserEntry(
eventId,
DateTime.UtcNow,
null,
null,
"Active"
));
_userService.Update(user.Id, user);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"User checked in for Pro Point Event.",
"auth.users",
user.Id,
JsonSerializer.Serialize(user)
));
return(Ok());
}
public ActionResult <Trazabilidad> Create(Trazabilidad trazabilidad)
{
_logService.Create(trazabilidad);
return(Ok(trazabilidad));
}
public ActionResult <Log> Create(Log log)
{
_logService.Create(log);
return(CreatedAtRoute("GetLog", new { id = log.Id.ToString() }, log));
}
