public override AuthorizationResponse Login(AuthorizationRequest request, Metadata headers = null, DateTime?deadline = null,
CancellationToken cancellationToken = default(CancellationToken))
{
AuthorizationResponse response = base.Login(request, headers, deadline, cancellationToken);
Auth.Login(response.Token);
return(response);
}
/// <inheritdoc/>
public virtual async Task <CloudStorageToken> FetchTokenAsync(string redirectedUrl, string state, string codeVerifier)
{
if (string.IsNullOrWhiteSpace(redirectedUrl))
{
throw new ArgumentNullException(nameof(redirectedUrl));
}
if (string.IsNullOrWhiteSpace(state))
{
throw new ArgumentNullException(nameof(state));
}
AuthorizationResponse response = OAuth2Utils.ParseAuthorizationResponseUrl(redirectedUrl);
// Check whether the user denied access
if (!response.IsAccessGranted)
{
return(null);
}
// Verify state
if (response.State != state)
{
throw new CloudStorageException("The authorization response has a wrong state, this indicates a hacking attempt.", null);
}
// Determine flow type
AuthorizationFlow flow;
if (!string.IsNullOrWhiteSpace(response.Token))
{
flow = AuthorizationFlow.Token;
}
else if (!string.IsNullOrWhiteSpace(response.Code))
{
flow = AuthorizationFlow.Code;
}
else
{
throw new CloudStorageException("The authorization response is neither form a token-flow, nor from a code-flow request.", null);
}
switch (flow)
{
case AuthorizationFlow.Token:
return(new CloudStorageToken
{
AccessToken = response.Token,
ExpiryDate = null,
RefreshToken = null
});
case AuthorizationFlow.Code:
return(await ExchangeCodeForTokenAsync(response.Code, codeVerifier));
default:
return(null); // Never happens
}
}
public AuthorizationResponse IsAuthorized(string userId)
{
AuthorizationResponse authorizationResponse = new AuthorizationResponse
{
IsAuthorized = true
};
return(authorizationResponse);
}
public void SetAuthorization(string feed, string topic, AuthorizationResponse authorization)
{
if (!_authorizations.TryGetValue(feed, out var topicAuthorizations))
{
_authorizations.Add(feed, topicAuthorizations = new Dictionary <string, AuthorizationResponse>());
}
topicAuthorizations[topic] = authorization;
}
public SettlementRequest FromAuthorizationResponse(AuthorizationResponse response)
{
return new SettlementRequest
{
AccountNumber = response.AccountNumber,
TransactionId = response.TransactionId,
ProviderTransactionId = response.ProviderTransactionId
};
}
public async Task <AuthorizationResponse> IsHouseholdAuthorized(string userId, int occupantId)
{
AuthorizationResponse authorizationResponse = new AuthorizationResponse
{
IsAuthorized = await checkHousehold(userId, occupantId)
};
return(authorizationResponse);
}
//
void it_is_approved_when_any_transaction_is_approved()
{
var response = new AuthorizationResponse();
response.Transactions.Add(new Transaction {
Approved = true
});
response.Approved.ShouldBeTrue();
}
public override async Task AuthorizationCodeFlow_Login_CallbackAsync(HttpContext httpContext)
{
var idp = CreateModelOIDCAuthenticationServer();
Trace.Write("AuthorizationCodeFlow_Login_CallbackAsync");
var context = new SVAuthRequestContext(SVX_Principal, httpContext);
var dummyAuthorizationRequest = new AuthorizationRequest();
//REDACTED's original implementation, without detaching concdst_conckey
/*var authorizationResponse = (OAuth20.AuthorizationResponse)Utils.ObjectFromFormPost(
* context.http.Request.Form,typeof(OAuth20.AuthorizationResponse));
*/
JObject jo = detach_concdst_conckey_formpost(ref context, " ");
AuthorizationResponse authorizationResponse = (AuthorizationResponse)Utils.UnreflectObject(jo, typeof(AuthorizationResponse));;
GetMessageStructures().authorizationResponse.ImportWithModel(authorizationResponse,
() => { idp.FakeCodeEndpoint(dummyAuthorizationRequest, authorizationResponse); },
SVX.Channel.GenerateNew(SVX_Principal), // unknown producer
context.channel);
/*GetMessageStructures().authorizationResponse.Import(authenticationResponse,
* SVX.PrincipalFacet.GenerateNew(SVX_Principal), // unknown producer
* context.client);*/
var _AccessTokenRequest = SVX.SVX_Ops.Call(createAccessTokenRequest, authorizationResponse);
GetMessageStructures().accessTokenRequest.Export(_AccessTokenRequest, idpParticipantId.principal, null);
var rawReq = marshalAccessTokenRequest(_AccessTokenRequest);
var RawAccessTokenResponse = await Utils.PerformHttpRequestAsync(rawReq);
Trace.Write("Got AccessTokenResponse");
JObject jObject = JObject.Parse(RawAccessTokenResponse.Content.ReadAsStringAsync().Result);
TokenResponse tokenResponse = Utils.UnreflectObject <TokenResponse>(jObject);
GetMessageStructures().tokenResponse.ImportDirectResponseWithModel(tokenResponse,
() => { idp.FakeTokenEndpoint(_AccessTokenRequest, tokenResponse); },
idpParticipantId.principal,
SVX_Principal
);
if (!String.IsNullOrEmpty(tokenResponse.id_token.theParams.nonce))
{
HashAlgorithm hashAlgo = SHA1.Create();
string expected_nonce = BitConverter.ToString(hashAlgo.ComputeHash(System.Text.Encoding.UTF8.GetBytes(context.channel.id)));
if (expected_nonce != tokenResponse.id_token.theParams.nonce)
{
throw new Exception("invalid nonce");
}
}
var conclusion = SVX.SVX_Ops.Call(createConclusionOidc, authorizationResponse, tokenResponse);
await AuthenticationDone(conclusion, context);
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
AuthorizationResponse resp = AuthorizationResponse.FromIntent(Intent);
AuthorizationException ex = AuthorizationException.FromIntent(Intent);
AuthService.Instance.AuthActivityCreated(resp, ex);
Finish();
}
/// <summary>
/// Compute the initial value for the login ID field in the
/// authorization page.
/// </summary>
static string ComputeLoginId(AuthorizationResponse response)
{
if (response.Subject != null)
{
return(response.Subject);
}
return(response.LoginHint);
}
public override async Task <bool> InvokeAsync()
{
// Check SignInAs identity for authentication update
if (Context.Authentication.User.Identity.IsAuthenticated)
{
await ValidateSignInAsIdentities();
}
// Check for valid callback URI
var callbackUri = await KeycloakIdentity.GenerateLoginCallbackUriAsync(Options, Request.Uri);
if (!Options.ForceBearerTokenAuth && Request.Uri.GetLeftPart(UriPartial.Path) == callbackUri.ToString())
{
// Create authorization result from query
var authResult = new AuthorizationResponse(Request.Uri.Query);
try
{
// Validate passed state
var stateData = Global.StateCache.ReturnState(authResult.State);
if (stateData == null)
{
throw new BadRequestException("Invalid state: Please reattempt the request");
}
// Parse properties from state data
var properties =
stateData[Constants.CacheTypes.AuthenticationProperties] as AuthenticationProperties ??
new AuthenticationProperties();
// Process response
var kcIdentity =
await KeycloakIdentity.ConvertFromAuthResponseAsync(Options, authResult, Request.Uri);
var identity = await kcIdentity.ToClaimsIdentityAsync();
Context.Authentication.User.AddIdentity(identity);
SignInAsAuthentication(identity, properties, Options.SignInAsAuthenticationType);
// Redirect back to the original secured resource, if any
if (!string.IsNullOrWhiteSpace(properties.RedirectUri) &&
Uri.IsWellFormedUriString(properties.RedirectUri, UriKind.Absolute))
{
Response.Redirect(properties.RedirectUri);
return(true);
}
}
catch (BadRequestException exception)
{
await GenerateErrorResponseAsync(HttpStatusCode.BadRequest, "Bad Request", exception.Message);
return(true);
}
}
return(false);
}
public SettlementRequest FromAuthorizationResponse(AuthorizationResponse response)
{
return(new SettlementRequest
{
AccountNumber = response.AccountNumber,
TransactionId = response.TransactionId,
ProviderTransactionId = response.ProviderTransactionId
});
}
private BackblazeDstInterop(string accountid, string applicationkey,
string bucketid, string bucketname, string connectionsettingsfile = null)
{
AccountID = accountid;
ApplicationKey = applicationkey;
BucketId = bucketid;
BucketName = bucketname;
ConnectionSettingsFile = connectionsettingsfile;
AuthResp = AuthorizeAccount().Result;
}
public void ShouldReturnErrorMessageWhenPassingNullRequest()
{
//Arrange
AuthorizationTransaction authTransaction = new AuthorizationTransaction(null, null, logger, null);
//Act
AuthorizationResponse response = authTransaction.Execute(null);
//Assert
Assert.AreEqual("Ocorreu um erro na chamada da transação de autorização. Verifique o log de erro para mais detalhes", response.ReturnMessage);
}
public RequestAccessTokenMessage(IOwinRequest request, KeycloakAuthenticationOptions options,
AuthorizationResponse authResponse)
: base(request, options)
{
if (authResponse == null)
{
throw new ArgumentNullException();
}
AuthResponse = authResponse;
}
public AuthorizationResponse IsAuthorized(IRequisition entity, string userId)
{
if (entity.Status == RequisitionStatus.None)
{
//TODO: get user dept, role, etc
return(AuthorizationResponse.Authorized());
}
return(AuthorizationResponse.NotAuthorized("Invalid status"));
}
public async Task <AuthorizationResponse> Authorization()
{
var re = Request;
var headers = re.Headers;
if (headers.Contains(Constants.Header_ApplicationId) && headers.Contains(Constants.Header_ApplicationSecret))
{
var applicationId = headers.GetValues(Constants.Header_ApplicationId).First();
var applicationSecret = headers.GetValues(Constants.Header_ApplicationSecret).First();
try
{
//Get token
AuthorizationResponse response =
await _applicationService.GetAccessToken(applicationId, applicationSecret);
if (response == null)
{
throw new HttpResponseException(new HttpResponseMessage
{
StatusCode = HttpStatusCode.Unauthorized,
Content = new StringContent(Constants.HttpResponse_401)
});
}
//Save token in section
var saved = await _applicationService.SaveAccessToken(response.AccessToken, applicationId);
if (!saved)
{
throw new HttpResponseException(new HttpResponseMessage
{
StatusCode = HttpStatusCode.NotAcceptable,
Content = new StringContent(Constants.HttpResponse_406)
});
}
return(response);
}
catch (Exception)
{
throw new HttpResponseException(new HttpResponseMessage
{
StatusCode = HttpStatusCode.InternalServerError,
Content = new StringContent(Constants.HttpResponse_500)
});
}
}
throw new HttpResponseException(new HttpResponseMessage
{
StatusCode = HttpStatusCode.BadRequest,
Content = new StringContent(Constants.HttpResponse_400)
});
}
/// <summary>
/// Gets the authorization token.
/// </summary>
/// <param name="authorizationTokenRequest">The authorization token request.</param>
/// <returns>AuthorizationResponse.</returns>
public static AuthorizationResponse GetAuthorizationToken(AuthorizationTokenRequest authorizationTokenRequest)
{
var audience = authorizationTokenRequest.Audience;
var authenticationBody =
$"username={authorizationTokenRequest.AuthenticationRequestBody.Username}&password={authorizationTokenRequest.AuthenticationRequestBody.Password}&organisationalUnitAlias={authorizationTokenRequest.AuthenticationRequestBody.OrganisationalUnitAlias}";
HttpResponseMessage authenticationResponseMessage = null;
var authenticationUrl = authorizationTokenRequest.AuthenticationUrl;
AuthenticationResponse authenticationResponse = null;
AuthorizationRequest authorizationRequest = null;
HttpResponseMessage authorizationResponseMessage = null;
var authorizationUrl = authorizationTokenRequest.AuthorizationUrl;
var purpose = authorizationTokenRequest.Purpose;
var result = new AuthorizationResponse();
using (HttpContent content = new StringContent(authenticationBody, Encoding.UTF8))
{
content.Headers.Clear();
content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
using (var client = new HttpClient())
{
authenticationResponseMessage = client.PostAsync(authenticationUrl, content).Result;
}
}
if (authenticationResponseMessage.IsSuccessStatusCode)
{
authenticationResponse = JsonConvert.DeserializeObject <AuthenticationResponse>(
authenticationResponseMessage.Content.ReadAsStringAsync().Result);
authorizationRequest = new AuthorizationRequest()
{
SearchTypeCode = purpose,
DataAssetSets = new string[] { audience }
};
using (var content = new StringContent(JsonConvert.SerializeObject(authorizationRequest)))
{
content.Headers.Clear();
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", authenticationResponse.AccessToken);
authorizationResponseMessage = client.PostAsync(authorizationUrl, content).Result;
}
}
result = JsonConvert.DeserializeObject <AuthorizationResponse>(authorizationResponseMessage.Content
.ReadAsStringAsync().Result);
result.AccessToken = string.Format("Bearer {0}", result.AccessToken);
}
return(result);
}
/// <summary>
/// Validates an <see cref="AuthenticationResponse"/>.
/// </summary>
/// <param name="authorizationResponse">The <see cref="AuthenticationResponse"/> pararm.</param>
/// <param name="auth0Domain">The Auth0's tenant domain.</param>
/// <param name="state">The state used during the authentication flow.</param>
public static void ValidateAuthorizationResponse(AuthorizationResponse authorizationResponse, string auth0Domain, string state)
{
if (string.IsNullOrEmpty(auth0Domain))
{
throw new ArgumentException(Resources.NullArgumentExceptionError, nameof(auth0Domain));
}
if (authorizationResponse is null)
{
throw new ArgumentNullException(nameof(authorizationResponse));
}
string errorDescription = null;
Uri origin = new Uri(authorizationResponse.Origin);
// Validate Origin
if (authorizationResponse.IsTrusted && origin.Authority != auth0Domain)
{
errorDescription = "Invalid Origin";
}
// Validate Error
if (errorDescription == null && !string.IsNullOrEmpty(authorizationResponse.Error))
{
switch (authorizationResponse.Error.ToLowerInvariant())
{
case "login_required":
errorDescription = "Login Required";
break;
case "consent_required":
errorDescription = "Consent Required";
break;
default:
errorDescription = authorizationResponse.ErrorDescription;
break;
}
}
// Validate State
if (errorDescription == null && !string.IsNullOrEmpty(state) ? state != authorizationResponse.State.Replace(' ', '+') : false)
{
errorDescription = "Invalid State";
}
if (!string.IsNullOrEmpty(errorDescription))
{
throw new AuthenticationException(errorDescription);
}
}
public void ParseRealWorldGoogleSuccessResponse()
{
string redirectUrl = "com.example.myapp:/oauth2redirect/?state=AJ7CQLlJEwNn2AVL&code=4/aQHgCtVfeTg--SEAyJ6pYHvcCtZZZZZckvGcT5OpPjNuEEEEcvUJzQSaAALzD_DSfenHwHXItOE2Ax55j25-bbY&scope=https://www.googleapis.com/auth/drive.appdata";
AuthorizationResponse response = OAuth2Utils.ParseAuthorizationResponseUrl(redirectUrl);
Assert.IsTrue(response.IsAccessGranted);
Assert.AreEqual("4/aQHgCtVfeTg--SEAyJ6pYHvcCtZZZZZckvGcT5OpPjNuEEEEcvUJzQSaAALzD_DSfenHwHXItOE2Ax55j25-bbY", response.Code);
Assert.IsNull(response.Token);
Assert.AreEqual("AJ7CQLlJEwNn2AVL", response.State);
Assert.IsNull(response.Error);
}
public void ShouldReturnErrorWhenSendAuthorizationTransactionWithNullRequest()
{
//Arrange
AuthorizationRequest authorizationRequestData = null;
CieloTransaction authorizationTransaction = new CieloTransaction(TransactionType.Authorization, credentials);
//Act
AuthorizationResponse authorizationResponse = (AuthorizationResponse)authorizationTransaction.Execute(authorizationRequestData);
//Assert
Assert.AreEqual("Ocorreu um erro na chamada da transação de autorização. Verifique o log de erro para mais detalhes", authorizationResponse.ReturnMessage);
}
public void ParseRealWorldGoogleRejectResponse()
{
string redirectUrl = "com.example.myapp:/oauth2redirect/?error=access_denied&state=AJ7CQLlJEwNn2AVL";
AuthorizationResponse response = OAuth2Utils.ParseAuthorizationResponseUrl(redirectUrl);
Assert.IsFalse(response.IsAccessGranted);
Assert.IsNull(response.Token);
Assert.IsNull(response.Code);
Assert.AreEqual("AJ7CQLlJEwNn2AVL", response.State);
Assert.AreEqual(AuthorizationResponseError.AccessDenied, response.Error);
}
public void ParseRealWorldDropboxSuccessResponse()
{
string redirectUrl = "com.example.myapp://oauth2redirect/#access_token=vQGkdNzLZ9AAAAAAApZW8zLyjRRRRRcic2MqEx1A1AdyaPcLdbKKOLNg2I8z0we-&token_type=bearer&state=68D8kUO0ubb78C8k&uid=111111111&account_id=abcd%3AAADucBH8TWrbYMWUHlrWQ4TGdcyC55pzBKk";
AuthorizationResponse response = OAuth2Utils.ParseAuthorizationResponseUrl(redirectUrl);
Assert.IsTrue(response.IsAccessGranted);
Assert.AreEqual("vQGkdNzLZ9AAAAAAApZW8zLyjRRRRRcic2MqEx1A1AdyaPcLdbKKOLNg2I8z0we-", response.Token);
Assert.IsNull(response.Code);
Assert.AreEqual("68D8kUO0ubb78C8k", response.State);
Assert.IsNull(response.Error);
}
private IActionResult GetAuthorizationResponse(AccessRequestModel model, IUser user, IComputer computer)
{
try
{
// Do authorization check first.
AuthorizationResponse authResponse = this.authorizationService.GetAuthorizationResponse(user, computer, model.RequestType);
if (!authResponse.IsAuthorized())
{
this.AuditAuthZFailure(model, authResponse, user, computer);
model.FailureReason = UIMessages.NotAuthorized;
return(this.View("AccessRequest", model));
}
// Do actual work only if authorized.
if (authResponse.EvaluatedAccess == AccessMask.Laps)
{
return(this.GetLapsPassword(model, user, computer, (LapsAuthorizationResponse)authResponse));
}
else if (authResponse.EvaluatedAccess == AccessMask.LapsHistory)
{
return(this.GetLapsPasswordHistory(model, user, computer, (LapsHistoryAuthorizationResponse)authResponse));
}
else if (authResponse.EvaluatedAccess == AccessMask.Jit)
{
return(this.GrantJitAccess(model, user, computer, (JitAuthorizationResponse)authResponse));
}
else
{
throw new AccessManagerException(@"The evaluated access response mask was not supported");
}
}
catch (AuditLogFailureException ex)
{
this.logger.LogEventError(EventIDs.AuthZFailedAuditError, string.Format(LogMessages.AuthZFailedAuditError, user.MsDsPrincipalName, model.ComputerName), ex);
return(this.View("Error", new ErrorModel
{
Heading = UIMessages.AccessDenied,
Message = UIMessages.AuthZFailedAuditError
}));
}
catch (Exception ex)
{
this.logger.LogEventError(EventIDs.AuthZError, string.Format(LogMessages.AuthZError, user.MsDsPrincipalName, computer.MsDsPrincipalName), ex);
return(this.View("Error", new ErrorModel
{
Heading = UIMessages.UnableToProcessRequest,
Message = UIMessages.AuthZError
}));
}
}
public void Credit(CcDepositRequest depositRequest, AuthorizationResponse response, Action <CcDepositResponse> onFunded)
{
if (depositRequest.Currency == "DEM")
{
throw new ApplicationException("Are you serious? Deposits in Deutsche Mark are not supported since 2002!");
}
Debug.WriteLine(
$"Funding Customer Account. TransactionId={response.TransactionId} AccountNumber={depositRequest.AccountNumber} Amount={depositRequest.Amount} Currency={depositRequest.Currency}");
onFunded(new DepositResponseFactory().FromClearingResponse(depositRequest, response));
}
public void Any_Transaction_Is_Approved()
{
_transactions.Add(_declined);
_transactions.Add(_approved);
var sut = new AuthorizationResponse();
sut.Transactions.AddRange(_transactions);
sut.Approved.ShouldBe(true);
}
public void All_Transactions_Where_Declined()
{
_transactions.Add(_declined);
_transactions.Add(_declined);
var sut = new AuthorizationResponse();
sut.Transactions.AddRange(_transactions);
sut.Approved.ShouldBe(false);
}
private async Task AuthorizeAsync(CancellationToken cancellationToken)
{
if (_authorizationResponse != null) return;
_authorizationResponse = null;
var formContent = new[] {new KeyValuePair<string, string>("grant_type", "client_credentials")};
var response = await _authorizationService.PostFormAsync<AuthorizationResponse>(ApiCalls.AuthorizationPath, formContent, cancellationToken);
_libraryService.SetAuthorizationHeader(response.TokenType, response.AccessToken);
_authorizationResponse = response;
}
public void ShouldReturnResponseObjectWithErrorMessageWhenResponseMessageIsIncomplete()
{
//Arrange
string response = new StreamReader(expectedResultPath + "\\AuthorizationResponseIncomplete.json").ReadToEnd();
AuthorizationTransactionFormatter authFormatter = new AuthorizationTransactionFormatter();
//Act
AuthorizationResponse authResponse = authFormatter.ParseMessageToResponse(response);
//Assert
Assert.AreEqual("Ocorreu um erro ao formatar a mensagem de resposta na API da Cielo. Verifique o log de erro para mais detalhes", authResponse.ReturnMessage);
}
async Task <HttpResponseMessage> HandleNoInteraction(
AuthorizationResponse response)
{
// Make NoInteractionHandler handle the case of
// 'prompt=none'. An implementation of the
// INoInteractionHandlerSpi interface needs to be given
// to the constructor of NoInteractionHandler.
return(await new NoInteractionHandler(
API, new NoInteractionHandlerSpiImpl(this))
.Handle(response));
}
/// <summary>
/// Is Valid OAuth 2.0 Authorization Response.
/// </summary>
public static void Validate(this AuthorizationResponse response, bool isImplicitFlow = false)
{
if (response == null)
{
throw new ArgumentNullException(nameof(response));
}
if (!response.Error.IsNullOrEmpty())
{
throw new ResponseErrorException(response.Error, $"{response.GetTypeName()}{(response.ErrorDescription.IsNullOrEmpty() ? string.Empty : $", {response.ErrorDescription}")}.");
}
private void ServerMessageReceived(NetworkClient senderClient, int messageType, ByteString messageContent)
{
Debug.Log("Server message Type={0} Size={1}.", messageType, messageContent.Length);
switch (messageType) {
/* Handshake request. */
case MessageType.ClientHandshakeRequest: {
HandshakeRequest request = HandshakeRequest.Parser.ParseFrom(messageContent);
senderClient.UpdatePublicKey(request.Key);
PublicKey serverPublic = this.ServerKey;
if (serverPublic == null) {
Debug.Error("Server public key is invalid.");
return;
}
HandshakeResponse response = new HandshakeResponse();
response.Key = serverPublic;
senderClient.SendMessage(MessageType.ClientHandshakeResponse, response);
}
break;
/* Authorization request. */
case MessageType.AuthorizationRequest: {
AuthorizationRequest request = AuthorizationRequest.Parser.ParseFrom(messageContent);
senderClient.Profile.UpdateProfile(request);
AuthorizationResponse response = new AuthorizationResponse();
response.ServerName = this.m_serverConfig.ServerName;
senderClient.SendMessage(MessageType.AuthorizationResponse, response);
Task.Run(() => {
ContactUpdate contactUpdate = new ContactUpdate();
contactUpdate.Add.Add(senderClient.ContactClient);
foreach (NetworkClient connectedClient in this.m_connectedClients) {
if (connectedClient.ClientId == senderClient.ClientId) continue;
Debug.Log("Sending contact update to ClientId={0}.", connectedClient.ClientId);
connectedClient.SendMessage(MessageType.ContactUpdate, contactUpdate);
}
});
}
break;
/* Contact list update. */
case MessageType.ContactUpdateRequest: {
ContactUpdateRequest request = ContactUpdateRequest.Parser.ParseFrom(messageContent);
ContactUpdate contactUpdate = new ContactUpdate();
List<long> clientList = request.Clients.ToList();
foreach (NetworkClient connectedClient in this.m_connectedClients) {
// if (connectedClient.ClientId == senderClient.ClientId) continue;
if (!connectedClient.Profile.Valid) continue;
if (clientList.Contains(connectedClient.ClientId)) {
Debug.Log("Client {0} has got ClientId={1}.", senderClient.ClientId, connectedClient.ClientId);
clientList.Remove(connectedClient.ClientId);
}
else {
Debug.Log("Client {0} requires ClientId={1}.", senderClient.ClientId, connectedClient.ClientId);
contactUpdate.Add.Add(connectedClient.ContactClient);
}
}
Debug.Log("Trash clients count={0}.", clientList.Count);
if (clientList.Count > 0) {
contactUpdate.Remove.Add(clientList);
}
senderClient.SendMessage(MessageType.ContactUpdate, contactUpdate);
}
break;
case MessageType.ContactUpdateChangeRequest: {
ContactUpdateChangeRequest clientRequestedChange = ContactUpdateChangeRequest.Parser.ParseFrom(messageContent);
var senderProfile = senderClient.Profile;
if (senderProfile.Name != clientRequestedChange.Name || senderProfile.Surname != clientRequestedChange.Surname) {
Debug.Log("Updating client data. This is not implemented on the client side. ;)");
}
else if(senderProfile.Status != clientRequestedChange.Online) {
senderProfile.Status = clientRequestedChange.Online;
ContactUpdateStatus statusUpdate = new ContactUpdateStatus();
statusUpdate.Online = clientRequestedChange.Online;
statusUpdate.ClientId = senderClient.ClientId;
foreach (NetworkClient connectedClient in this.m_connectedClients) {
// if (connectedClient.ClientId == senderClient.ClientId) continue;
Debug.Log("Sending status update to ClientId={0}.", connectedClient.ClientId);
connectedClient.SendMessage(MessageType.ContactUpdateStatus, statusUpdate);
}
}
}
break;
/* Client Public Key request. */
case MessageType.MessageClientPublicRequest: {
MessageRequestClientPublic requestMessage = MessageRequestClientPublic.Parser.ParseFrom(messageContent);
PublicKey responseKey = null;
foreach (NetworkClient connectedClient in this.m_connectedClients) {
if (connectedClient.ClientId == requestMessage.ClientId) {
responseKey = connectedClient.ClientPublic;
}
}
if (responseKey != null) {
MessageResponseClientPublic responseMessage = new MessageResponseClientPublic();
responseMessage.ClientId = requestMessage.ClientId;
responseMessage.Key = responseKey;
senderClient.SendMessage(MessageType.MessageClientPublicResponse, responseMessage);
}
else
Debug.Warn("ClientId={0} has invalid public key.");
}
break;
}
}
/*
* Get your client_id when registering your app at dev.oyatel.com
* */
public Authorize(String client_id, String redirect_uri, AuthorizationResponse callback)
{
this.client_id = client_id;
this.redirect_uri = redirect_uri;
authorized = callback;
}
