/// <summary>
/// Initializes a new instance of the <see cref="SageController"/> class.
/// </summary>
protected SageController()
{
typeName = this.GetType().Name.Replace("Controller", string.Empty).ToLower();
messages = new ControllerMessages();
this.ViewData["messages"] = messages;
this.IsShared = this.GetType().GetCustomAttributes(typeof(SharedControllerAttribute), true).Count() != 0;
}
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 <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> > 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> 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 <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 <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> 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 <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 EstablishmentsController(ILogger <EstablishmentsController> logger, EstablishmentService establishmentService, ControllerMessages responseMessages)
{
this.logger = logger;
this.establishmentService = establishmentService;
this.httpResponseHelper = new HttpResponseHelper();
this.responseMessages = responseMessages;
}
public TalkMessage()
{
InitializeComponent();
talk = this;
//Socket.client.Emit("render Messages");
renderMessages(ControllerMessages.getMessages());
}
public ReleasesController(ILogger <ReleasesController> logger, ReleasesService releasesService, EstablishmentService establishmentService, ControllerMessages responseMessages)
{
this.logger = logger;
this.releasesService = releasesService;
this.establishmentService = establishmentService;
this.responseMessages = responseMessages;
this.httpResponseHelper = new HttpResponseHelper();
}
public TalkMessage(double width)
{
InitializeComponent();
talk = this;
this.Width = width;
//Socket.client.Emit("render Messages");
renderMessages(ControllerMessages.getMessages());
}
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 ActionResult Get()
{
var result = new BaseResult
{
Success = true,
Message = ControllerMessages.StatusCode200("Hello World from Sudoku Collective!")
};
return(Ok(result));
}
public EstablishmentControllerTests(DatabaseSettingsFixture dbFixture)
{
// 0: Setting wrapper for logger
loggerWrapper = new LoggerWrapper <EstablishmentsController>();
// 1: Setting establishment service given db settings
this.dbSettings = dbFixture.dbSettings;
this.establishmentService = dbFixture.establishmentService;
// 2: Get controller messages
this.controllerMessages = GetControllerMessagesProperties();
// 3: Instantiate of Establishment Controller
this.establishmentsController = new EstablishmentsController(loggerWrapper, establishmentService, controllerMessages);
}
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 ReleasesServiceTests(DatabaseSettingsFixture dbFixture)
{
// 0: Setting wrapper for logger
loggerWrapper = new LoggerWrapper <ReleasesController>();
rabbitConnector = new RabbitConnectorWrapper();
// 1: Setting establishment and releases service given db settings
this.dbSettings = dbFixture.dbSettings;
this.establishmentService = dbFixture.establishmentService;
this.releasesService = dbFixture.releasesService;
// 2: Get controller messages
this.controllerMessages = GetControllerMessagesProperties();
// 3: Instantiate of Establishment Controller
this.releasesController = new ReleasesController(loggerWrapper, releasesService, establishmentService, controllerMessages, rabbitConnector);
}
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<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> 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));
}
}
/// <summary>
///
/// </summary>
public void Start()
{
//set the default screen resolution
intDeviceScreenWidth = ViewerConstants.ViewerWidth;
intDeviceScreenHeight = ViewerConstants.ViewerHeight;
controllerMessages = new ControllerMessages();
}
/// <summary>
///
/// </summary>
/// <param name="bytController"></param>
/// <param name="cntlMsgs"></param>
/// <param name="strControllerData"></param>
public static void DecodeControllerData(byte[] bytController, ref ControllerMessages cntlMsgs)
{
//UnityEngine.Debug.Log("Entered DecodeControllerData()");
int intMsgType = 0;
MemoryStream stream = new MemoryStream(bytController);
using (EndianAwareBinaryReader reader = new EndianAwareBinaryReader(stream, false))
{
while (reader.BaseStream.Position < reader.BaseStream.Length)
{
intMsgType = reader.ReadInt32();
//UnityEngine.Debug.Log("intMsgType = " + intMsgType);
if (intMsgType == ViewerConstants.MESSAGE_TOUCH_INPUT)
{
UnityEngine.Debug.Log("reading touch");
cntlMsgs.TouchMessage.X = reader.ReadSingle();
cntlMsgs.TouchMessage.Y = reader.ReadSingle();
cntlMsgs.TouchMessage.Timestamp = reader.ReadInt64();
cntlMsgs.TouchMessage.Pointer = reader.ReadInt32();
cntlMsgs.TouchMessage.Active = reader.ReadInt32();
}
else if (intMsgType == ViewerConstants.MESSAGE_ACCELEROMETER_INPUT)
{
//UnityEngine.Debug.Log("reading accel");
cntlMsgs.AccelMessage.X = reader.ReadSingle();
cntlMsgs.AccelMessage.Y = reader.ReadSingle();
cntlMsgs.AccelMessage.Z = reader.ReadSingle();
cntlMsgs.AccelMessage.Timestamp = reader.ReadInt32();
}
else if (intMsgType == ViewerConstants.MESSAGE_MAGNOTOMETER_INPUT)
{
//UnityEngine.Debug.Log("reading magnotometer");
cntlMsgs.MagnoMessage.X = reader.ReadSingle();
cntlMsgs.MagnoMessage.Y = reader.ReadSingle();
cntlMsgs.MagnoMessage.Z = reader.ReadSingle();
cntlMsgs.MagnoMessage.Timestamp = reader.ReadInt32();
}
else if (intMsgType == ViewerConstants.MESSAGE_ATTITUDE_INPUT)
{
//UnityEngine.Debug.Log("reading attitude");
cntlMsgs.AttMessage.X = reader.ReadSingle();
cntlMsgs.AttMessage.Y = reader.ReadSingle();
cntlMsgs.AttMessage.Z = reader.ReadSingle();
cntlMsgs.AttMessage.Timestamp = reader.ReadInt32();
}
else if (intMsgType == ViewerConstants.MESSAGE_TRACKBALL_INPUT)
{
UnityEngine.Debug.Log("reading trackball");
cntlMsgs.TrackMessage.X = reader.ReadSingle();
cntlMsgs.TrackMessage.Y = reader.ReadSingle();
}
else if (intMsgType == ViewerConstants.MESSAGE_OPTIONS)
{
UnityEngine.Debug.Log("reading options");
cntlMsgs.OptionMessage.ScreenWidth = reader.ReadInt32();
cntlMsgs.OptionMessage.ScreenHeight = reader.ReadInt32();
}
else if (intMsgType == ViewerConstants.MESSAGE_KEY)
{
UnityEngine.Debug.Log("reading keys");
cntlMsgs.KeyMessage.State = reader.ReadInt32();
cntlMsgs.KeyMessage.Key = reader.ReadInt32();
cntlMsgs.KeyMessage.Unicode = reader.ReadInt32();
}
}
}
}
/// <summary>
///
/// </summary>
void Start()
{
styleAlert = new GUIStyle();
styleAlert.normal.textColor = Color.red;
styleAlert.fontSize = 15;
//set the default screen resolution
intDeviceScreenWidth = ViewerConstants.ViewerWidth;
intDeviceScreenHeight = ViewerConstants.ViewerHeight;
cntlMsgs = new ControllerMessages();
DudeBase = GameObject.Find("Dude");
MainCam = GameObject.Find("Main Camera");
controller = DudeBase.GetComponent<CharacterController>();
}
