private async void button1_Click(object sender, EventArgs e) { try { CognitoHelper cognitoHelper = new CognitoHelper(); cognitoUser = await cognitoHelper.ValidateUser(txtusername.Text, txtpassword.Text); MessageBox.Show("Login successfully"); Console.WriteLine(cognitoUser.Username); CognitoAWSCredentials credentials = cognitoUser.GetCognitoAWSCredentials(ConfigurationManager.AppSettings["FED_POOL_id"], new AppConfigAWSRegion().Region); StringBuilder tokens = new StringBuilder(); tokens.Append("================Cognito Credentails==================\n"); tokens.Append("Access Key - " + credentials.GetCredentials().AccessKey); tokens.Append("\nSecret - " + credentials.GetCredentials().SecretKey); tokens.Append("\nSession Token - " + credentials.GetCredentials().Token); tokens.Append("\nUseToken Token - " + credentials.GetCredentials().UseToken.ToString()); Console.WriteLine(tokens.ToString()); } catch (Exception exp) { Console.WriteLine(exp); MessageBox.Show("Unable to validate the username and password"); } }
/// <summary> /// Lambda to insert character to character table /// </summary> /// <param name="pRequest">Incoming API Gateway request object, should be a PUT or POST with a BODY</param> /// <param name="pContext">Incoming Lambda Context object, not used currently</param> /// <returns></returns> public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext) { if (pRequest.Headers.Keys.Contains("warmup")) { return(HttpHelper.WarmupResponse()); } if (pRequest == null) { return(HttpHelper.HandleError("Request appears to be null", 500)); } using (opendkpContext vDatabase = new opendkpContext()) { if (!CognitoHelper.IsDkpAdmin(pRequest) || !CognitoHelper.IsAuthorizedAdmin(vDatabase, pRequest)) { return(HttpHelper.HandleError("You do not have permission to perform this action", 401)); } var vCognitoUser = CognitoHelper.GetCognitoUser(pRequest.Headers["cognitoinfo"]); //We need to retrieve the ClientId for multitenancy purposes var vClientId = pRequest.Headers["clientid"]; if (pRequest.HttpMethod.Equals("PUT", StringComparison.InvariantCultureIgnoreCase)) { return(HandleInsert(pRequest, pContext, vCognitoUser, vDatabase, vClientId)); } else if (pRequest.HttpMethod.Equals("POST", StringComparison.InvariantCultureIgnoreCase)) { return(HandleUpdate(pRequest, pContext, vCognitoUser, vDatabase, vClientId)); } } return(HttpHelper.HandleError("Only Methods PUT,POST are supported by this lamdba", 500)); }
private async void button4_Click(object sender, EventArgs e) { try { CognitoHelper helper = new CognitoHelper(); /*var req = new Amazon.CognitoIdentityProvider.Model.UpdateUserAttributesRequest(); * req.AccessToken = cognitoUser.SessionTokens.AccessToken; * var att1 = new Amazon.CognitoIdentityProvider.Model.AttributeType(); * var att2 = new Amazon.CognitoIdentityProvider.Model.AttributeType(); * att2.Name = "custom:test2"; * att1.Name = "custom:Attribut"; * att1.Value = textBox1.Text; * att2.Value = textBox2.Text; * req.UserAttributes.Add(att1); * req.UserAttributes.Add(att2); * var result = await helper.UpdateAttributes(req);*/ var bla = helper.getAttributes(cognitoUser).Result.UserAttributes; String ans = ""; foreach (var a in bla) { ans += a.Name + " : " + a.Value + Environment.NewLine; } MessageBox.Show(ans); } catch (Exception ex) { Console.WriteLine(ex); MessageBox.Show("Some kind of error"); } }
/// <summary> /// Lambda to insert character to character table /// </summary> /// <param name="pRequest">Incoming API Gateway request object, should be a PUT or POST with a BODY</param> /// <param name="pContext">Incoming Lambda Context object, not used currently</param> /// <returns></returns> public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext) { if (pRequest.Headers != null && pRequest.Headers.Count > 0 && pRequest.Headers.Keys.Contains("warmup")) { return(HttpHelper.WarmupResponse()); } if (pRequest == null) { return(HttpHelper.HandleError("Request appears to be null", 500)); } //For these operations, we should have the CognitoInfo user available to us //Authorized Users only for Deleting Raids using (opendkpContext vDatabase = new opendkpContext()) { if (!CognitoHelper.IsDkpAdmin(pRequest) || !CognitoHelper.IsAuthorizedAdmin(vDatabase, pRequest)) { return(HttpHelper.HandleError("You do not have permission to perform this action", 401)); } var vCognitoUser = CognitoHelper.GetCognitoUser(pRequest.Headers["cognitoinfo"]); if (pRequest.HttpMethod.Equals("PUT", StringComparison.InvariantCultureIgnoreCase)) { return(HandleInsert(pRequest, pContext, vCognitoUser, vDatabase)); } else if (pRequest.HttpMethod.Equals("POST", StringComparison.InvariantCultureIgnoreCase)) { return(HandleUpdateAsync(pRequest, pContext, vCognitoUser, vDatabase)); } } return(HttpHelper.HandleError("Only Methods PUT,POST are supported by this lamdba", 500)); }
public SignInSignUp() { InitializeComponent(); _cognitoHelper = new CognitoHelper(); if (Application.Current.Properties.ContainsKey("User")) { EmailEntry.Text = (Application.Current.Properties["User"] as User).EmailAddress; } }
/// <summary> /// Lambda to insert character to character table /// </summary> /// <param name="pRequest">Incoming API Gateway request object, should be a PUT or POST with a BODY</param> /// <param name="pContext">Incoming Lambda Context object, not used currently</param> /// <returns></returns> public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext) { if (pRequest.Headers.Keys.Contains("warmup")) { return(HttpHelper.WarmupResponse()); } var vResponse = HttpHelper.HandleError("[DeleteAdjustment] Unknown Backend error", 500); try { if (pRequest != null && pRequest.PathParameters != null && pRequest.PathParameters.Count > 0) { int vId = int.Parse(pRequest.PathParameters["id"]); using (opendkpContext vDatabase = new opendkpContext()) { //Authorized Users only for Deleting Adjustments if (!CognitoHelper.IsDkpAdmin(pRequest) || !CognitoHelper.IsAuthorizedAdmin(vDatabase, pRequest)) { return(HttpHelper.HandleError("You do not have permission to perform this action", 401)); } var vCognitoUser = CognitoHelper.GetCognitoUser(pRequest.Headers["cognitoinfo"]); //We need to retrieve the ClientId for multitenancy purposes var vClientId = pRequest.Headers["clientid"]; var vResult = vDatabase.Adjustments .FirstOrDefault(x => x.ClientId.Equals(vClientId) && x.IdAdjustment == vId); if (vResult != null) { vDatabase.Adjustments.Remove(vResult); vDatabase.SaveChanges(); //Audit AuditHelper.InsertAudit(vDatabase, vClientId, vResult, string.Empty, vCognitoUser.Username, Audit.ACTION_ADJUST_DELETE); //Update Caches int vStatus = CacheManager.UpdateSummaryCacheAsync(vClientId).GetAwaiter().GetResult(); Console.WriteLine("StatusCode for CacheUpdate=" + vStatus); vResponse = HttpHelper.HandleResponse(vResult, 200, true); } else { vResponse = HttpHelper.HandleError("[DeleteAdjustment] Adjustment doesnt exist in DB", 500); } } } } catch { vResponse = HttpHelper.HandleError("[DeleteAdjustment] Issue with DB or Query", 500); } return(vResponse); }
/// <summary> /// Lambda to fetch all characters from the character table /// </summary> /// <param name="pRequest">Incoming API Gateway request object, not used currently</param> /// <param name="pContext">Incoming Lambda Context object, not used currently</param> /// <returns></returns> public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext) { if (pRequest.Headers != null && pRequest.Headers.Count > 0 && pRequest.Headers.Keys.Contains("warmup")) { return(HttpHelper.WarmupResponse()); } var vResponse = HttpHelper.HandleError("[CognitoAPIs] Unknown Error in backend", 500); try { string pUserPool = string.Empty; //The request should be from an authorized user, if yes then also grab the UserPool for the associated client using (opendkpContext vDatabase = new opendkpContext()) { //Authorized Users only for Audit information if (!CognitoHelper.IsDkpAdmin(pRequest) || !CognitoHelper.IsAuthorizedAdmin(vDatabase, pRequest)) { return(HttpHelper.HandleError("You do not have permission to perform this action", 401)); } //No validation on header because it's pre-performed above in the CognitoHelper pUserPool = vDatabase.Clients. FirstOrDefault(x => x.ClientId.Equals(pRequest.Headers["clientid"], StringComparison.InvariantCultureIgnoreCase)).UserPool; } if (pRequest.HttpMethod == "GET") { Task <object> vTask = GetAllUsersAsync(pUserPool); vResponse = HttpHelper.HandleResponse(vTask.Result, 200); } if (pRequest.HttpMethod == "POST") { dynamic vModel = JsonConvert.DeserializeObject(pRequest.Body); string vAction = vModel.Action; string vData = vModel.Data; if (vAction.Equals("add-admin")) { Task <string> vTask = AddDkpAdminAsync(vData, pUserPool); vResponse = HttpHelper.HandleResponse(vTask.Result, 200); } else if (vAction.Equals("remove-admin")) { Task <string> vTask = RemoveDkpAdminAsync(vData, pUserPool); vResponse = HttpHelper.HandleResponse(vTask.Result, 200); } } } catch (Exception vException) { vResponse = HttpHelper.HandleError("[CognitoAPIs] " + vException.Message, 500); } return(vResponse); }
/// <summary> /// Lambda to fetch all characters from the character table /// </summary> /// <param name="pRequest">Incoming API Gateway request object, not used currently</param> /// <param name="pContext">Incoming Lambda Context object, not used currently</param> /// <returns></returns> public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext) { if (pRequest.Headers != null && pRequest.Headers.Count > 0 && pRequest.Headers.Keys.Contains("warmup")) { return(HttpHelper.WarmupResponse()); } var vResponse = HttpHelper.HandleError("[AuditLambda] Unknown Error in backend", 500); //We need to retrieve the ClientId for multitenancy purposes var vClientId = pRequest.Headers["clientid"]; try { int vId = -1; if (pRequest != null && pRequest.PathParameters != null && pRequest.PathParameters.Count > 0) { vId = int.Parse(pRequest.PathParameters["id"]); } using (opendkpContext vDatabase = new opendkpContext()) { //Authorized Users only for Audit information if (!CognitoHelper.IsDkpAdmin(pRequest) || !CognitoHelper.IsAuthorizedAdmin(vDatabase, pRequest)) { return(HttpHelper.HandleError("You do not have permission to perform this action", 401)); } if (pRequest.HttpMethod.Equals("GET", StringComparison.InvariantCultureIgnoreCase)) { List <Audit> vResult; if (vId > -1) { vResult = vDatabase.Audit.Where(x => x.ClientId.Equals(vClientId) && x.Id == vId).ToList(); } else { //We don't want to transmit a ton of data for fetching all audits vResult = vDatabase.Audit.Where(x => x.ClientId.Equals(vClientId)).ToList(); foreach (Audit vItem in vResult) { vItem.NewValue = string.Empty; vItem.OldValue = string.Empty; } } vResponse = HttpHelper.HandleResponse(vResult, 200, true); } } } catch (Exception vException) { vResponse = HttpHelper.HandleError("[AuditLambda] " + vException.Message, 500); } return(vResponse); }
private async void btnSignUp_Click(object sender, EventArgs e) { if (dropMonth.selectedValue == "MM" || dropDay.selectedValue == "DD" || dropYear.selectedValue == "YYYY") { lblBDError.Visible = true; } else if (lblUNError.Visible == false && lblEmailError.Visible == false && lblPWError.Visible == false) { CognitoHelper cognitoHelper = new CognitoHelper(); try { string birthday = dropYear.selectedValue + "-" + dropMonth.selectedValue + "-" + dropDay.selectedValue; bool success = await cognitoHelper.SignUpUser(txtUsername.Text, txtPassword.Text, txtEmail.Text, birthday); if (success) { VerificationCode verificationCode = new VerificationCode(txtUsername.Text); Point verificationcodePoint = new Point(281, 162); verificationCode.Location = verificationcodePoint; verificationCode.Show(); Program.home.Controls.Add(verificationCode); this.Dispose(); } else { MessageBox.Show("some unhandled error"); } } catch (Amazon.CognitoIdentityProvider.Model.UsernameExistsException) { lblUNError.Visible = true; lblUNError.Text = "Username already exists"; } catch (Amazon.CognitoIdentityProvider.Model.AliasExistsException) { lblUNError.Visible = true; lblUNError.Text = "Username already exists"; } catch (Amazon.CognitoIdentityProvider.Model.InvalidParameterException) { lblEmailError.Visible = true; lblEmailError.Text = "Invalid email"; } catch (Exception) { lblUNError.Visible = true; lblUNError.Text = "Unhandled exception"; } } }
/// <summary> /// Lambda to insert character to character table /// </summary> /// <param name="pRequest">Incoming API Gateway request object, should be a PUT or POST with a BODY</param> /// <param name="pContext">Incoming Lambda Context object, not used currently</param> /// <returns></returns> public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext) { if (pRequest.Headers.Keys.Contains("warmup")) { return(HttpHelper.WarmupResponse()); } var vResponse = HttpHelper.HandleError("[DeleteCharacter] Unknown Backend error", 500); try { if (pRequest != null && pRequest.PathParameters != null && pRequest.PathParameters.Count > 0) { //We need to retrieve the ClientId for multitenancy purposes var vClientId = pRequest.Headers["clientid"]; string vCharacterName = pRequest.PathParameters["character"]; using (opendkpContext vDatabase = new opendkpContext()) { //Authorized Users only for Deleting Characters if (!CognitoHelper.IsDkpAdmin(pRequest) || !CognitoHelper.IsAuthorizedAdmin(vDatabase, pRequest)) { return(HttpHelper.HandleError("You do not have permission to perform this action", 401)); } var vCognitoUser = CognitoHelper.GetCognitoUser(pRequest.Headers["cognitoinfo"]); var vResult = vDatabase. Characters. FirstOrDefault(x => x.ClientId.Equals(vClientId) && x.Name.Equals(vCharacterName, StringComparison.InvariantCultureIgnoreCase)); if (vResult != null) { vDatabase.Characters.Remove(vResult); vDatabase.SaveChanges(); AuditHelper.InsertAudit(vDatabase, vClientId, vResult, string.Empty, vCognitoUser.Username, Audit.ACTION_CHAR_DELETE); vResponse = HttpHelper.HandleResponse(vResult, 200); } else { vResponse = HttpHelper.HandleError("[DeleteCharacter] Character doesn't exist in the DB", 500); } } } } catch { vResponse = HttpHelper.HandleError("[DeleteCharacter] Issue with DB or Query", 500); } return(vResponse); }
private async void btnupdatepass_Click(object sender, EventArgs e) { try { CognitoHelper helper = new CognitoHelper(); await helper.UpdatePassword(txtusername.Text, txtcode.Text, txtnewpassword.Text); MessageBox.Show("Password updated."); } catch (Exception exp) { MessageBox.Show("Unable to update the password" + exp.Message); } }
private async void Login_Click(object sender, RoutedEventArgs e) { CognitoHelper cognitoHelper = new CognitoHelper(); ioioSetting.All.cognitoUser = await cognitoHelper.ValidateUser("atumm", "B@y7cgmc"); Console.WriteLine(ioioSetting.All.cognitoUser.Username); string email = string.Empty; ioioSetting.All.cognitoUser.Attributes.TryGetValue("email", out email); GetUserResponse r = await cognitoHelper.GetUserInfo(ioioSetting.All.cognitoUser); Console.WriteLine(email); }
private async void button1_Click(object sender, EventArgs e) { CognitoHelper cognitoHelper = new CognitoHelper(); bool success = await cognitoHelper.VerifyAccessCode(lblusername.Text, txtcode.Text); if (success) { MessageBox.Show("Able to validate the access code"); this.Close(); } else { MessageBox.Show("Unable to validate the access code"); } }
/// <summary> /// Lambda to insert character to character table /// </summary> /// <param name="pRequest">Incoming API Gateway request object, should be a PUT or POST with a BODY</param> /// <param name="pContext">Incoming Lambda Context object, not used currently</param> /// <returns></returns> public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext) { if (pRequest.Headers.Keys.Contains("warmup")) { return(HttpHelper.WarmupResponse()); } var vResponse = HttpHelper.HandleError("[DeleteRaid] Unknown Backend error", 500); try { if (pRequest != null && pRequest.PathParameters != null && pRequest.PathParameters.Count > 0) { int vId = int.Parse(pRequest.PathParameters["id"]); using (opendkpContext vDatabase = new opendkpContext()) { //Authorized Users only for Deleting Raids if (!CognitoHelper.IsDkpAdmin(pRequest) || !CognitoHelper.IsAuthorizedAdmin(vDatabase, pRequest)) { return(HttpHelper.HandleError("You do not have permission to perform this action", 401)); } var vCognitoUser = CognitoHelper.GetCognitoUser(pRequest.Headers["cognitoinfo"]); //We need to retrieve the ClientId for multitenancy purposes var vClientId = pRequest.Headers["clientid"]; Raids vResult = RaidHelper.DeleteRaid(vDatabase, vId, vClientId); vDatabase.SaveChanges(); vResponse = HttpHelper.HandleResponse(vResult, 200); //Audit AuditHelper.InsertAudit(vDatabase, vClientId, vResult, string.Empty, vCognitoUser.Username, Audit.ACTION_RAID_DELETE); //Update Caches int vStatus = CacheManager.UpdateSummaryCacheAsync(vClientId).GetAwaiter().GetResult(); Console.WriteLine("SummaryCacheResponse=" + vStatus); vStatus = CacheManager.UpdateItemCacheAsync(vClientId).GetAwaiter().GetResult(); Console.WriteLine("ItemCacheResponse=" + vStatus); } } } catch { vResponse = HttpHelper.HandleError("[DeleteRaid] Issue with DB or Query", 500); } return(vResponse); }
private async void button1_Click(object sender, EventArgs e) { CognitoHelper helper = new CognitoHelper(); bool success = await helper.SignUpUser(txtUsername.Text, txtPassword.Text, txtEmail.Text, txtPhone.Text); if (success) { MessageBox.Show("User Added Successfully! Please validate the phone number."); CodeEntry codeEntry = new CodeEntry(txtUsername.Text, txtPhone.Text); codeEntry.ShowDialog(); } else { MessageBox.Show("Unable to add the user"); } }
private async void button1_Click(object sender, EventArgs e) { try { CognitoHelper cognitoHelper = new CognitoHelper(); cognitoUser = await cognitoHelper.ValidateUser(txtusername.Text, txtpassword.Text); Console.WriteLine(cognitoUser.Username); string bucketsforuser = await cognitoHelper.GetS3BucketsAsync(cognitoUser); MessageBox.Show(bucketsforuser, "Buckets for the users"); } catch (Exception exp) { Console.WriteLine(exp); MessageBox.Show("Unable to validate the username and password"); } }
private async void button1_Click(object sender, EventArgs e) { try { CognitoHelper helper = new CognitoHelper(); await helper.ResetPassword(txtusername.Text); MessageBox.Show("Password reset request submitted. Please check the code on phone"); lblcode.Enabled = true; txtcode.Enabled = true; lblnewpassword.Enabled = true; txtnewpassword.Enabled = true; btnupdatepass.Enabled = true; } catch (Exception exp) { MessageBox.Show(exp.Message); } }
private async void btnLogIn_Click(object sender, EventArgs e) { CognitoHelper cognitoHelper = new CognitoHelper(); try { var cognitoUser = await cognitoHelper.ValidateUser(txtUsername.Text, txtPassword.Text); MessageBox.Show("Validated!"); } catch (Amazon.CognitoIdentityProvider.Model.UserNotFoundException) { errorUI("User not found"); } catch (Amazon.CognitoIdentityProvider.Model.InvalidPasswordException) { errorUI("Invalid password"); } catch (Exception) { errorUI("Unexpected error"); } }
private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e) { CognitoHelper cognitoHelper = new CognitoHelper(); System.Diagnostics.Process.Start(cognitoHelper.GetCustomHostedURL()); }
/// <summary> /// /// </summary> /// <param name="pRequest">Incoming API Gateway request object, not used currently</param> /// <param name="pContext">Incoming Lambda Context object, not used currently</param> /// <returns></returns> public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext) { if (pRequest.Headers != null && pRequest.Headers.Count > 0 && pRequest.Headers.Keys.Contains("warmup")) { return(HttpHelper.WarmupResponse()); } var vResponse = HttpHelper.HandleError("[AdminSettings] Unknown Error in backend", 500); //We need to retrieve the ClientId for multitenancy purposes var vClientId = pRequest.Headers["clientid"]; try { using (opendkpContext vDatabase = new opendkpContext()) { if (pRequest.HttpMethod == "GET") { string vSettingName = pRequest.PathParameters["setting"]; var vResult = vDatabase.AdminSettings.Where(x => x.ClientId.Equals(vClientId) && x.SettingName.Equals(vSettingName, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault(); if (vResult == null) { vResult = new AdminSettings(); } return(HttpHelper.HandleResponse(JsonConvert.SerializeObject(vResult), 200)); } //This is the Guild Dump Utility I quickly wrote if (pRequest.HttpMethod == "POST") { //Authorize User for POST requests only if (!CognitoHelper.IsDkpAdmin(pRequest) || !CognitoHelper.IsAuthorizedAdmin(vDatabase, pRequest)) { return(HttpHelper.HandleError("You do not have permission to perform this action", 401)); } //Process Guild Dump dynamic vModel = JsonConvert.DeserializeObject(pRequest.Body); string vAction = vModel.Action; JArray vData = vModel.Data; if (!string.IsNullOrWhiteSpace(vAction)) { var vCharacters = vData.ToObject <Characters[]>(); List <string> vCharacterNames = new List <string>(); foreach (Characters vCharacter in vCharacters) { vCharacterNames.Add(vCharacter.Name); } var vResults = vDatabase.Characters.Where(x => x.ClientId.Equals(vClientId) && vCharacterNames.Contains(x.Name)); foreach (var item in vResults) { var vChar = vCharacters.FirstOrDefault(x => x.Name.Equals(item.Name)); if (vChar != null) { item.Level = vChar.Level; item.Rank = vChar.Rank; item.Class = vChar.Class; } } vDatabase.SaveChanges(); return(HttpHelper.HandleResponse("Success", 200)); } else { AdminSettings vInputModel = JsonConvert.DeserializeObject <AdminSettings>(pRequest.Body); AdminSettings vAdminModel = vDatabase.AdminSettings .FirstOrDefault(x => x.ClientId.Equals(vClientId) && x.SettingName.Equals(vInputModel.SettingName, StringComparison.InvariantCultureIgnoreCase)); if (vAdminModel == null) { vAdminModel = vInputModel; vAdminModel.ClientId = vClientId; vDatabase.Add(vAdminModel); } vAdminModel.SettingValue = vInputModel.SettingValue; vAdminModel.UpdatedBy = vInputModel.UpdatedBy; vAdminModel.UpdatedTimestamp = vInputModel.UpdatedTimestamp; vAdminModel.ClientId = vClientId; vDatabase.SaveChanges(); return(HttpHelper.HandleResponse(JsonConvert.SerializeObject(vAdminModel), 200)); } } } } catch (Exception vException) { vResponse = HttpHelper.HandleError("[AdminSettings] Error Connecting to DB: " + vException.Message, 500); } return(vResponse); }
/// <summary> /// Lambda to insert character to character table /// </summary> /// <param name="pRequest">Incoming API Gateway request object, should be a PUT or POST with a BODY</param> /// <param name="pContext">Incoming Lambda Context object, not used currently</param> /// <returns></returns> public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext) { if (pRequest.Headers != null && pRequest.Headers.Count > 0 && pRequest.Headers.Keys.Contains("warmup")) { return(HttpHelper.WarmupResponse()); } var vResponse = HttpHelper.HandleError("[UserRequestsLambda] Unknown Backend error", 500); //We need to retrieve the ClientId for multitenancy purposes var vClientId = pRequest.Headers["clientid"]; try { using (opendkpContext vDatabase = new opendkpContext()) { //For these operations, we should have the CognitoInfo user available to us if (pRequest.Headers != null && !pRequest.Headers.ContainsKey("cognitoinfo")) { return(HttpHelper.HandleError("You do not have permission to perform this action", 401)); } CognitoUser vCognitoUser = CognitoHelper.GetCognitoUser(pRequest.Headers["cognitoinfo"]); if (pRequest.HttpMethod.Equals("GET", StringComparison.InvariantCultureIgnoreCase)) { //If the GET request has PathParameter of the account, fetch all requests for given account //Otherwise return all requests if (pRequest != null && pRequest.PathParameters != null && pRequest.PathParameters.Count > 0) { string vAccountName = pRequest.PathParameters["account"]; vResponse = GetAccountRequests(vDatabase, vAccountName, vClientId); } else { vResponse = GetAllRequests(vDatabase, vClientId); } } //PUT can come from any user, such as a standard user who wants to assign a character to themselves //or credit for a raid tick. if (pRequest.HttpMethod.Equals("PUT", StringComparison.InvariantCultureIgnoreCase)) { if (vCognitoUser == null) { return(HttpHelper.HandleError("You do not have permission to perform this action", 401)); } UserRequests vUserRequest = JsonConvert.DeserializeObject <UserRequests>(pRequest.Body); if (vUserRequest.RequestType == UserRequests.TYPE_CHARACTER_ASSIGN) { vResponse = HandleCharacterAssignRequest(vDatabase, vUserRequest, pRequest, vCognitoUser); } if (vUserRequest.RequestType == UserRequests.TYPE_RAIDTICK) { vResponse = HandleRaidTickRequest(vDatabase, vUserRequest, pRequest, vCognitoUser); } } //POST can only come from admins, need to make sure cognito Groups contains "DKP_ADMIN" or "SITE_ADMIN" //This would be for approving or denying requests if (pRequest.HttpMethod.Equals("POST", StringComparison.InvariantCultureIgnoreCase)) { if (!CognitoHelper.IsDkpAdmin(pRequest) || !CognitoHelper.IsAuthorizedAdmin(vDatabase, pRequest)) { return(HttpHelper.HandleError("You do not have permission to perform this action", 401)); } vCognitoUser = CognitoHelper.GetCognitoUser(pRequest.Headers["cognitoinfo"]); UserRequests vUserRequest = JsonConvert.DeserializeObject <UserRequests>(pRequest.Body); if (vUserRequest.RequestType == UserRequests.TYPE_CHARACTER_ASSIGN) { vResponse = UpdateCharacterAssignRequest(vDatabase, vClientId, vUserRequest, vCognitoUser); } if (vUserRequest.RequestType == UserRequests.TYPE_RAIDTICK) { vResponse = UpdateRaidTickRequest(vDatabase, vUserRequest, vCognitoUser, vClientId); } } } } catch (Exception vException) { vResponse = HttpHelper.HandleError("[UserRequestsLambda] Issue with DB or Query: " + vException.Message, 500); } return(vResponse); }