public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <SendDnsInformationResult, ISendGeneratedDnsInformationCommand,
SendGeneratedDnsInformationCommand>(this,
context => context.SendGeneratedDnsInformation(this)));
}
/// <summary>
///
/// </summary>
/// <param name="longpolling">Set true for event notification, false for immediate response.</param>
/// <returns></returns>
public Task <Event> GetEventAsync(bool longpolling, ApiVersion version = ApiVersion.V1_0
, CancellationTokenSource cancel = null)
{
return(Single(
RequestGenerator.Jsonize("getEvent", version, longpolling),
CustomParser.AsCameraEvent, cancel));
}
public async Task <StreamingStatus> RequestToNotifyStreamingStatusAsync(LongPollingFlag flag
, CancellationTokenSource cancel = null)
{
return(await Single(
RequestGenerator.Serialize("requestToNotifyStreamingStatus", ApiVersion.V1_0, flag),
BasicParser.AsObject <StreamingStatus>, cancel).ConfigureAwait(false));
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <List <WhiteListedIpAddress>, IAddWhiteListedIpAddressCommand, AddWhiteListedIpAddressCommand>(
this,
context => context.AddWhiteListedIpAddress(this)));
}
void Start()
{
DataManager.SendDataRequest();
StartUp startUp = new StartUp();
VersionProto version = new VersionProto();
version.MajorNumber = 1;
version.MinorNumber = 0;
version.PatchNumber = 0;
startUp.Version = version;
startUp.Platform = "ANDROID";
startUp.Udid = SystemInfo.deviceUniqueIdentifier;
string fb_id = PlayerPrefs.GetString(GameConstants.PlayerPrefKeys.FB_ID);
startUp.StaticDataHash = Guid.NewGuid().ToString();
if (!string.IsNullOrEmpty(fb_id))
{
startUp.Fbid = fb_id;
}
else
{
startUp.Fbid = "";
}
Request request = RequestGenerator.CreateRequest(RequestType.Startup, startUp.ToByteString());
NetworkManager.Instance.SendRequest(request, HandleStartupResponse);
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <TeammateInviteResult, IResendTeammateInviteCommand, ResendTeammateInviteCommand>(
this,
context => context.ResendTeammateInviteByToken(Token)));
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <string, IRemoveWhiteListedIpAddressCommand, RemoveWhiteListedIpAddressCommand>(
this,
context => context.RemoveWhiteListedIpAddress(this)));
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <UserEmailAddress, IUserEmailAddressSingleQuery, UserEmailAddressSingleQuery>(
this,
context => context.UserEmailAddress()));
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <string, IResendVerificationSenderIdentityCommand, ResendVerificationSenderIdentityCommand>(
this,
context => context.ResendVerificationSenderIdentityById(Id)));
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <WebhookParseStatistics, IWebhookParseStatisticsListQuery, WebhookParseStatisticsListQuery>(
this,
context => context.WebhookParseStatistics(this)));
}
public void ShouldInsertVideo()
{
var repository = _fixture.Create <MovieRepository>();
var request = RequestGenerator.GetMovieRequest(134132);
var videoEntered = repository.UpsertMovie(request);
videoEntered.Count().Should().Be(1);
videoEntered.All(a => a.imdb_id == "tt134132").Should().BeTrue();
var command = @"SELECT COUNT(*)
FROM video.vw_movies
WHERE imdb_id = 'tt134132'";
using var sqlConnection = new SqlConnection(_config.CreateConnectionString());
using var sqlCommand = new SqlCommand(command, sqlConnection);
sqlCommand.Connection.Open();
var reader = sqlCommand.ExecuteReader();
reader.Read();
var rowCount = reader.GetInt32(0);
sqlCommand.Connection.Close();
rowCount.Should().Be(1);
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <AuthenticatedDomainSetting, IUpdateAuthenticatedDomainSettingCommand,
UpdateAuthenticatedDomainSettingCommand>(this,
context => context.UpdateAuthenticatedDomainSetting(this)));
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <IpAccessManagementSettingActivity, IIpAccessManagementSettingActivityListQuery,
IpAccessManagementSettingActivityListQuery>(this,
context => context.IpAccessManagementSettingActivities(this)));
}
public async Task <List <Beer_PunkModel> > Search(string keyword)
{
string url = string.Format("{0}/{1}{2}", this._configs.punkapiBaseUrl.Trim('/'), "beers?beer_name=", keyword);
List <Beer_PunkModel> result = new List <Beer_PunkModel>();
var request = new RequestGenerator(_clientFactory);
var response = await request.Get(url);
switch (response.StatusCode)
{
case System.Net.HttpStatusCode.OK:
string jsonString = await response.Content.ReadAsStringAsync();
result = JsonSerializer.Deserialize <List <Beer_PunkModel> >(jsonString);
break;
case System.Net.HttpStatusCode.NotFound:
result = null;
break;
default:
result = null;
throw new System.Exception("Unknow Error in punk api.");
}
return(result);
}
internal static void StartReceiveWorker(BlockingCollection <ISerializedReceiveInfo> receives, ConcurrentQueue <RequestGenerator> workItems, Communicator comm)
{
Thread worker = new Thread(new ThreadStart(() =>
{
using (EventWaitHandle waitHandle = new AutoResetEvent(false))
{
bool done = false;
int source = default(int);
int tag = default(int);
Func <byte[], int> readAction = delegate(byte[] bytes)
{
if (done)
{
return(0);
}
int length = 0;
Action <int> setLength = value => { length = value; };
var workItem = new RequestGenerator(waitHandle, $"Receive length from {source}", () =>
comm.ImmediateReceive(source, tag, setLength)
);
workItems.Enqueue(workItem);
waitHandle.WaitOne();
if (length < comm.Serialization.BufferSize)
{
done = true;
}
if (length == 0)
{
return(0);
}
var workItem2 = new RequestGenerator(waitHandle, $"Receive {length} bytes from {source}", () =>
comm.ImmediateReceive(source, tag, bytes)
);
workItems.Enqueue(workItem2);
waitHandle.WaitOne();
return(length);
};
using (var stream = new BufferedStream(new ActionStream(readAction, null), comm.Serialization.BufferSize))
{
while (true)
{
var info = receives.Take();
if (info == null)
{
break;
}
done = false;
source = info.Source;
tag = info.Tag;
info.Deserialize(comm.Serialization.Serializer, stream);
info.Completed();
}
}
}
}));
worker.IsBackground = true;
worker.Start();
comm.Serialization.ReceiveWorkerCount++;
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <AuthenticatedDomainValidation, IValidateAuthenticatedDomainCommand,
ValidateAuthenticatedDomainCommand>(this,
context => context.ValidateAuthenticatedDomainById(Id)));
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <SpamForwardingSetting, ISpamForwardingSettingSingleQuery, SpamForwardingSettingSingleQuery>(
this,
context => context.SpamForwardingSetting()));
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <PendingTeammateInvitation, IPendingTeammateInvitationListQuery,
PendingTeammateInvitationListQuery>(this,
context => context.PendingTeammateInvitations()));
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <string, IAssociateBrandedForSubUserCommand, AssociateBrandedForSubUserCommand>(
this,
context => context.AssociateBrandedForSubUser(this)));
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <AuthenticatedDomain, IRemoveIpAddressFromAuthenticatedDomainCommand,
RemoveIpAddressFromAuthenticatedDomainCommand>(this,
context => context.RemoveIpAddressFromAuthenticatedDomain(this)));
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <BounceForwardSetting, IUpdateBounceForwardSettingCommand, UpdateBounceForwardSettingCommand>(
this,
context => context.UpdateBounceForwardSetting(this)));
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <AuthenticatedDomain, IAuthenticatedDomainListForSubuserQuery,
AuthenticatedDomainListForSubuserQuery>(this,
context => context.AuthenticatedDomainsForSubUser(this)));
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <EmailAddressWhiteListSetting, IEmailAddressWhiteListSettingSingleQuery,
EmailAddressWhiteListSettingSingleQuery>(this,
context => context.EmailAddressWhiteListSetting()));
}
public void GivenAVideoAlreadyExistsInTheRecord(string typeOfContent)
{
object request;
switch (typeOfContent.ToUpperInvariant())
{
case "MOVIE":
request = RequestGenerator.GetMovieRequest();
(request as MovieRequest).Plot = "Original Plot";
Database.AddRequestItem(request as MovieRequest, _container.Resolve <IConfiguration>());
(request as MovieRequest).Plot = "New Plot";
break;
case "TV EPISODE":
request = RequestGenerator.GetTvEpisodeRequest();
(request as TvEpisodeRequest).EpisodePlot = "Original Plot";
Database.AddRequestItem(request as TvEpisodeRequest, _container.Resolve <IConfiguration>());
(request as TvEpisodeRequest).EpisodePlot = "New Plot";
break;
default:
throw new Exception($"{typeOfContent} is not currently supported.");
}
;
_container.RegisterInstanceAs(request, name: "RequestBody");
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <AssignedIpAddress, IAssignedIpAddressListQuery, AssignedIpAddressListQuery>(
this,
context => context.AssignedIpAddresses()));
}
public void GivenAUserThatWantsToSeeWhatMoviesAlreadyExist(string typeOfContent)
{
object request;
var config = _container.Resolve <IConfiguration>();
switch (typeOfContent.ToUpperInvariant())
{
case "MOVIE":
foreach (var videoId in Enumerable.Range(1000000, 10))
{
request = RequestGenerator.GetMovieRequest(videoId);
Database.AddRequestItem(request as MovieRequest, config);
}
break;
case "SHOW":
case "TV EPISODE":
foreach (var tvId in Enumerable.Range(10000000, 10))
{
request = RequestGenerator.GetTvEpisodeRequest(1000000, tvId);
Database.AddRequestItem(request as TvEpisodeRequest, config);
}
break;
default:
throw new Exception($"{typeOfContent} is not currently supported.");
}
;
}
public void ShouldRetrieveAllEpisodesInDatastore()
{
foreach (var id in Enumerable.Range(1, 10))
{
var request = RequestGenerator.GetTvEpisodeRequest(100, id);
Database.AddRequestItem(request, _config);
}
var repository = _fixture.Create <TvEpisodeRepository>();
var(tvShows, tvEpisodes) = repository.GetTvEpisodes();
tvEpisodes
.Select(s => s.imdb_id)
.Distinct()
.Should()
.HaveCount(10)
.And
.BeEquivalentTo(new[]
{
"tt1", "tt2", "tt3", "tt4", "tt5", "tt6", "tt7", "tt8", "tt9", "tt10"
});
tvShows
.Select(s => s.imdb_id)
.Distinct()
.Should()
.HaveCount(1)
.And
.BeEquivalentTo(new[]
{
"tt100"
});
}
internal static void StartSendWorker(BlockingCollection <ISerializedSendInfo> sends, ConcurrentQueue <RequestGenerator> workItems, Communicator comm)
{
Thread worker = new Thread(new ThreadStart(() =>
{
using (EventWaitHandle waitHandle = new AutoResetEvent(false))
{
bool done = false;
int dest = default(int);
int tag = default(int);
Action flushAction = delegate()
{
if (!done)
{
var workItem = new RequestGenerator(waitHandle, $"Send to {dest}", () =>
comm.ImmediateSend(0, dest, tag)
);
workItems.Enqueue(workItem);
comm.Serialization.SendLogger?.Invoke(4, dest);
waitHandle.WaitOne();
done = true;
}
};
Action <byte[]> writeAction = delegate(byte[] bytes)
{
if (bytes.Length < comm.Serialization.BufferSize)
{
done = true; // the receiver knows that this is the last block.
}
var workItem = new RequestGenerator(waitHandle, $"Serialized send to {dest}", () =>
{
return(new SerializedSendRequest(comm, dest, tag, bytes, bytes.Length, bytes.Length));
});
workItems.Enqueue(workItem);
comm.Serialization.SendLogger?.Invoke(bytes.Length, dest);
waitHandle.WaitOne();
};
using (var stream = new BufferedStream(new ActionStream(null, writeAction, flushAction), comm.Serialization.BufferSize))
{
while (true)
{
var info = sends.Take();
if (info == null)
{
break;
}
done = false;
dest = info.Destination;
tag = info.Tag;
info.Serialize(comm.Serialization.Serializer, stream);
stream.Flush();
info.Completed();
}
}
}
}));
worker.IsBackground = true;
worker.Start();
comm.Serialization.SendWorkerCount++;
}
public Processing_Failed_At_Bank(TestFixture fixture) : base(fixture)
{
_request = RequestGenerator.Generate();
_request.MerchantId = "FailMerchant";
_httpResponseMessage = HttpClient.PostAsJsonAsync("/payments", _request).Result;
_processPaymentResponse = DeserializeJson <ProcessPaymentResponse>(_httpResponseMessage.Content.ReadAsStringAsync().Result);
}
public Task <IResult <HttpRequestMessage> > GenerateRequest()
{
return(RequestGenerator
.Process <UserEmailAddress, IUpdateUserEmailAddressCommand, UpdateUserEmailAddressCommand>(
this,
context => context.UpdateUserEmailAddress(this)));
}
