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();
