public async Task Can_Auto_reconnect_with_BasicAuth_after_expired_token_Async()
{
var authClient = GetClientWithUserPassword(alwaysSend: true);
var called = 0;
var client = new JsonServiceClient(ListeningOn)
{
BearerToken = CreateExpiredToken(),
};
client.OnAuthenticationRequired = () =>
{
called++;
client.BearerToken = authClient.Send(new Authenticate()).BearerToken;
};
var request = new Secured {
Name = "test"
};
var response = await client.SendAsync(request);
Assert.That(response.Result, Is.EqualTo(request.Name));
response = await client.SendAsync(request);
Assert.That(response.Result, Is.EqualTo(request.Name));
Assert.That(called, Is.EqualTo(1));
}
public static bool Crawl(string uri, int amountPages)
{
var isSuccess = true;
var client = new JsonServiceClient(ClientConect);
var previosPages = 0;
client.SendAsync(new CravlByUri {
Uri = uri, DeapValue = amountPages
});
System.Threading.Thread.Sleep(5000);
while (true)
{
var currentPagesCompleted = client.Send(new CrawlCompletedPages {
});
if (currentPagesCompleted >= amountPages)
{
break;
}
if (previosPages == currentPagesCompleted)
{
isSuccess = false;
break;
}
System.Threading.Thread.Sleep(5000);
previosPages = currentPagesCompleted;
}
return(isSuccess);
//client.SendOneWay(new CravlByUri { Uri = uri, DeapValue = 100});
}
public static void Main(string[] args)
{
int amount = -1;
var client = new JsonServiceClient("http://localhost:64132") {UserName="******", Password= "******"};
client.Send<AssignRolesResponse>(new AssignRoles {
UserName = "******",
Roles = new ArrayOfString("User"),
Permissions = new ArrayOfString("GetStatus") }
//after constructor initialization, set up UserName and Password authentication
//Soap11ServiceClient
//Soap12ServiceClient
//Different clients are availble not only JsonServiceClient
while (amount != 0)
{
//Call the service and add an entry
Console.WriteLine("Enter protein amount (0 to exit):");
amount = int.Parse(Console.ReadLine());
//no need to specify the return type here, as the Entry class implements "IReturn" response, and specifies what type gets returned
//old code //var response = client.Send(new Entry // Send works with any method that is available on the server that accepts calls
//{
// Amount = amount,
// Time = DateTime.Now
//});
//Async call
client.SendAsync(new Entry // Send works with any method that is available on the server that accepts calls
{
Amount = amount,
Time = DateTime.Now
}, entryResponse => Console.WriteLine("Response " + response.Id) // on success
,(entryResponse, exception) => Console.WriteLine("error"));
//Service Stack will serialize and desiralize on its own
}
//type of response accepted
//ServiceStack doesn't even need the url anymore, it will figure that out from the Route
//older code client.Post("status", new StatusQuery{..});
StatusResponse statusResponse = null;
try
{
statusResponse = client.Post(new StatusQuery //url is needed for POST: http://localhost:64132/status
{
Date = DateTime.Now
});
}
catch(WebServiceException exception)
{
Console.WriteLine(exception.ErrorMessage);
Console.ReadLine();
return;
}
Console.WriteLine("{0} / {1}", statusResponse.Total, statusResponse.Goal);
Console.WriteLine(statusResponse.Message);
Console.ReadLine();
}
static void Main(string[] args)
{
var client = new JsonServiceClient("http://localhost:53353"){UserName = "******", Password = "******"};
client.SendAsync(new AwardRequest(),
r => Console.WriteLine("Response: " + r.IsSuccess),
(r, ex) => Console.WriteLine(ex.Message));
Console.ReadLine();
}
void HandleClicked(object sender, EventArgs e)
{
var name = NameField.Text;
var client = new JsonServiceClient("http://127.0.0.1:8080/servicestack");
client.SendAsync<HelloResponse>(
new Hello { Name = name },
(response) => Append(response.Result),
(response, error) => Append("ERROR: " + error.Message)
);
}
public async Task Can_call_SendAsync_on_ServiceClient()
{
var jsonClient = new JsonServiceClient(ListeningOn);
var request = new GetFactorial { ForNumber = 3 };
var response = await jsonClient.SendAsync<GetFactorialResponse>(request);
Assert.That(response, Is.Not.Null, "No response received");
Assert.That(response.Result, Is.EqualTo(GetFactorialService.GetFactorial(request.ForNumber)));
}
void HandleClicked(object sender, EventArgs e)
{
var name = NameField.Text;
var client = new JsonServiceClient(ServiceAddressField.Text);
client.SendAsync<HelloResponse>(
new Hello { Name = name },
(response) => Append(response.Result),
(response, error) => Append("ERROR: " + error.Message)
);
NameField.ResignFirstResponder();
}
public async Task Can_send_single_HelloAllAsync_request()
{
var client = new JsonServiceClient(Config.AbsoluteBaseUri);
var request = new HelloAllAsync {
Name = "Foo"
};
var response = await client.SendAsync(request);
Assert.That(response.Result, Is.EqualTo("Hello, Foo!"));
}
public async Task Can_call_SendAsync_on_ServiceClient()
{
var jsonClient = new JsonServiceClient(ListeningOn);
var request = new GetFactorial {
ForNumber = 3
};
var response = await jsonClient.SendAsync <GetFactorialResponse>(request);
Assert.That(response, Is.Not.Null, "No response received");
Assert.That(response.Result, Is.EqualTo(GetFactorialService.GetFactorial(request.ForNumber)));
}
public async Task Does_send_version_using_JsonServiceClient()
{
var client = new JsonServiceClient(Config.AbsoluteBaseUri);
var response = client.Send(new RequestWithVersion {
Version = 1
});
Assert.That(response.Version, Is.EqualTo(1));
response = await client.SendAsync(new RequestWithVersion { Version = 1 });
Assert.That(response.Version, Is.EqualTo(1));
client.Version = 1;
response = client.Send(new RequestWithVersion());
Assert.That(response.Version, Is.EqualTo(1));
response = await client.SendAsync(new RequestWithVersion());
Assert.That(response.Version, Is.EqualTo(1));
}
public static void ExtractEntities()
{
var client = new JsonServiceClient(ClientConect);
client.SendAsync(new ExtractEntities {
});
System.Threading.Thread.Sleep(5000);
while (!client.Send(new IsExtractEntitiesCompleted {
}))
{
System.Threading.Thread.Sleep(5000);
}
}
void HandleClicked(object sender, EventArgs e)
{
var name = NameField.Text;
var client = new JsonServiceClient("http://127.0.0.1:8080/servicestack");
client.SendAsync <HelloResponse>(
new Hello {
Name = name
},
(response) => Append(response.Result),
(response, error) => Append("ERROR: " + error.Message)
);
}
void HandleClicked(object sender, EventArgs e)
{
var name = NameField.Text;
var client = new JsonServiceClient(ServiceAddressField.Text);
client.SendAsync <HelloResponse>(
new Hello {
Name = name
},
(response) => Append(response.Result),
(response, error) => Append("ERROR: " + error.Message)
);
NameField.ResignFirstResponder();
}
public async Task Does_allow_sending_Cached_Response_Async()
{
var cache = new Dictionary <string, object>();
client.ResultsFilter = (type, method, uri, request) =>
{
var cacheKey = "{0} {1}".Fmt(method, uri);
object entry;
cache.TryGetValue(cacheKey, out entry);
return(entry);
};
client.ResultsFilterResponse = (webRes, res, method, uri, request) =>
{
Assert.That(webRes, Is.Not.Null);
var cacheKey = "{0} {1}".Fmt(method, uri);
cache[cacheKey] = res;
};
var response1 = await client.SendAsync(new GetCustomer { CustomerId = 5 });
var response2 = await client.SendAsync(new GetCustomer { CustomerId = 5 });
Assert.That(response1.Created, Is.EqualTo(response2.Created));
}
public void Can_call_SendAsync_on_ServiceClient()
{
var jsonClient = new JsonServiceClient(ListeningOn);
var request = new GetFactorial {
ForNumber = 3
};
GetFactorialResponse response = null;
jsonClient.SendAsync <GetFactorialResponse>(request, r => response = r, FailOnAsyncError);
Thread.Sleep(1000);
Assert.That(response, Is.Not.Null, "No response received");
Assert.That(response.Result, Is.EqualTo(GetFactorialService.GetFactorial(request.ForNumber)));
}
static void Main(string[] args)
{
var client = new JsonServiceClient("http://localhost:51283")
{
UserName = "******", Password = "******"
};
client.Send(new AssignRoles {
UserName = "******", Roles = new ArrayOfString("Customer"), Permissions = new ArrayOfString("GetCafe")
});
var provider = CultureInfo.InvariantCulture;
var format = "MMM HH':'mm':'yyyy";
int zipCode = 0;
while (zipCode == 0)
{
Console.WriteLine("Enter the name of the cafe:");
var name = Console.ReadLine();
Console.WriteLine("Enter the address of the cafe:");
var address = Console.ReadLine();
Console.WriteLine("Enter the city of the cafe:");
var city = Console.ReadLine();
Console.WriteLine("Enter the Open Time of the cafe of the cafe | Format: MMM HH:mm:yyyy");
var openTime = Console.ReadLine();
var fixedOpenTime = DateTime.ParseExact(openTime, format, provider);
Console.WriteLine("Enter the price range of the cafe:");
var priceRange = Console.ReadLine();
Console.WriteLine("Enter the rating of the cafe:");
var rating = Console.ReadLine();
Console.WriteLine("Enter the type of the cafe:");
var type = Console.ReadLine();
Console.WriteLine("Enter the ZipCode of the city:");
var newZip = Console.ReadLine();
var parsedZip = Int32.Parse(newZip);
client.SendAsync(new Cafe {
Name = name, Address = address, City = city, OpenTime = fixedOpenTime, CloseTime = fixedOpenTime.AddHours(10), PriceRange = Decimal.Parse(priceRange), Rating = Decimal.Parse(rating), Type = type, ZipCode = parsedZip
},
cafeRespone => Console.WriteLine($"Response: {cafeRespone.ToString()} | Message: {cafeRespone.Message}"),
(cafeResonse, exception) => Console.WriteLine(exception.Message));
zipCode = parsedZip;
Console.ReadKey();
}
}
public IObservable <TResponse> ObserveMany <TResponse>(IReturn <IEnumerable <TResponse> > request)
{
return(Observable.Create <TResponse>(observer =>
{
var client = new JsonServiceClient(_baseUri);
var disposable = new MutableDisposable // rx 1.0.2856
//var disposable = new MultipleAssignmentDisposable // rx 2+
{
Disposable = Disposable.Create(client.CancelAsync)
};
client.SendAsync <HttpWebResponse>(
request,
onSuccess: response =>
{
var responseStream = response.GetResponseStream();
disposable.Disposable = responseStream.DeserializeMany <TResponse>().Subscribe(observer);
},
onError: (response, exception) => observer.OnError(exception));
return disposable.Dispose;
}));
}
async Task ConcreteAsyncApiUsage(JsonServiceClient client)
{
UsageNone none = await client.SendAsync <UsageNone>(new UsageNone());
UsageNone noneToken = await client.SendAsync <UsageNone>(new UsageNone(), CancellationToken.None);
UsageReturn @return = await client.SendAsync(new UsageReturn());
UsageReturn returnToken = await client.SendAsync(new UsageReturn(), CancellationToken.None);
await client.SendAsync(new UsageVoid());
await client.SendAsync(new UsageVoid(), CancellationToken.None);
List <UsageReturn> returnAll = await client.SendAllAsync(new[] { new UsageReturn() });
List <UsageReturn> returnAllToken = await client.SendAllAsync(new[] { new UsageReturn() }, CancellationToken.None);
await client.PublishAsync(new UsageNone());
await client.PublishAsync(new UsageNone(), CancellationToken.None);
await client.PublishAsync(new UsageReturn());
await client.PublishAsync(new UsageReturn(), CancellationToken.None);
await client.PublishAsync(new UsageVoid());
await client.PublishAsync(new UsageVoid(), CancellationToken.None);
await client.PublishAllAsync(new[] { new UsageNone() });
await client.PublishAllAsync(new[] { new UsageNone() }, CancellationToken.None);
await client.PublishAllAsync(new[] { new UsageReturn() });
await client.PublishAllAsync(new[] { new UsageReturn() }, CancellationToken.None);
await client.PublishAllAsync(new[] { new UsageVoid() });
await client.PublishAllAsync(new[] { new UsageVoid() }, CancellationToken.None);
}
