void ToggleUI() { if (inEditing && (int.Parse(AllStoreData[currentStoreIndex].data[currIndex].price) > coinsValue)) { BuyItemB.SetActive(false); } else { BuyItemB.SetActive(inEditing); } SitDownB.SetActive(false); ReturnB.SetActive(inEditing); NextItemB.SetActive(inEditing); PrevItemB.SetActive(inEditing); objectTitle.SetActive(inEditing); price.SetActive(inEditing); GoHomeB.SetActive(!inEditing); if (inEditing) { chatBubbleIsActive = currentChatBubble.activeSelf; RequestSent.SetActive(false); RequestRejected.SetActive(false); AcceptRequest.SetActive(false); SendRequest.SetActive(false); currentChatBubble.SetActive(false); } else { currentChatBubble.SetActive(chatBubbleIsActive); } ScreenshotB.SetActive(!inEditing); joystick.SetActive(!inEditing); StoreB.SetActive(!inEditing); }
public async Task <IActionResult> AcceptStatusChange([FromBody] AcceptRequest acceptRequest) { try { var userToken = User.FindFirst("sub")?.Value; OperationResult operationResult = await infectionService.AcceptStatusAsync(userToken, acceptRequest); switch (operationResult.Status) { case StatusCodes.Status200OK: logger.LogInformation("Change request is accepted"); return(Ok()); case StatusCodes.Status404NotFound: logger.LogWarning(operationResult.ErrorMessage); return(ActionError(operationResult.Status, new InnerError(ErrorTarget.AcceptStatusCodeNotFound, operationResult.ErrorMessage))); case StatusCodes.Status406NotAcceptable: logger.LogWarning(operationResult.ErrorMessage); return(ActionError(operationResult.Status, new InnerError(ErrorTarget.AcceptStatusCodeExpired, operationResult.ErrorMessage))); } logger.LogError(operationResult.ErrorMessage); return(InternalServerError(new InnerError(ErrorTarget.AcceptStatusFailed, "Unhandled exception."))); } catch (Exception e) { logger.LogError(e, $"Unhandled exception: {e.Message}"); return(InternalServerError(new InnerError(ErrorTarget.AcceptStatusRejected, "Unhandled exception."))); } }
internal void ReceviedRequests() { //Populate the excel data GlobalDefinitions.ExcelLib.PopulateInCollection(Base.ExcelPath, "ManageRequest"); //Click on ManageRequest Tab GlobalDefinitions.WaitForElementVisibility(GlobalDefinitions.driver, "XPath", "//div[text()='Manage Requests']", 10000); ManageReqTab.Click(); //Select Recieved Request GlobalDefinitions.WaitForElementVisibility(GlobalDefinitions.driver, "LinkText", "Received Requests", 10000); ReceivedReqSel.Click(); //Accept or Declane request if (GlobalDefinitions.ExcelLib.ReadData(2, "ReceviedRequest") == "Accept") { GlobalDefinitions.WaitForElementVisibility(GlobalDefinitions.driver, "XPath", "//*[@id='received-request-section']/div[2]/div[1]/table/tbody/tr[1]/td[8]/button[1]", 10000); AcceptRequest.Click(); } else if (GlobalDefinitions.ExcelLib.ReadData(2, "ReceviedRequest") == "Decline") { GlobalDefinitions.WaitForElementVisibility(GlobalDefinitions.driver, "XPath", "//*[@id='received-request-section']/div[2]/div[1]/table/tbody/tr[1]/td[8]/button[2]", 10000); DeclineRequest.Click(); } //Complete request GlobalDefinitions.WaitForElementVisibility(GlobalDefinitions.driver, "XPath", "//*[@id='received-request-section']/div[2]/div[1]/table/tbody/tr[3]/td[8]/button", 10000); CompleteRequest.Click(); Base.test.Log(LogStatus.Info, "Responded to received request successfully"); }
/// <summary>Accepts the status.</summary> /// <param name="ownerToken"></param> /// <param name="acceptRequest">The accept request.</param> /// <returns></returns> public async Task <OperationResult> AcceptStatusAsync(string ownerToken, AcceptRequest acceptRequest) { AcceptChangeResponse statusChangeResponse = statusChangeRepository.TryAcceptChangeRequest(acceptRequest.MedicalCode, expirationPeriodInHours); switch (statusChangeResponse.Result) { case AcceptChangeResult.MissingCode: case AcceptChangeResult.ReusedCode: return(OperationResult.CreateInstance(StatusCodes.Status404NotFound, "Medical code not found or already taken.")); case AcceptChangeResult.ExpiredCode: return(OperationResult.CreateInstance(StatusCodes.Status406NotAcceptable, "Medical code is expired.")); } // Try upload all meetings to blob await blobStorageService.UploadMeetingsToContainer(ownerToken, acceptRequest); // Mark the change request as accepted var userStatus = new UserStateStatus { UserToken = ownerToken, StatusId = statusChangeResponse.StatusId, StatusChangedOn = statusChangeResponse.StatusChangedOn }; // Update user status userRepository.SetUserStatus(userStatus); return(OperationResult.CreateInstance(StatusCodes.Status200OK)); }
/// <summary>Uploads the meetings to container.</summary> /// <param name="ownerToken">The owner token.</param> /// <param name="acceptRequest">The accept request.</param> public async Task UploadMeetingsToContainer(string ownerToken, AcceptRequest acceptRequest) { var blobName = $"{ownerToken}_{DateTime.UtcNow:yyyyMMddHHmmss}"; IDictionary <string, string> metadata = new Dictionary <string, string> { { UserToken, ownerToken } }; await UploadBlobAsync(blobName, acceptRequest, metadata); }
public override Task <Empty> Accept(AcceptRequest request, ServerCallContext context) { _bus.Publish(new ElectionMessage.Accept( Uuid.FromDto(request.ServerId).ToGuid(), new IPEndPoint(IPAddress.Parse(request.ServerInternalHttp.Address), (int)request.ServerInternalHttp.Port), Uuid.FromDto(request.LeaderId).ToGuid(), new IPEndPoint(IPAddress.Parse(request.LeaderInternalHttp.Address), (int)request.LeaderInternalHttp.Port), request.View)); return(EmptyResult); }
public bool HandleOutgoingMessage(NetMessage message, AcceptRequest acceptRequest) { if (acceptRequest != null) { PendingAcceptRequestsManager.AddAcceptRequest(acceptRequest); } // transform and Marshall message byte[] encodedData = EncodeMessage(message); return(SendMessage(encodedData)); }
private async Task SendAcceptAsync(Guid serverId, EndPoint serverHttpEndPoint, Guid leaderId, EndPoint leaderHttp, int view, DateTime deadline) { var request = new AcceptRequest { ServerId = Uuid.FromGuid(serverId).ToDto(), ServerHttp = new GossipEndPoint(serverHttpEndPoint.GetHost(), (uint)serverHttpEndPoint.GetPort()), LeaderId = Uuid.FromGuid(leaderId).ToDto(), LeaderHttp = new GossipEndPoint(leaderHttp.GetHost(), (uint)leaderHttp.GetPort()), View = view }; await _electionsClient.AcceptAsync(request); _electionsClient.Accept(request, deadline: deadline.ToUniversalTime()); }
private async Task SendAcceptAsync(Guid serverId, IPEndPoint serverInternalHttp, Guid leaderId, IPEndPoint leaderInternalHttp, int view, DateTime deadline) { var request = new AcceptRequest { ServerId = Uuid.FromGuid(serverId).ToDto(), ServerInternalHttp = new EndPoint(serverInternalHttp.Address.ToString(), (uint)serverInternalHttp.Port), LeaderId = Uuid.FromGuid(leaderId).ToDto(), LeaderInternalHttp = new EndPoint(leaderInternalHttp.Address.ToString(), (uint)leaderInternalHttp.Port), View = view }; await _electionsClient.AcceptAsync(request); _electionsClient.Accept(request, deadline: deadline.ToUniversalTime()); }
public int AcceptRejectRequest(AcceptRequest ar) { SqlConnection Conn = new SqlConnection(); try { Conn.ConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["connstr"].ToString(); SqlCommand cmd = new SqlCommand(); cmd.Connection = Conn; cmd.CommandType = System.Data.CommandType.StoredProcedure; cmd.CommandText = "AcceptRejectRequest"; SqlParameter ac = new SqlParameter("AcceptRejectRequest", SqlDbType.Int); ac.Value = ar.AcceptRejectRequest; cmd.Parameters.Add(ac); SqlParameter ri = new SqlParameter("RequestNo", SqlDbType.VarChar, 10); ri.Value = ar.RequestNo; cmd.Parameters.Add(ri); SqlParameter mn = new SqlParameter("MobileNo", SqlDbType.VarChar, 10); mn.Value = ar.RequestNo; cmd.Parameters.Add(mn); SqlParameter f1 = new SqlParameter("flag", SqlDbType.VarChar); f1.Value = ar.RequestNo; cmd.Parameters.Add(f1); Conn.Open(); cmd.ExecuteNonQuery(); Conn.Close(); } catch (Exception Ex) { if (Conn.State == ConnectionState.Open) { Conn.Close(); } throw Ex; } finally { if (Conn.State == ConnectionState.Open) { Conn.Close(); } } return(1); }
public override async Task <Empty> Accept(AcceptRequest request, ServerCallContext context) { var user = context.GetHttpContext().User; if (!await _authorizationProvider.CheckAccessAsync(user, AcceptOperation, context.CancellationToken).ConfigureAwait(false)) { throw AccessDenied(); } _bus.Publish(new ElectionMessage.Accept( Uuid.FromDto(request.ServerId).ToGuid(), new IPEndPoint(IPAddress.Parse(request.ServerInternalHttp.Address), (int)request.ServerInternalHttp.Port), Uuid.FromDto(request.LeaderId).ToGuid(), new IPEndPoint(IPAddress.Parse(request.LeaderInternalHttp.Address), (int)request.LeaderInternalHttp.Port), request.View)); return(EmptyResult); }
public IActionResult AcceptRequest(AcceptRequest req) { if (ActiveUser == null) { return(RedirectToAction("Login", "Home")); } Friend requested = new Friend { friend_id = req.friend_id, is_friend = req.is_friend, requested = req.requested, accepted_request = req.accepted_request, user_id = ActiveUser.user_id }; _iContext.friends.Add(requested); _iContext.SaveChanges(); ViewBag.user = ActiveUser; return(RedirectToAction("Users", "Friend")); }
public async Task<UserProfileResponse> ApplyStatusChangeCode(string code) { try { code = code.ToUpperInvariant(); _connectivityService.CheckConnection(); var meetings = ShouldShareDeviceContacts(code) ? await _meetingsService.GetMeetingsAsync().ConfigureAwait(false) : new List<Meeting>(0); var request = new AcceptRequest(code, meetings.ToList()); var response = await _platformClient.Endpoints.AcceptStatusChangeAsync(request).ConfigureAwait(false); if (response.Metadata != null) { await _metadataContainer.SetAsync(response.Metadata).ConfigureAwait(false); } if (response.UserProfile != null) { await _userProfileContainer.SetAsync(response.UserProfile).ConfigureAwait(false); } return response; } catch (Exception ex) { _logger.LogError(ex, "Failed to apply the code."); if (_serviceErrorHandler.TryHandle(ex, out var generatedException)) { generatedException.Rethrow(); } throw; } }
public static void AddAcceptRequest(AcceptRequest request) { if (request.ActionId == null) { throw new Exception("Action identifier in AcceptRequest can not be null."); } if (request.Listener == null) { throw new Exception("MessageAcceptedListener in AcceptRequest can not be null."); } lock (pendingRequests) { if (pendingRequests.ContainsKey(request.ActionId)) { throw new Exception(String.Format("Action indentifier \"{0}\" already beeing used.", request.ActionId)); } pendingRequests.Add(request.ActionId, new AcceptRequestTimeout { Request = request, EfectiveTimeout = System.DateTime.Now.AddMilliseconds(request.Timeout) }); } }
private static void FireOnTimeOut(AcceptRequest request) { request.Listener.MessageTimedout(request.ActionId); }
public bool HandleOutgoingMessage(NetMessage message, AcceptRequest acceptRequest) { if( acceptRequest != null) { PendingAcceptRequestsManager.AddAcceptRequest(acceptRequest); } // transform and Marshall message byte[] encodedData = EncodeMessage(message); return SendMessage(encodedData); }
public bool Authenticate(ICredentialsProvider provider) { log.Info("Authenticating"); if (provider == null) { throw new ArgumentNullException("AuthenticationInfo can not be null in order to authenticate."); } AuthenticationInfo authInfoToUse = null; try { authInfoToUse = provider.GetCredentials(); if (authInfoToUse == null) throw new InvalidCredentialsException("Credential provider returned null"); } catch (InvalidCredentialsException ice) { log.Error("Failed to obtain credentials.", ice); return false; } // save important information lock (this) { this.provider = provider; this.clientAuthInfo = authInfoToUse; this.usingAuth = true; } // build NetMessage string actionId = System.Guid.NewGuid().ToString(); NetAuthentication netAuth = new NetAuthentication(authInfoToUse.Token, authInfoToUse.UserAuthenticationType); if ((authInfoToUse.Roles != null) && (authInfoToUse.Roles.Count != 0)) netAuth.Roles = authInfoToUse.Roles; if (authInfoToUse.UserId != null) { netAuth.UserId = authInfoToUse.UserId; } netAuth.ActionId = actionId; NetAction netAction = new NetAction(NetAction.ActionType.AUTH); netAction.AuthenticationMessage = netAuth; NetMessage msg = new NetMessage(netAction); // build waitable object WaitMessageAccepted waitMsgAccepted = new WaitMessageAccepted(); AcceptRequest acceptRequest = new AcceptRequest(actionId, waitMsgAccepted, 7000); //send message HandleOutgoingMessage(msg, acceptRequest); // wait for response lock (waitMsgAccepted.SyncObject) { Monitor.Wait(waitMsgAccepted.SyncObject); } if (waitMsgAccepted.WaitResult != WaitMessageAccepted.Result.Accepted) { log.Error("Authenticatation failed. Reason: " + waitMsgAccepted.WaitResult); return false; } log.Info("Authenticated"); return true; }
/// <summary> /// Cancel a previous subscription. /// </summary> /// <param name="subscription">A Subscription instance.</param> /// <param name="acceptRequest">An AcceptRequest instance.</param> public void Unsubscribe(Subscription subscription, AcceptRequest acceptRequest) { if (IsClosed()) return; NetUnsubscribe netUnsubscribe = new NetUnsubscribe(subscription.DestinationPattern, subscription.DestinationType); NetAction action = new NetAction(NetAction.ActionType.UNSUBSCRIBE); action.UnsbuscribeMessage = netUnsubscribe; NetMessage netMessage = new NetMessage(action, subscription.Headers); protocolHandler.HandleOutgoingMessage(netMessage, acceptRequest); protocolHandler.RemoveSubscription(subscription); }
/// <summary> /// Subscribe to a destination. /// </summary> /// <param name="subscription">A Subscription instance.</param> /// <param name="acceptRequest">An AcceptRequest instance.</param> public void Subscribe(Subscription subscription, AcceptRequest acceptRequest) { if (IsClosed()) return; subscription.BrokerClient = this; NetSubscribe netSubscribe = new NetSubscribe(subscription.DestinationPattern, subscription.DestinationType); NetAction action = new NetAction(NetAction.ActionType.SUBSCRIBE); action.SubscribeMessage = netSubscribe; NetMessage netMessage = new NetMessage(action, subscription.Headers); protocolHandler.HandleOutgoingMessage(netMessage, acceptRequest); protocolHandler.AddSubscription(subscription); }
/// <summary> /// Publish a message (to a topic). /// </summary> /// <param name="message">A broker message</param> /// <param name="destination">A destination (e.g. "/topic/foo")</param> /// <param name="acceptRequest">An AcceptRequest instance.</param> public void Publish(NetBrokerMessage message, string destination, AcceptRequest acceptRequest) { if (IsClosed()) return; NetPublish publish = new NetPublish(destination, NetAction.DestinationType.TOPIC, message); NetAction action = new NetAction(NetAction.ActionType.PUBLISH); action.PublishMessage = publish; NetMessage netMessage = new NetMessage(action, message.Headers); protocolHandler.HandleOutgoingMessage(netMessage, acceptRequest); }
/// <summary> /// Poll an message from a queue. /// </summary> /// <param name="queueName">Queue name (e.g. "/queue/foo").</param> /// <param name="timeout">Time, in miliseconds, before the agent stops waiting for a message, if the timeout is bigger than 0. If timeout is reached a TimeoutException is thrown. If the value is zero, than the agent will wait forever. A negative value means that the client doesn't want to wait if there are no messages is local agent's queue.</param> /// <param name="reserveTime">Message reserve time, in milliseconds. Polled messages are reserved, by default, for 15 minutes. If clients prefer a different reserve time, bigger or small, they can specify it.</param> /// <param name="acceptRequest">An AcceptRequest instance.</param> /// <returns>A NetNotification instance. In case of connection fail or if there are no messages in local agent's queue when timeout is negative null is returned.</returns> public NetNotification Poll(String queueName, long timeout, long reserveTime,AcceptRequest acceptRequest) { if (IsClosed()) return null; NetPoll poll = new NetPoll(queueName, timeout); NetAction action = new NetAction(NetAction.ActionType.POLL); action.PollMessage = poll; NetMessage netMessage = new NetMessage(action); if (reserveTime != -1) { netMessage.Headers.Add("RESERVE_TIME", reserveTime.ToString()); } protocolHandler.HandleOutgoingMessage(netMessage, acceptRequest); NetNotification notification = protocolHandler.GetSyncMessage(queueName, netMessage); if (notification == BrokerProtocolHandler.UnblockNotification) throw new TimeoutException(); if (notification == BrokerProtocolHandler.NoMessageNotification) return null; return notification; }
/// <summary> /// Acknowledge a queue message. /// </summary> /// <param name="quequeName">Queue name (e.g. "/queue/foo" or "myQueue@/topic/foo").</param> /// <param name="messageId">The received message identifier.</param> /// <param name="acceptRequest">An AcceptRequest instance.</param> public void Acknowledge(string quequeName, string messageId, AcceptRequest acceptRequest) { if (IsClosed()) return; NetAcknowledge netAck = new NetAcknowledge(quequeName, messageId); NetAction action = new NetAction(NetAction.ActionType.ACKNOWLEDGE); action.AcknowledgeMessage = netAck; NetMessage netMessage = new NetMessage(action); protocolHandler.HandleOutgoingMessage(netMessage, acceptRequest); }
public bool Authenticate(ICredentialsProvider provider) { log.Info("Authenticating"); if (provider == null) { throw new ArgumentNullException("AuthenticationInfo can not be null in order to authenticate."); } AuthenticationInfo authInfoToUse = null; try { authInfoToUse = provider.GetCredentials(); if (authInfoToUse == null) { throw new InvalidCredentialsException("Credential provider returned null"); } } catch (InvalidCredentialsException ice) { log.Error("Failed to obtain credentials.", ice); return(false); } // save important information lock (this) { this.provider = provider; this.clientAuthInfo = authInfoToUse; this.usingAuth = true; } // build NetMessage string actionId = System.Guid.NewGuid().ToString(); NetAuthentication netAuth = new NetAuthentication(authInfoToUse.Token, authInfoToUse.UserAuthenticationType); if ((authInfoToUse.Roles != null) && (authInfoToUse.Roles.Count != 0)) { netAuth.Roles = authInfoToUse.Roles; } if (authInfoToUse.UserId != null) { netAuth.UserId = authInfoToUse.UserId; } netAuth.ActionId = actionId; NetAction netAction = new NetAction(NetAction.ActionType.AUTH); netAction.AuthenticationMessage = netAuth; NetMessage msg = new NetMessage(netAction); // build waitable object WaitMessageAccepted waitMsgAccepted = new WaitMessageAccepted(); AcceptRequest acceptRequest = new AcceptRequest(actionId, waitMsgAccepted, 7000); //send message HandleOutgoingMessage(msg, acceptRequest); // wait for response lock (waitMsgAccepted.SyncObject) { Monitor.Wait(waitMsgAccepted.SyncObject); } if (waitMsgAccepted.WaitResult != WaitMessageAccepted.Result.Accepted) { log.Error("Authenticatation failed. Reason: " + waitMsgAccepted.WaitResult); return(false); } log.Info("Authenticated"); return(true); }
public override async Task <AcceptResponse> Accept(AcceptRequest request, ServerCallContext context) { var validatorId = request.ValidatorId; var validatorLinkEntity = _validatorLinkReader.Get().FirstOrDefault(v => v.InvitationToken == request.InviteId); if (validatorLinkEntity == null) { _logger.LogInformation("Cannot accept invitation: 'Invitation token is not correct'. InviteId='{InviteId}'; ValidatorId='{ValidatorId}'", request.InviteId, request.ValidatorId); return(new AcceptResponse() { Error = new ValidatorApiError() { Code = ValidatorApiError.Types.ErrorCodes.WrongInvitation, Message = "Invitation token is not correct" } }); } if (validatorLinkEntity.IsAccepted) { _logger.LogInformation("Cannot accept invitation: 'Invitation token already accepted'. InviteId='{InviteId}'; ValidatorId='{ValidatorId}'", request.InviteId, request.ValidatorId); return(new AcceptResponse() { Error = new ValidatorApiError() { Code = ValidatorApiError.Types.ErrorCodes.WrongInvitation, Message = "Invitation token already accepted" } }); } if (string.IsNullOrEmpty(request.PublicKeyPem)) { _logger.LogInformation("Cannot accept invitation: 'PublicKeyPem cannot be empty'. InviteId='{InviteId}'; ValidatorId='{ValidatorId}'", request.InviteId, request.ValidatorId); return(new AcceptResponse() { Error = new ValidatorApiError() { Code = ValidatorApiError.Types.ErrorCodes.WrongInvitation, Message = "PublicKeyPem cannot be empty" } }); } var token = GenerateJwtToken(validatorId, request.PublicKeyPem, validatorLinkEntity.ApiKeyId, validatorLinkEntity.TenantId); var resp = new AcceptResponse { ApiKey = token, Name = validatorLinkEntity.Name, Position = validatorLinkEntity.Position, Description = validatorLinkEntity.Description }; validatorLinkEntity.ValidatorId = request.ValidatorId; validatorLinkEntity.PublicKeyPem = request.PublicKeyPem; validatorLinkEntity.IsAccepted = true; validatorLinkEntity.DeviceInfo = request.DeviceInfo; validatorLinkEntity.PushNotificationFcmToken = request.PushNotificationFCMToken; await _validatorLinkWriter.InsertOrReplaceAsync(validatorLinkEntity); _logger.LogInformation("Invitation accepted. InviteId='{InviteId}'; ValidatorId='{ValidatorId}'; PushNotificationFcmToken='{PushNotificationFcmToken}'", request.InviteId, request.ValidatorId, request.PushNotificationFCMToken); return(resp); }
/// <summary> /// Accepts the status change request. /// </summary> /// <remarks> /// Called when the user accepts the status change request. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='body'> /// </param> public static UserProfileResponse AcceptStatusChange(this IPlatformEndpoints operations, AcceptRequest body = default(AcceptRequest)) { return(operations.AcceptStatusChangeAsync(body).GetAwaiter().GetResult()); }
/// <summary> /// Accepts the status change request. /// </summary> /// <remarks> /// Called when the user accepts the status change request. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='body'> /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <UserProfileResponse> AcceptStatusChangeAsync(this IPlatformEndpoints operations, AcceptRequest body = default(AcceptRequest), CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.AcceptStatusChangeWithHttpMessagesAsync(body, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public Task ReceiveAcceptRequestAsync(AcceptRequest <T> request) => throw new NotImplementedException();
public Task SendAcceptRequestAsync(AcceptRequest <T> request) => throw new System.NotImplementedException();