private void UserRequest_Click(object sender, RoutedEventArgs e)
{
var requestHolder = ((this.Parent as FrameworkElement).FindName("userrequest") as ContentControl);
if (requestHolder.Visibility == Visibility.Visible)
{
requestHolder.Visibility = Visibility.Collapsed;
var ur = requestHolder.Content as UserRequests;
if (ur != null)
{
ur.stop();
}
requestHolder.Content = null;
}
else
{
var ur = new UserRequests();
if (Double.IsNaN(ur.Height))
{
ur.Height = 200;
}
if (Double.IsNaN(ur.Width))
{
ur.Width = 400;
}
if (Manager.Config.UserRequestSize.Width > 2)
{
ur.Width = Manager.Config.UserRequestSize.Width;
ur.Height = Manager.Config.UserRequestSize.Height;
}
var h = WorkPage.CurrentPage.ActualHeight - 55;
if (h < ur.Height)
{
ur.Height = h;
}
ur.MinHeight = ur.Height;
requestHolder.Content = ur;
VisualEx.MakeResizable(requestHolder.Content as FrameworkElement, false);
requestHolder.Visibility = Visibility.Visible;
}
}
public async Task <ActionResult> GetUserRequests(string argRequestType)
{
#region Declarations
UserRequests l_UserRequests = new UserRequests();
UserRequestsBECollection l_UserRequestsBECollection = new UserRequestsBECollection();
UserRequestsCollection l_UserRequestsCollection = new UserRequestsCollection();
string l_skillsURL = string.Empty;
#endregion
l_skillsURL = apiBaseURL + "/GetUserRequests?argLoggedInUser="******"&argType=" + argRequestType + "";
HttpResponseMessage l_SkillsData = await client.GetAsync(l_skillsURL);
if (l_SkillsData != null && l_SkillsData.IsSuccessStatusCode)
{
var l_SkillResponse = l_SkillsData.Content.ReadAsStringAsync().Result;
l_UserRequestsBECollection = JsonConvert.DeserializeObject <UserRequestsBECollection>(l_SkillResponse);
}
l_UserRequestsCollection = ConvertUserRequestsToModel(l_UserRequestsBECollection);
return(PartialView("_partialGetUserRequests", l_UserRequestsCollection));
}
/// <summary>
/// Executed when Navigation is performed
/// </summary>
/// <param name="mode">Value representing page to navigate to</param>
private async void OnNavigateModeChanged(Mode mode)
{
//Load user requests when History view is opened
if (mode == Mode.History)
{
LoaderService.Instance.ShowLoader();
bool isSuccess = await Task.Run(() =>
{
try
{
//this code added to show loader working
Thread.Sleep(3000);
using (UserRequestApiService userRequestApi = new UserRequestApiService())
{
IEnumerable <UserRequest> userRequests = userRequestApi.GetUserRequests(AutoLoginService.Instance.CurrentUser.Guid)
.Select(r => { r.ChangedAt = r.ChangedAt.ToLocalTime(); return(r); });
UserRequests = new ObservableCollection <UserRequest>(userRequests);
return(true);
}
}
catch (Exception ex)
{
Logger.Log(ex);
return(false);
}
});
LoaderService.Instance.HideLoader();
if (!isSuccess)
{
Logger.Log(Resources.UserRequest_LoadAllFailed);
MessageBox.Show(Resources.UserRequest_LoadAllFailed);
}
}
else
{
//Clear user requests list when user opens other pages
UserRequests.Clear();
}
}
private void btn_addProjectToWorker_Click(object sender, EventArgs e)
{
List <User> users = new List <User>();
for (int i = 0; i < checkedListBoxWorkers.Items.Count; i++)
{
if (checkedListBoxWorkers.GetItemChecked(i))
{
users.Add((checkedListBoxWorkers.Items[i] as User));
}
}
bool isSuccess = UserRequests.addWorkerToProject((cmbx_projects.SelectedItem as Project).ProjectId, users);
if (isSuccess)
{
MessageBox.Show("Success");
}
else
{
MessageBox.Show("ERROR!");
}
}
/// <summary>
/// Try to get ip cumputer and login with ip
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Main_Load(object sender, EventArgs e)
{
string computerIp = "";
var host = Dns.GetHostEntry(Dns.GetHostName());
foreach (var ip in host.AddressList)
{
if (ip.AddressFamily == AddressFamily.InterNetwork)
{
computerIp = ip.ToString();
}
}
User user = UserRequests.LoginByIP(computerIp);
//enter form by premission
Form form = BaseService.GetDepartmentUser(user);
form.BringToFront();
form.TopMost = true;
form.Focus();
form.Show();
}
private void AddWorkerToProject_Load(object sender, EventArgs e)
{
List <User> workers = UserRequests.getSimpleWorkers();
if (workers != null)
{
checkedListBoxWorkers.DisplayMember = "UserName";
foreach (User worker in workers)
{
checkedListBoxWorkers.Items.Add(worker);
}
}
List <Project> projects = TaskRequests.getAllProjects();
if (projects != null)
{
cmbx_projects.DisplayMember = "ProjectName";
foreach (Project project in projects)
{
cmbx_projects.Items.Add(project);
}
}
}
private void UpdateWorkerInDB(GridViewRowInfo newRowInfo)
{
User editWorker = getUpdateWorker();
editWorker.UserId = (newRowInfo.Tag as User).UserId;
try
{
if (UserRequests.UpdateUser(editWorker))
{
UpdateWorkerInGridView();
}
else
{
this.radGridView1.CloseEditor();
}
}
catch
{
radGridView1.CloseEditor();
RadMessageBox.SetThemeName(ThemeName);
RadMessageBox.Show("update worker failed", "error", MessageBoxButtons.OK, RadMessageIcon.None, MessageBoxDefaultButton.Button1);
}
}
public IActionResult Index()
{
var userRequests = new UserRequests
{
Id = 1,
Reference = "U001",
Firstname = "Gilles",
Firstname2 = "Gilles",
Lastname = "Lautrou"
};
//Add
_solr.Add(userRequests);
_solr.Commit();
//Get
var results1 = _solr.Query(new SolrQueryByField("id", "1"));
var results2 = _solr.Query(new SolrQueryByField("firstname2", "Gilles"));
var results3 = _solr.Query(new SolrQueryByField("firstname2", "gilles"));
var results4 = _solr.Query(new SolrQueryByField("firstname2", "lles"));
return(View());
}
public async Task ReadTextMessageFromUpdateAsync(Update update)
{
User senderUser;
ChatId chatId;
string updateMessage = string.Empty;
try {
updateMessage = update.Message.Text;
updateMessage = updateMessage.StartsWith("/") ? updateMessage.ToLower() : updateMessage;
senderUser = update.Message.From;
chatId = update.Message.Chat.Id;
DatabaseHandler.GetCurrentRequest(chatId.Identifier);
// Update UI
DataGridView.Invoke((MethodInvoker) delegate {
// From,Name,To,ReceiverName,Message
DataGridView.Rows.Add(chatId.Identifier, senderUser.FirstName, "BOT", "BOT", updateMessage);
});
if (updateMessage.StartsWith(BotConfigs.CMD_START))
{
if (updateMessage.Equals(BotConfigs.CMD_START)) //----------------------------------------------------------------- '/start'
{
if (DatabaseHandler.UserExists(id: chatId.Identifier))
{
BotApiMethods.SendTextMessageAsync(chatId: chatId, message: BotConfigs.MSG_RECEIVE_CMD); //------------------------------------ Send "what can i do for u?"
}
else //---------------------------------------------------------------------------------------------------- Register new user
{
Image profileImage = await BotApiMethods.GetProfileImageAsync(senderUser.Id);
Model.NewUser newUser = new Model.NewUser(chatId, senderUser, profileImage);
if (DatabaseHandler.RegisterUser(newUser: newUser))
{
BotApiMethods.SendTextMessageAsync(chatId: chatId, message: BotConfigs.MSG_WELCOME); //------------------- Send "welcome message"
}
else
{
BotApiMethods.SendTextMessageAsync(chatId: chatId, message: BotConfigs.MSG_EXCEPTION);
// send to admin
}
}
}
else //-------------------------------------------------------------------------------------------------------- '/start contactcode'
{
if (!DatabaseHandler.UserExists(chatId.Identifier)) // ------------------------------ Register new user
{
Image profileImage = await BotApiMethods.GetProfileImageAsync(senderUser.Id);
Model.NewUser newUser = new Model.NewUser(chatId, senderUser, profileImage);
if (!DatabaseHandler.RegisterUser(newUser: newUser))
{
BotApiMethods.SendTextMessageAsync(chatId: chatId, message: BotConfigs.MSG_EXCEPTION);//--------------------------------- sending a message to user that shows we are aware of the problem, we'll fix it soon
//------------------------------------------------------------------------------------------------------ send the problem to admin(s)
return;
}
}
string contactCode = updateMessage.Split(separator: ' ')[1]; //------ updateMessage = '/start contactCode'.splitBySpace ----> contactCode
if (DatabaseHandler.UserExists(contactCode: contactCode))
{
string fullName = DatabaseHandler.GetFullNameByContactCode(contactCode: contactCode);
BotApiMethods.SendTextMessageAsync(chatId: chatId, message: BotConfigs.MSG_SENDING_ANONYMOUS_TO.Replace("X", fullName)); //---- "you're going to send an anonymous message for 'fullName' please type your message"
DatabaseHandler.EditUserRequest(id: chatId.Identifier, userRequests: UserRequests.sendMessage, contactCode: contactCode); /* ---Update tbl_requests for chatId with request "sendMessage" and "contactCode",
* if user types anymessage and press enter, we will send it to target, (exception: user press BackButton)*/
// <REQUEST ADDED TO DATABASE, NOW WE NEED TO ANALYZE THE NEXT USER'S MESSAGE>
}
else
{
BotApiMethods.SendTextMessageAsync(chatId: chatId, message: BotConfigs.MSG_USER_NOT_FOUND);//--------------- user not found
}
}
}
else if (updateMessage.Equals(BotConfigs.CMD_LINK)) //------------------------------------------- Request contact links
{
if (DatabaseHandler.IsContactNameSet(id: chatId.Identifier)) //---------------------------------------------------------------------- If user's name is set to database
{
string links = BotApiMethods.CreateAnonymousLinks(id: chatId.Identifier); //-------------------------------------------- Receive links
BotApiMethods.SendTextMessageAsync(chatId: chatId, message: links);
}
else //---------------------------------------------------------------------------------------------------------------------------------- before sending links, set user's name to database
{
if (DatabaseHandler.EditUserRequest(id: chatId.Identifier, userRequests: Model.UserRequests.contactCode)) // Add a request to database, user wants to enter his/her own name.
{
BotApiMethods.SendTextMessageAsync(chatId: chatId.Identifier, message: BotConfigs.MSG_GET_NAME, keyboard: Keyboards.Back);
}
else
{
BotApiMethods.SendTextMessageAsync(chatId: chatId, message: BotConfigs.MSG_EXCEPTION);
// send to admin
}
}
}
else if (updateMessage.Equals(BotConfigs.CMD_INBOX)) // ------------------- receive inbox Messages from database.
{
System.Data.SqlClient.SqlDataReader userMessages = DatabaseHandler.GetAllMessagesFor(id: chatId.Identifier); // -- request to database for returning messages.
if (userMessages != null)
{
string messages = string.Empty; // User messages.
int messageNumber = 0; // ------------------------ messages count.
while (userMessages.Read())
{
messages = messages + $"{++messageNumber}- {userMessages.GetString(0)}\n"; // Model -> 1- HereIsMessageOne ... \n 2- HereIsMessageTwo ... and etc..
}
userMessages.Close();
BotApiMethods.SendTextMessageAsync(chatId: chatId, message: $"{BotConfigs.MSG_SHOW_INBOX.Replace("X", messageNumber.ToString())}{messages}", keyboard: Keyboards.Inbox); // Send messages to user.
}
}
else if (updateMessage.StartsWith(BotConfigs.CMD_HELP))
{
BotApiMethods.SendTextMessageAsync(chatId: chatId.Identifier, message: BotConfigs.MSG_HELP);
}
else if (updateMessage.StartsWith(BotConfigs.CMD_REPLY))
{
BotApiMethods.SendTextMessageAsync(chatId: chatId.Identifier, message: BotConfigs.MSG_ENTER_REPLY_NUMBER, keyboard: Keyboards.Back);
DatabaseHandler.EditUserRequest(id: chatId.Identifier, userRequests: UserRequests.replyToMessage);
}
else if (updateMessage.Equals(BotConfigs.CMD_BACK)) // ---- We need to clean user's request from database for preventing future errors/exceptions.
{
if (DatabaseHandler.EditUserRequest(id: chatId.Identifier, userRequests: UserRequests.empty))
{
BotApiMethods.SendTextMessageAsync(chatId: chatId.Identifier, message: BotConfigs.MSG_RECEIVE_CMD);
}
}
else // --------------------------------------------------------------------------------------------------------------- Handling user requests like sendMessage, replyMessage and etc..
{
UserRequests request = DatabaseHandler.GetCurrentRequest(id: chatId.Identifier);
if (request == UserRequests.empty)
{
return;
}
if (request == UserRequests.contactCode) // If user requests the contact links.
{
if (DatabaseHandler.SetContactName(id: chatId.Identifier, name: updateMessage))
{
string links = BotApiMethods.CreateAnonymousLinks(id: chatId.Identifier); // --------- Receive links
BotApiMethods.SendTextMessageAsync(chatId: chatId, message: links); // Send links to user
}
}
else if (request == UserRequests.sendMessage) /* If user requests to send anonymous Message to anotherone. We already saved the target's contactCode in database when
* setting up the sendMessage request(line 75)*/
{
string rContact = DatabaseHandler.GetContactCodeFromRequests(id: chatId.Identifier); // receiver contactCode
long rId = DatabaseHandler.GetIdByContactCode(contactCode: rContact); // reciver id
string rName = DatabaseHandler.GetFullNameByContactCode(contactCode: rContact); // receiver name
string rUser = DatabaseHandler.GetUsernameById(id: rId); // receiver username
string sContact = DatabaseHandler.GetContactCode(id: chatId.Identifier); // sender contactCode
string sName = DatabaseHandler.GetFullNameByContactCode(contactCode: sContact); // sender name
string sUser = DatabaseHandler.GetUsernameById(id: chatId.Identifier); // sender username, we could also get it from senderUser object too(line 29)
DatabaseHandler.AddMessage(receiverId: rId, receiverName: rName, receiverContactCode: rContact, receiverUsername: rUser, message: updateMessage, senderId: chatId.Identifier, senderName: sName, senderUsername: sUser); // Add message to database.
DatabaseHandler.EditUserRequest(id: chatId.Identifier, userRequests: UserRequests.empty); // Clean senderUser request from database.
BotApiMethods.SendTextMessageAsync(chatId: chatId.Identifier, message: BotConfigs.MSG_SENT); // Notif sender that your message sent.
BotApiMethods.SendTextMessageAsync(chatId: rId, message: BotConfigs.MSG_NEW_MESSAGE); // Notif receiver that you received a new message.
}
else if (request == UserRequests.replyToMessage)
{
/* We need to get all messages from database for current user
* then we have to pick the number which user told us want to reply it.(it saved in tbl_requests, column contactCode.
* after that, we find the senderId from database where selected message and receiverId equals to user info*/
int messageNumber;
string messageToSearch = string.Empty;
if (int.TryParse(s: updateMessage, result: out messageNumber))
{
System.Data.SqlClient.SqlDataReader userMessages = DatabaseHandler.GetAllMessagesFor(id: chatId.Identifier);
int counter = 1;
while (userMessages.Read())
{
if (counter++ == messageNumber)
{
messageToSearch = userMessages.GetString(0);
break;
}
}
userMessages.Close();
if (!string.IsNullOrEmpty(value: messageToSearch))
{
long senderId = DatabaseHandler.GetSenderIdByMessage(receiverId: chatId.Identifier, message: messageToSearch);
if (senderId != 0)
{
if (DatabaseHandler.EditUserRequest(id: chatId.Identifier, userRequests: UserRequests.pickReplyMessage, contactCode: senderId.ToString()))
{
BotApiMethods.SendTextMessageAsync(chatId: chatId.Identifier, message: BotConfigs.MSG_ENTER_REPLY_MESSAGE, keyboard: Keyboards.Back);
}
}
}
}
}
else if (request == UserRequests.pickReplyMessage)
{
// NEXT UPDATE STARTS HERE. replyToMessage didnt tested.
long id;
if (long.TryParse(s: DatabaseHandler.GetContactCodeFromRequests(id: chatId.Identifier), result: out id))
{
BotApiMethods.SendTextMessageAsync(chatId: id, message: $"{BotConfigs.MSG_REPLY_ANSWERED}{updateMessage}");
BotApiMethods.SendTextMessageAsync(chatId: chatId.Identifier, message: BotConfigs.MSG_SENT);
DatabaseHandler.EditUserRequest(id: chatId.Identifier, userRequests: UserRequests.empty);
}
}
}
} catch (Exception ex) {
ErrorHandler.SetError(source: "ReadMessageFromUpdateAsync", error: ex.Message);
return;
}
}
public UpdateHours(User teamHead)
{
InitializeComponent();
cmb_workers.DataSource = UserRequests.GetWorkersByTeamhead(teamHead.UserId);
cmb_workers.DisplayMember = "userName";
}
public async Task <ActionResult <string> > GetAsync()
{
List <User> users = await UserRequests.GetAllUsersInACityOrWithinDistance("London", 50);
return(JsonConvert.SerializeObject(users));;
}
public async Task TestGetAllUsersInACityOrWithinDistance2()
{
List <User> allUsers = await UserRequests.GetAllUsersInACityOrWithinDistance("London", 30);
Assert.AreEqual(allUsers.Count, 8);
}
public async Task TestGetAllUserGivenDistanceFromCity1()
{
List <User> allUsers = await UserRequests.GetAllUserGivenDistanceFromCity("London", 50);
Assert.AreEqual(allUsers.Count, 3);
}
public async Task TestGetAllUsersListedInACity1()
{
List <User> allUsers = await UserRequests.GetAllUsersListedInACity("London");
Assert.AreEqual(allUsers.Count, 6);
}
private APIGatewayProxyResponse HandleCharacterAssignRequest(opendkpContext pDatabase, UserRequests pUserRequest, APIGatewayProxyRequest pRequest, CognitoUser pCognitoUser)
{
var vResponse = HttpHelper.HandleError("[UserRequestsLambda] Issue with DB or Query", 500);
//We need to retrieve the ClientId for multitenancy purposes
var vClientId = pRequest.Headers["clientid"];
if (!string.IsNullOrWhiteSpace(pUserRequest.RequestDetails))
{
dynamic vCharacterId = JsonConvert.DeserializeObject(pUserRequest.RequestDetails);
int vId = vCharacterId.characterId;
//Determine if we've already got a character associated for this character Id
var vFound = pDatabase.UserXCharacter.FirstOrDefault(x => x.ClientId.Equals(vClientId) && x.IdCharacter == vId);
if (vFound != null)
{
return(HttpHelper.HandleError("[UserRequestsLambda] This character has already been associated to an account", 500));
}
//Verify that there is not already an open pending request for the specific character
//Note: It's possible someone else tries to claim someone elses character and this request would block them
//TODO: Review note above, determine if anything should be done regarding this scenario
var vPendingRequests = pDatabase.UserRequests.Where(x => x.ClientId.Equals(vClientId) &&
x.RequestType == UserRequests.TYPE_CHARACTER_ASSIGN &&
x.RequestStatus == UserRequests.STATUS_PENDING).ToList();
foreach (var vRequest in vPendingRequests)
{
dynamic vTmpCharId = JsonConvert.DeserializeObject(vRequest.RequestDetails);
int vTmpId = vTmpCharId.characterId;
if (vTmpId == vId)
{
return(HttpHelper.HandleError("[UserRequestsLambda] There is already a pending request for this character", 500));
}
}
pUserRequest.Requestor = pCognitoUser.Username;
pUserRequest.RequestStatus = UserRequests.STATUS_PENDING;
pUserRequest.RequestTimestamp = DateTime.Now;
pUserRequest.RequestApprover = "NONE";
pUserRequest.ReviewedTimestamp = DateTime.Now;
pUserRequest.ClientId = vClientId;
pDatabase.Add(pUserRequest);
pDatabase.SaveChanges();
vResponse = HttpHelper.HandleResponse(pUserRequest, 200, true);
}
return(vResponse);
}
private APIGatewayProxyResponse HandleRaidTickRequest(opendkpContext pDatabase, UserRequests pUserRequest, APIGatewayProxyRequest pRequest, CognitoUser pCognitoUser)
{
var vResponse = HttpHelper.HandleError("[UserRequestsLambda] Issue with DB or Query", 500);
//We need to retrieve the ClientId for multitenancy purposes
var vClientId = pRequest.Headers["clientid"];
if (!string.IsNullOrWhiteSpace(pUserRequest.RequestDetails))
{
dynamic vModel = JsonConvert.DeserializeObject(pUserRequest.RequestDetails);
//`{characterName:${this.CharacterName},tickId=${this.SelectedData.TickId},reason:${this.LogData}}`;
string vCharacterName = vModel.characterName;
int vTickId = vModel.tickId;
string vReason = vModel.reason;
//First, lets make sure the Character Exists in the Database!
Characters vCharacter = CharacterHelper.GetCharacterByName(pDatabase, vClientId, vCharacterName);
if (vCharacter == null)
{
return(HttpHelper.HandleError(string.Format("{0} does not exist in the database...", vCharacterName), 500));
}
//Second, lets confirm the Character is associated with the Account
var vUser = pDatabase.UserXCharacter.FirstOrDefault(x => x.ClientId.Equals(vClientId) && x.IdCharacter == vCharacter.IdCharacter && x.User.Equals(pCognitoUser.Username));
if (vUser == null)
{
return(HttpHelper.HandleError(string.Format("{0} is not associated with your account", vCharacterName), 500));
}
//Determine if this character already has the raid tick
var vFound = pDatabase.TicksXCharacters.FirstOrDefault(x => x.ClientId.Equals(vClientId) && x.IdCharacter == vCharacter.IdCharacter && x.IdTick == vTickId);
if (vFound != null)
{
return(HttpHelper.HandleError("You already have credit for this raid tick!", 500));
}
//Verify that there is not already an open pending request
var vPendingRequests = pDatabase.UserRequests.Where(x => x.ClientId.Equals(vClientId) &&
x.RequestType == UserRequests.TYPE_RAIDTICK &&
x.RequestStatus == UserRequests.STATUS_PENDING).ToList();
foreach (var vRequest in vPendingRequests)
{
dynamic vTmpModel = JsonConvert.DeserializeObject(vRequest.RequestDetails);
string vTmpName = vTmpModel.characterName;
int vTmpId = vTmpModel.tickId;
if (vTmpId == vTickId && vCharacterName.Trim().Equals(vTmpName.Trim(), StringComparison.InvariantCultureIgnoreCase))
{
return(HttpHelper.HandleError("There is already a pending request for this character & raid tick!", 500));
}
}
pUserRequest.Requestor = pCognitoUser.Username;
pUserRequest.RequestStatus = UserRequests.STATUS_PENDING;
pUserRequest.RequestTimestamp = DateTime.Now;
pUserRequest.RequestApprover = "NONE";
pUserRequest.ReviewedTimestamp = DateTime.Now;
pUserRequest.ClientId = vClientId;
pDatabase.Add(pUserRequest);
pDatabase.SaveChanges();
vResponse = HttpHelper.HandleResponse(pUserRequest, 200, true);
}
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);
}
private APIGatewayProxyResponse UpdateCharacterAssignRequest(opendkpContext pDatabase, string pClientId, UserRequests pUserRequest, CognitoUser pCognitoUser)
{
var vResponse = HttpHelper.HandleError("[UserRequestsLambda] Issue with DB or Query", 500);
if (!string.IsNullOrWhiteSpace(pUserRequest.Requestor) && !string.IsNullOrWhiteSpace(pUserRequest.RequestDetails))
{
if (pUserRequest.RequestStatus == UserRequests.STATUS_APPROVED)
{
dynamic vCharacterId = JsonConvert.DeserializeObject(pUserRequest.RequestDetails);
int vId = vCharacterId.characterId;
//I need to associate the character
//If character associate is successful, I need to update pending request to completed
using (var dbContextTransaction = pDatabase.Database.BeginTransaction())
{
UserXCharacter vAssociation = new UserXCharacter();
vAssociation.User = pUserRequest.Requestor;
vAssociation.IdCharacter = vId;
vAssociation.ApprovedBy = pCognitoUser.Username;
vAssociation.ClientId = pClientId;
pDatabase.Add(vAssociation);
UserRequests vRequest = pDatabase.UserRequests.FirstOrDefault(x => x.ClientId.Equals(pClientId) && x.Id == pUserRequest.Id);
if (vRequest == null)
{
return(HttpHelper.HandleError("[UserRequestsLambda] Couldn't find the Request in DB to update...", 500));
}
vRequest.RequestApprover = pCognitoUser.Username;
vRequest.ReviewedTimestamp = DateTime.Now;
vRequest.RequestStatus = UserRequests.STATUS_APPROVED;
vRequest.ClientId = pClientId;
pDatabase.SaveChanges();
dbContextTransaction.Commit();
vResponse = HttpHelper.HandleResponse(vRequest, 200, true);
}
}
else if (pUserRequest.RequestStatus == UserRequests.STATUS_DENIED)
{
UserRequests vRequest = pDatabase.UserRequests.FirstOrDefault(x => x.ClientId.Equals(pClientId) && x.Id == pUserRequest.Id);
if (vRequest == null)
{
return(HttpHelper.HandleError("[UserRequestsLambda] Couldn't find the Request in DB to update...", 500));
}
vRequest.RequestApprover = pCognitoUser.Username;
vRequest.ReviewedTimestamp = DateTime.Now;
vRequest.RequestStatus = UserRequests.STATUS_DENIED;
vRequest.RequestDetails = pUserRequest.RequestDetails;
vRequest.ClientId = pClientId;
pDatabase.SaveChanges();
vResponse = HttpHelper.HandleResponse(vRequest, 200, true);
}
}
return(vResponse);
}
private APIGatewayProxyResponse UpdateRaidTickRequest(opendkpContext pDatabase, UserRequests pUserRequest, CognitoUser pCognitoUser, string pClientId)
{
var vResponse = HttpHelper.HandleError("[UserRequestsLambda] Issue with DB or Query", 500);
if (!string.IsNullOrWhiteSpace(pUserRequest.Requestor) && !string.IsNullOrWhiteSpace(pUserRequest.RequestDetails))
{
if (pUserRequest.RequestStatus == UserRequests.STATUS_APPROVED)
{
dynamic vModel = JsonConvert.DeserializeObject(pUserRequest.RequestDetails);
//`{characterName:${this.CharacterName},tickId=${this.SelectedData.TickId},reason:${this.LogData}}`;
string vCharacterName = vModel.characterName;
int vTickId = vModel.tickId;
string vReason = vModel.reason;
//I need to associate the character
//If character associate is successful, I need to update pending request to completed
using (var dbContextTransaction = pDatabase.Database.BeginTransaction())
{
//First, lets make sure the Character Exists in the Database!
Characters vCharacter = CharacterHelper.GetCharacterByName(pDatabase, pClientId, vCharacterName);
if (vCharacter == null)
{
return(HttpHelper.HandleError(string.Format("{0} does not exist in the database...", vCharacterName), 500));
}
//Determine if this character already has the raid tick
var vFound = pDatabase.TicksXCharacters.FirstOrDefault(x => x.ClientId.Equals(pClientId) && x.IdCharacter == vCharacter.IdCharacter && x.IdTick == vTickId);
if (vFound != null)
{
return(HttpHelper.HandleError("You already have credit for this raid tick!", 500));
}
TicksXCharacters vTickToInsert = new TicksXCharacters();
vTickToInsert.IdCharacter = vCharacter.IdCharacter;
vTickToInsert.IdTick = vTickId;
vTickToInsert.ClientId = pClientId;
pDatabase.Add(vTickToInsert);
//Update the Request
UserRequests vRequest = pDatabase.UserRequests.FirstOrDefault(x => x.ClientId.Equals(pClientId) && x.Id == pUserRequest.Id);
if (vRequest == null)
{
return(HttpHelper.HandleError("[UserRequestsLambda] Couldn't find the Request in DB to update...", 500));
}
vRequest.RequestApprover = pCognitoUser.Username;
vRequest.ReviewedTimestamp = DateTime.Now;
vRequest.RequestStatus = UserRequests.STATUS_APPROVED;
vRequest.ClientId = pClientId;
pDatabase.SaveChanges();
dbContextTransaction.Commit();
//Update Caches
int vStatus = CacheManager.UpdateSummaryCacheAsync(pClientId).GetAwaiter().GetResult();
Console.WriteLine("SummaryCacheResponse=" + vStatus);
vResponse = HttpHelper.HandleResponse(vRequest, 200, true);
}
}
else if (pUserRequest.RequestStatus == UserRequests.STATUS_DENIED)
{
UserRequests vRequest = pDatabase.UserRequests.FirstOrDefault(x => x.ClientId.Equals(pClientId) && x.Id == pUserRequest.Id);
if (vRequest == null)
{
return(HttpHelper.HandleError("[UserRequestsLambda] Couldn't find the Request in DB to update...", 500));
}
vRequest.RequestApprover = pCognitoUser.Username;
vRequest.ReviewedTimestamp = DateTime.Now;
vRequest.RequestStatus = UserRequests.STATUS_DENIED;
vRequest.RequestDetails = pUserRequest.RequestDetails;
vRequest.ClientId = pClientId;
pDatabase.SaveChanges();
vResponse = HttpHelper.HandleResponse(vRequest, 200, true);
}
}
return(vResponse);
}
