public async Task <IActionResult> RemoveRoles(
int id,
[FromBody] UpdateUserRoleRequest request)
{
if (await appsService.IsRequestValidOnThisLicense(
request.AppId,
request.License,
request.RequestorId))
{
var result = await usersService.RemoveUserRoles(
id,
request.RoleIds.ToList(),
request.License);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
else
{
return(BadRequest(ControllerMessages.InvalidLicenseRequestMessage));
}
}
public async Task <ActionResult> RegisteredApps(
int userId,
[FromBody] BaseRequest request,
[FromQuery] bool fullRecord = true)
{
if (await appsService.IsRequestValidOnThisLicense(
request.AppId,
request.License,
request.RequestorId))
{
var result = await appsService.GetRegisteredApps(
userId,
request.Paginator,
fullRecord);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
else
{
return(BadRequest(ControllerMessages.InvalidLicenseRequestMessage));
}
}
public async Task <ActionResult <Game> > PostGame(
[FromBody] CreateGameRequest request)
{
if (await appsService.IsRequestValidOnThisLicense(
request.AppId,
request.License,
request.RequestorId))
{
var result = await gamesService.CreateGame(request);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode201(result.Message);
return(StatusCode((int)HttpStatusCode.Created, result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
else
{
return(BadRequest(ControllerMessages.InvalidLicenseRequestMessage));
}
}
public async Task <ActionResult> CheckAnnonymousGame([FromBody] AnnonymousCheckRequest request)
{
var intList = new List <int>();
intList.AddRange(request.FirstRow);
intList.AddRange(request.SecondRow);
intList.AddRange(request.ThirdRow);
intList.AddRange(request.FourthRow);
intList.AddRange(request.FifthRow);
intList.AddRange(request.SixthRow);
intList.AddRange(request.SeventhRow);
intList.AddRange(request.EighthRow);
intList.AddRange(request.NinthRow);
var result = await gamesService.CheckAnnonymousGame(intList);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
public async Task <ActionResult> ResetApp(
int id,
[FromBody] BaseRequest request)
{
if (await appsService.IsOwnerOfThisLicense(
request.AppId,
request.License,
request.RequestorId))
{
var result = await appsService.DeleteOrResetApp(id, true);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
else
{
return(BadRequest(ControllerMessages.NotOwnerMessage));
}
}
public async Task <ActionResult <Game> > GetGame(int id,
[FromBody] BaseRequest request)
{
if (await appsService.IsRequestValidOnThisLicense(
request.AppId,
request.License,
request.RequestorId))
{
var result = await gamesService.GetGame(
id, request.AppId);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
else
{
return(BadRequest(ControllerMessages.InvalidLicenseRequestMessage));
}
}
public async Task <IActionResult> UpdateGame(
int id,
[FromBody] UpdateGameRequest request)
{
if (await appsService.IsRequestValidOnThisLicense(
request.AppId,
request.License,
request.RequestorId))
{
if (id != request.GameId)
{
return(BadRequest(ControllerMessages.IdIncorrectMessage));
}
var result =
await gamesService.UpdateGame(id, request);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
else
{
return(BadRequest(ControllerMessages.InvalidLicenseRequestMessage));
}
}
public async Task <ActionResult <IEnumerable <SudokuSolution> > > GetSolutions(
[FromBody] BaseRequest request,
[FromQuery] bool fullRecord = true)
{
if (await appsService.IsRequestValidOnThisLicense(
request.AppId,
request.License,
request.RequestorId))
{
var result = await solutionService
.GetSolutions(request, fullRecord);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
else
{
return(BadRequest(ControllerMessages.InvalidLicenseRequestMessage));
}
}
public async Task <IActionResult> CancelAllEmailRequests([FromBody] BaseRequest request)
{
if (await appsService.IsRequestValidOnThisLicense(
request.AppId,
request.License,
request.RequestorId))
{
var result = await usersService.CancelAllEmailRequests(request.RequestorId, request.AppId);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
else
{
return(BadRequest(ControllerMessages.InvalidLicenseRequestMessage));
}
}
public async Task <ActionResult <SudokuSolution> > Solve(
[FromBody] SolutionRequest request)
{
var result = await solutionService.Solve(request);
if (result.Success)
{
if (result.Solution != null)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
public async Task <IActionResult> UpdateUser(
int id, [FromBody] UpdateUserRequest request)
{
if (await appsService.IsRequestValidOnThisLicense(
request.AppId,
request.License,
request.RequestorId))
{
string baseUrl;
if (Request != null)
{
baseUrl = Request.Host.ToString();
}
else
{
baseUrl = "https://SudokuCollective.com";
}
string emailtTemplatePath;
if (!string.IsNullOrEmpty(hostEnvironment.WebRootPath))
{
emailtTemplatePath = Path.Combine(hostEnvironment.WebRootPath, "/Content/EmailTemplates/confirm-old-email-inlined.html");
emailtTemplatePath = string.Format("../SudokuCollective.Api{0}", emailtTemplatePath);
}
else
{
emailtTemplatePath = "../../Content/EmailTemplates/confirm-old-email-inlined.html";
}
var result = await usersService.UpdateUser(
id,
request,
baseUrl,
emailtTemplatePath);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
else
{
return(BadRequest(ControllerMessages.InvalidLicenseRequestMessage));
}
}
public async Task <ActionResult> RequestToken([FromBody] TokenRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var authenticateResult = await authService.IsAuthenticated(request);
if (authenticateResult.Success)
{
var result = new AuthenticatedUserResult()
{
Success = true,
Message = ControllerMessages.StatusCode200(authenticateResult.Message),
User = authenticateResult.User,
Token = authenticateResult.Token
};
return(Ok(result));
}
else if (authenticateResult.Message.Equals(AppsMessages.AppDeactivatedMessage))
{
return(NotFound(ControllerMessages.StatusCode404(authenticateResult.Message)));
}
else if (authenticateResult.Message.Equals(AppsMessages.UserIsNotARegisteredUserOfThisAppMessage))
{
return(NotFound(ControllerMessages.StatusCode404(authenticateResult.Message)));
}
else
{
var result = await userManagementService
.ConfirmAuthenticationIssue(request.UserName, request.Password);
if (result == UserAuthenticationErrorType.USERNAMEINVALID)
{
return(BadRequest(ControllerMessages.StatusCode400("No User Has This User Name")));
}
else if (result == UserAuthenticationErrorType.PASSWORDINVALID)
{
return(BadRequest(ControllerMessages.StatusCode400("Password Invalid")));
}
else
{
return(BadRequest(ControllerMessages.StatusCode400("Bad Request")));
}
}
}
public async Task <ActionResult> ConfirmUserName(string email)
{
var result = await userManagementService.ConfirmUserName(email);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
public async Task<ActionResult<IEnumerable<Role>>> GetRoles([FromQuery] bool fullRecord = true)
{
var result = await rolesService.GetRoles(fullRecord);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return Ok(result);
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return NotFound(result);
}
}
public async Task <ActionResult <SudokuSolution> > Generate()
{
var result = await solutionService.Generate();
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
public async Task <ActionResult> GetLicense(int id)
{
var result = await appsService.GetLicense(id);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
public async Task <IActionResult> DeactivateUser(int id)
{
var result = await usersService.DeactivateUser(id);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
public async Task <IActionResult> ResendRequestPasswordReset([FromBody] BaseRequest request)
{
string baseUrl;
if (Request != null)
{
baseUrl = Request.Host.ToString();
}
else
{
baseUrl = "https://SudokuCollective.com";
}
string emailtTemplatePath;
if (!string.IsNullOrEmpty(hostEnvironment.WebRootPath))
{
emailtTemplatePath = Path.Combine(hostEnvironment.WebRootPath, "/Content/EmailTemplates/password-reset-requested-inlined.html");
emailtTemplatePath = string.Format("../SudokuCollective.Api{0}", emailtTemplatePath);
}
else
{
emailtTemplatePath = "../../Content/EmailTemplates/confirm-old-email-inlined.html";
}
var result = await usersService.ResendPasswordReset(
request.RequestorId,
request.AppId,
baseUrl,
emailtTemplatePath);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
public async Task <ActionResult <App> > PostApp(
[FromBody] LicenseRequest request)
{
var result = await appsService.CreateApp(request);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode201(result.Message);
return(StatusCode((int)HttpStatusCode.Created, result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
public async Task <ActionResult <Difficulty> > GetDifficulty(
int id,
[FromQuery] bool fullRecord = true)
{
var result = await difficultiesService.GetDifficulty(id, fullRecord);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
public async Task <ActionResult <App> > GetByLicense(
[FromBody] BaseRequest request,
[FromQuery] bool fullRecord = true)
{
var result = await appsService
.GetAppByLicense(request.License, request.RequestorId, fullRecord);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
public async Task <IActionResult> AddSolutions(
[FromBody] AddSolutionRequest request)
{
if (await appsService.IsRequestValidOnThisLicense(
request.AppId,
request.License,
request.RequestorId))
{
if (request.Limit <= 1000)
{
var result = await solutionService.AddSolutions(request.Limit);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
else
{
return(BadRequest(
ControllerMessages.StatusCode400(
string.Format(
"The Amount Of Solutions Requested, {0}, Exceeds The Service's 1,000 Limit",
request.Limit.ToString())
)));
}
}
else
{
return(BadRequest(ControllerMessages.InvalidLicenseRequestMessage));
}
}
public async Task <ActionResult> PostAnnonymousGame([FromQuery] AnnonymousGameRequest request)
{
if (request.DifficultyLevel == DifficultyLevel.NULL)
{
return(BadRequest(
ControllerMessages.StatusCode400(
GamesMessages.DifficultyLevelIsRequiredMessage)));
}
var result = await gamesService.CreateAnnonymousGame(request.DifficultyLevel);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
public async Task <ActionResult <User> > SignUp(
[FromBody] RegisterRequest request)
{
string baseUrl;
if (Request != null)
{
baseUrl = Request.Host.ToString();
}
else
{
baseUrl = "https://SudokuCollective.com";
}
string emailtTemplatePath;
if (!string.IsNullOrEmpty(hostEnvironment.WebRootPath))
{
emailtTemplatePath = Path.Combine(hostEnvironment.WebRootPath, "/Content/EmailTemplates/create-email-inlined.html");
emailtTemplatePath = string.Format("../SudokuCollective.Api{0}", emailtTemplatePath);
}
else
{
emailtTemplatePath = "../../Content/EmailTemplates/create-email-inlined.html";
}
var result = await usersService.CreateUser(
request,
baseUrl,
emailtTemplatePath);
if (result.Success)
{
var tokenRequest = new TokenRequest
{
UserName = request.UserName,
Password = request.Password,
License = request.License
};
var authenticateResult = await authService.IsAuthenticated(tokenRequest);
if (authenticateResult.Success)
{
result.Message = ControllerMessages.StatusCode201(result.Message);
result.Token = authenticateResult.Token;
return(StatusCode((int)HttpStatusCode.Created, result));
}
else
{
result.Message = ControllerMessages.StatusCode404(authenticateResult.Message);
result.User = new User();
return(NotFound(result));
}
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}