public RootQuery(PunchclockContext context)
{
Field <ListGraphType <EntryType> >("entries", resolve: ctx =>
{
var user = (ClaimsPrincipal)ctx.UserContext;
var isUserAuthenticated = ((ClaimsIdentity)user.Identity).IsAuthenticated;
if (!isUserAuthenticated)
{
throw new ExecutionError("Not authenticated");
}
if (user.IsInRole("admin"))
{
return(context.Entries.Include(e => e.Employee).ThenInclude(e => e.Department));
}
return(context.Entries.Where(e => e.Employee.UserName == user.Identity.Name).Include(e => e.Employee)
.ThenInclude(e => e.Department));
});
Field <ListGraphType <EmployeeType> >("employees", resolve: ctx =>
context.Employees.Include(e => e.Department)
.Include(e => e.Entries));
Field <ListGraphType <DepartmentType> >("departments", resolve: ctx =>
context.Departments);
Field <DateTimeGraphType>("lastCheckIn", resolve: ctx =>
{
var user = (ClaimsPrincipal)ctx.UserContext;
var isUserAuthenticated = ((ClaimsIdentity)user.Identity).IsAuthenticated;
if (!isUserAuthenticated)
{
throw new ExecutionError("Not authenticated");
}
var lastEntry = context.Entries.Where(e => e.Employee.UserName == user.Identity.Name).OrderByDescending(e => e.Id).FirstOrDefault();
return(lastEntry switch
{
{ CheckOut: null, CheckIn: var checkIn } => checkIn as DateTime?,
public RootMutation(PunchclockContext context, UserManager <Employee> userManager,
SignInManager <Employee> signInManager,
IConfiguration configuration)
{
async Task <JwtOutput> CreateTokenAsync(UserInput user)
{
var employee = await userManager.FindByEmailAsync(user.Email);
if (employee is null)
{
throw new ExecutionError("User does not exist");
}
var result = await signInManager.CheckPasswordSignInAsync(employee, user.Password, false);
if (!result.Succeeded)
{
throw new ExecutionError("Wrong password");
}
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, user.Email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.UniqueName, user.Email),
new Claim(ClaimTypes.Role, employee.Email == "*****@*****.**" ? "admin" : "user"),
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration["Tokens:Key"]));
var cred = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
configuration["Tokens:Issuer"],
configuration["Tokens:Audience"],
claims,
expires: DateTime.UtcNow.AddMinutes(30),
signingCredentials: cred);
return(new JwtOutput
{
Token = new JwtSecurityTokenHandler().WriteToken(token),
Expiration = token.ValidTo,
});
}
FieldAsync <EntryType>("updateEntry",
arguments: new QueryArguments(new QueryArgument <UpdateEntryInputType> {
Name = "entry"
}),
resolve: async ctx =>
{
var user = (ClaimsPrincipal)ctx.UserContext;
var isUserAuthenticated = ((ClaimsIdentity)user.Identity).IsAuthenticated;
if (!isUserAuthenticated)
{
throw new ExecutionError("Not authenticated");
}
if (!user.IsInRole("admin"))
{
throw new ExecutionError("Only admins can edit entries");
}
var entry = ctx.GetArgument <UpdateEntryInput>("entry");
var dbEntry = await context.Entries.FirstOrDefaultAsync(e => e.Id == entry.Id);
dbEntry.EmployeeId = entry.EmployeeId ?? dbEntry.EmployeeId;
dbEntry.CheckIn = entry.CheckIn ?? dbEntry.CheckIn;
dbEntry.CheckOut = entry.CheckOut ?? dbEntry.CheckOut;
await context.SaveChangesAsync();
return(dbEntry);
});
FieldAsync <BooleanGraphType>("deleteUser",
resolve: async ctx =>
{
var user = (ClaimsPrincipal)ctx.UserContext;
var isUserAuthenticated = ((ClaimsIdentity)user.Identity).IsAuthenticated;
if (!isUserAuthenticated)
{
throw new ExecutionError("Not authenticated");
}
var employee = await context.Employees.FirstOrDefaultAsync(e => e.UserName == user.Identity.Name);
context.Entries.RemoveRange(context.Entries.Where(e => e.EmployeeId == employee.Id));
await context.SaveChangesAsync();
await userManager.DeleteAsync(employee);
return(true);
});
FieldAsync <JwtOutputType>("createUser",
arguments: new QueryArguments(new QueryArgument <UserInputType> {
Name = "user"
}),
resolve: async ctx =>
{
var user = ctx.GetArgument <UserInput>("user");
var employee = new Employee
{
UserName = user.Email,
Email = user.Email,
DepartmentId = 1,
};
var result = await userManager.CreateAsync(employee, user.Password);
if (result != IdentityResult.Success)
{
throw new ExecutionError("This doesn't work");
}
return(await CreateTokenAsync(user));
});
FieldAsync <JwtOutputType>("createToken",
arguments: new QueryArguments(new QueryArgument <UserInputType> {
Name = "user"
}),
resolve: async ctx =>
{
var user = ctx.GetArgument <UserInput>("user");
return(await CreateTokenAsync(user));
});
FieldAsync <EntryType>("createEntry",
arguments: new QueryArguments(new QueryArgument <EntryInputType> {
Name = "entry"
}),
resolve: async ctx =>
{
var user = (ClaimsPrincipal)ctx.UserContext;
var isUserAuthenticated = ((ClaimsIdentity)user.Identity).IsAuthenticated;
if (!isUserAuthenticated)
{
throw new ExecutionError("Not authenticated");
}
var entry = ctx.GetArgument <Entry>("entry");
var employee = await context.Employees.FirstOrDefaultAsync(e => e.UserName == user.Identity.Name);
if (employee is null)
{
throw new ExecutionError("Something went wrong");
}
entry.EmployeeId = employee.Id;
await context.Entries.AddAsync(entry);
await context.SaveChangesAsync();
return(entry);
});
FieldAsync <EntryType>("checkInOut",
resolve: async ctx =>
{
var user = (ClaimsPrincipal)ctx.UserContext;
var isUserAuthenticated = ((ClaimsIdentity)user.Identity).IsAuthenticated;
if (!isUserAuthenticated)
{
throw new ExecutionError("Not authenticated");
}
var employee = context.Employees.FirstOrDefault(e => e.UserName == user.Identity.Name);
var lastEntry = context.Entries
.Where(e => e.Employee.Id == employee.Id)
.OrderByDescending(e => e.Id).FirstOrDefault();
if (lastEntry != null && lastEntry.CheckOut is null)
{
lastEntry.CheckOut = DateTime.Now;
await context.SaveChangesAsync();
return(lastEntry);
}
var entry = new Entry
{
CheckIn = DateTime.Now,
EmployeeId = employee.Id
};
await context.Entries.AddAsync(entry);
await context.SaveChangesAsync();
return(entry);
});
}
