/// <summary>
/// Gets all attributes for the entity with the specified id
/// </summary>
/// <returns>The response object</returns>
public async Task <ContextResponse> GetAttributesForEntityAsync(string entityId)
{
RESTClient <ContextResponse> client = new RESTClient <ContextResponse>(OrionConfig.AuthHeaderKey, _config.Token);
string uri = string.Format(OrionConfig.ConvenienceUrlFormatOneParam, _config.BaseUrl, _config.Version1Path, OrionConfig.ContextEntitiesPath, entityId, OrionConfig.AttributesPath);
return(await client.GetAsync(uri));
}
/// <summary>
/// Deletes the value of the specified attribute and entity id
/// </summary>
/// <returns>The response object</returns>
public async Task <StatusCode> DeleteAttributeForEntityAsync(string entityId, string attributeName)
{
RESTClient <StatusCode> client = new RESTClient <StatusCode>(OrionConfig.AuthHeaderKey, _config.Token);
string uri = string.Format(OrionConfig.ConvenienceUrlFormatTwoParams, _config.BaseUrl, _config.Version1Path, OrionConfig.ContextEntitiesPath, entityId, OrionConfig.AttributesPath, attributeName);
return(await client.DeleteAsync(uri));
}
/// <summary>
/// Deletes the entity with the specified id
/// </summary>
/// <returns>The response object</returns>
public async Task <ContextResponse> DeleteEntityAsync(string entityId)
{
RESTClient <ContextResponse> client = new RESTClient <ContextResponse>(OrionConfig.AuthHeaderKey, _config.Token);
string uri = string.Format(OrionConfig.ConvenienceUrlFormat, _config.BaseUrl, _config.Version1Path, OrionConfig.ContextEntitiesPath, entityId);
return(await client.DeleteAsync(uri));
}
/// <summary>
/// Gets all types currently in the Orion Context Broker
/// </summary>
/// <returns>The response object</returns>
public async Task <ContextAttributesResponse> GetAttributesForTypeAsync(string type)
{
RESTClient <ContextAttributesResponse> client = new RESTClient <ContextAttributesResponse>(OrionConfig.AuthHeaderKey, _config.Token);
string uri = string.Format(OrionConfig.ConvenienceUrlFormat, _config.BaseUrl, _config.Version1Path, OrionConfig.ContextTypesPath, type);
return(await client.GetAsync(uri));
}
// private class FactAttribute : Attribute { } // Comment out this line to run this test
async public Task <GTXClient> InitTest()
{
var rest = new RESTClient("http://localhost:7740/");
await rest.InitializeBRIDFromChainID(0);
return(new GTXClient(rest));
}
/// <summary>
/// Gets the current version of the Orion Context Broker
/// </summary>
/// <returns>The version object</returns>
public async Task <OrionVersion> GetOrionVersionAsync()
{
RESTClient <OrionVersion> client = new RESTClient <OrionVersion>(OrionConfig.AuthHeaderKey, _config.Token);
string uri = string.Format(OrionConfig.VersionUrlFormat, _config.BaseUrl, OrionConfig.VersionPath);
return(await client.GetAsync(uri));
}
static void Main(string[] args)
{
if (args.Length > 0)
{
RESTClient rESTClient;
rESTClient = new RESTClient(args[0]);
string file1;
file1 = rESTClient.GetFileName(1);
string file2;
file2 = rESTClient.GetFileName(2);
string ffile1;
ffile1 = file1;
int val1;
val1 = rESTClient.HandleFile(ffile1);
string ffile2;
ffile2 = file2;
int val2;
val2 = rESTClient.HandleFile(ffile2);
int vval1, vval2;
vval1 = val1;
vval2 = val2;
Debug.Assert(rESTClient.count == vval1 + vval2);
}
}
public async Task GetAll_ReturnsNull_WhenNotValid()
{
var client = new RESTClient("https://jsonplaceholder.typicode.com");
var posts = await client.GetAll <BlogPost>("invalid_posts");
Assert.Null(posts);
}
public APIOutput ProblemStatus(bool ignoreCertificate = false)
{
// Creating Variables
RESTClient APIClient = new RESTClient(Target);
APIOutput outputValue = new APIOutput();
Dictionary <string, string> parameters = new Dictionary <string, string>
{
// Adding Parameters
{ "Api-Token", Token }
};
// API Call
string APIResponse = APIClient.GetRequest("/problem/status", URLParameters: parameters, IgnoreCertificate: ignoreCertificate);
outputValue.RawData = APIResponse;
// Processing Response
if (APIResponse == "Certificate Error")
{
outputValue.APIStatus = APIResult.CertificateError;
}
else
{
outputValue.APIStatus = APIResult.Success;
outputValue.OutputClass = JsonConvert.DeserializeObject <ProblemData.ProblemStatus.Root_Problemstatus>(APIResponse);
}
return(outputValue);
}
public async Task <ActionResult> UpdateInformacoesParaPagamento(InformacoesParaPagamentoInputModel model)
{
if (ModelState.IsValid)
{
Session["UpdateInformacoesParaPagamento"] = model;
try
{
var Id = (int)Session["UpdateId"];
var candidatoDTO = new CandidatoDTO(
(InformacoesDeContatoInputModel)Session["UpdateInformacoesDeContato"],
(PreferenciasDeTrabalhoInputModel)Session["UpdatePreferenciasDeTrabalho"],
(QuestionarioDeHabilidadesInputModel)Session["UpdateQuestionarioDeHabilidades"],
(InformacoesParaPagamentoInputModel)Session["UpdateInformacoesParaPagamento"]
);
RESTClient client = new RESTClient(baseUrl);
await client.PutJson <string>($"api/Candidato/{Id}", candidatoDTO);
ClearUpdateCandidatoSession();
return(View("UpdateConcluido", Id));
}
catch
{
return(View(model));
}
}
else
{
return(View(model));
}
}
public APIException createException(RESTClient client)
{
APIException resultException = null;
ExceptionDescription exceptionDesc = null;
try
{
var responseInJSON = JObject.Parse(client.RawResponse);
var status = responseInJSON.Value <string>(DefaultAPIResponseValidator.FIELD_STATUS);
if (status != null && status == DefaultAPIResponseValidator.STATUS_ERROR)
{
var result = responseInJSON.Value <JObject>(APIMethod.FIELD_RESULT);
if (result != null)
{
exceptionDesc = result.ToObject <ExceptionDescription>();
resultException = createException(exceptionDesc.Exception, client, exceptionDesc.ErrorMessage, exceptionDesc.Name);
}
}
if (resultException == null)
{
resultException = new APIException(client, (exceptionDesc != null ? exceptionDesc.ErrorMessage : ""));
}
}
catch (Newtonsoft.Json.JsonReaderException)
{
resultException = new APIException(client, "Invalid json with error description");
}
return(resultException);
}
public string SendSmsVerificationCode(string phone)
{
string apiPath = $"utils/phone/sms/{phone}/4";
string result = new RESTClient().PostRequest(_baseApiUrl + apiPath);
return(JsonConvert.DeserializeObject <SmsVerificationCode>(result).Code);
}
private async void UpdateClick(object sender, EventArgs e)
{
if (ValidateData())
{
user.username = etUsername.Text.ToString().Trim();
user.password = etPassword.Text.ToString().Trim();
user.phoneno = etPhone.Text.ToString().Trim();
user.gender = spnGender.SelectedItem.ToString();
progress.SetMessage("Updating Account.....");
RunOnUiThread(() =>
{
progress.Show();
});
await RESTClient.UpdateMemberAsync(this, user);
GetSharedPreferences(GetString(Resource.String.PreferenceFileName), FileCreationMode.Private)
.Edit()
.PutString(GetString(Resource.String.PreferenceSavedMember), JsonConvert.SerializeObject(user))
.Commit();
RunOnUiThread(() =>
{
progress.Dismiss();
});
}
}
private void DeletedSignUp(SignUpInfo signUpInfo)
{
SignUpControl oneSignUpItem = null;
for (int loop = 0; loop < signUpList.Children.Count; loop++)
{
if (signUpList.Children[loop].GetType().ToString() == "SignInApp.SignUpControl")
{
oneSignUpItem = signUpList.Children[loop] as SignUpControl;
if (oneSignUpItem.mSignUpInfo.Id == signUpInfo.Id)
{
//删除
string outMessage = "";
string response = RESTClient.SignOut(signUpInfo.Id, ref outMessage);
if (response == null || response == "")
{
if (outMessage == "")
{
outMessage = "删除签到失败，服务器错误";
}
broder_back.Visibility = Visibility.Collapsed;
_loading.Visibility = Visibility.Collapsed;
WarningTipWindow tipDialog = new WarningTipWindow(outMessage);
tipDialog.ShowDialog();
return;
}
try
{
JObject jResp = (JObject)JsonConvert.DeserializeObject(response);
String status = (String)jResp.SelectToken("status", true);
if (status != "success")
{
string message = (String)jResp.SelectToken("message", true);
broder_back.Visibility = Visibility.Collapsed;
_loading.Visibility = Visibility.Collapsed;
WarningTipWindow tipDialog = new WarningTipWindow("删除签到失败:" + message);
tipDialog.ShowDialog();
LogHelper.WriteWarnLog("删除签到失败:" + message);
return;
}
LogHelper.WriteInfoLog("查询签到成功");
broder_back.Visibility = Visibility.Collapsed;
_loading.Visibility = Visibility.Collapsed;
signUpList.Children.RemoveAt(loop);
return;
}
catch (Exception err)
{
broder_back.Visibility = Visibility.Collapsed;
_loading.Visibility = Visibility.Collapsed;
WarningTipWindow tipDialog = new WarningTipWindow("查询签到失败，" + err.Message);
tipDialog.ShowDialog();
return;
}
}
}
}
}
private void ExitSystemClickHandler(object sender, RoutedEventArgs e)
{
string outMessage = "";
RESTClient.Logout(ref outMessage);
this.Close();
}
public void Execute(IJobExecutionContext context)
{
var name = context.JobDetail.JobDataMap.Get(JobDataMapKeys.Name);
Logger.Info(string.Format("Job : {0} : {1} : {2} : Executing", this.GetType().Name, name, Id));
foreach (var ep in CustomConfig.Instance.EndPoints)
{
var endPoint = ep;
var request = new DipsTransportRequest {
Id = this.Id, Message = "Process Dips Files Transfer"
};
var thread = new Thread(() =>
{
Logger.Info(string.Format("Job : {0} : {1} : {2} : Dispatching Request, EndPoint = {3}, Data = {4}", Id, this.GetType().Name, name, endPoint.Url, request.ToJson()));
Thread.CurrentThread.IsBackground = true;
var response = new RESTClient()
.TryPost <DipsTransportRequest, DipsTransportResponse>(endPoint.Url, request)
.Result;
Logger.Info(string.Format("Job : {0} : {1} : {2} : Response Received, EndPoint = {3}, Data = {4}", Id, this.GetType().Name, name, endPoint.Url, response.ToJson()));
}
);
thread.Start();
}
Logger.Info(string.Format("Job : {0} : {1} : {2} : Completed", this.GetType().Name, name, Id));
}
public override async Task <BlockChainAddressInformation> GetAddress(string address)
{
try
{
await _SemaphoreSlim.WaitAsync();
//https://chain.so/api#rate-limits
//5 requests/second * 3
await Task.Delay(400);
var balance = await RESTClient.GetAsync <ChainSoAddress>($"/api/v2/get_address_balance/{Currency}/{address}");
if (balance.data.confirmed_balance != 0)
{
//TODO: This should include both confirmed and unconformed...
return(new BlockChainAddressInformation(address, balance.data.confirmed_balance, false));
}
//There is no balance so check to see if the address was ever used
await Task.Delay(400);
var received = await RESTClient.GetAsync <ChainSoAddressReceived>($"/api/v2/get_address_received/{Currency}/{address}");
return(new BlockChainAddressInformation(address, balance.data.confirmed_balance, received.data.confirmed_received_value == 0));
}
finally
{
_SemaphoreSlim.Release();
}
}
private void upPlay_Click(object sender, RoutedEventArgs e)
{
List <Record> recordList = new List <Record>();
if (playlistView.Items.Count == 0)
{
recordList.Add(new Record()
{
UID = int.Parse(MainPage.userSettings._userID), videoname = "#####"
});
}
else
{
foreach (MediaModel mediaModel in playlistView.Items)
{
if (mediaModel.canSync)
{
Record record = new Record()
{
bytes = 123,
UID = int.Parse(MainPage.userSettings._userID),
videoname = mediaModel.Title,
LastOpened = DateTime.Now.ToString(),
location = "LibraryVideo",
record = mediaModel.PlaybackPosition.ToString()
};
recordList.Add(record);
}
}
}
RESTClient.UpdateRecordList(recordList);
}
public IAsyncResult BeginPost(string classname, object pobject, ProtoAPIPostCallback callback)
{
if (string.IsNullOrEmpty(classname) || null == pobject)
{
throw new ProtoAPIException("Invalid parameters: AsyncGet cannot be completed");
}
CheckUserAndAppKey();
ResponseStatus <string> response_status = new ResponseStatus <string>();
ManualResetEvent finished_event = new ManualResetEvent(false);
RESTAsyncResult async_result = new RESTAsyncResult(finished_event, response_status);
string payload = null;
try{
payload = JsonConvert.SerializeObject(pobject, new IsoDateTimeConverter());
} catch (Exception e) {
throw new ProtoAPIException("Unable to serialize object to json: " + e.Message);
}
if (string.IsNullOrEmpty(payload))
{
throw new ProtoAPIException("Resulting json string is null or empty");
}
RESTClient client = new RESTClient(m_ServiceUri);
client.SetBasicAuthorizationCredential(m_username, m_appkey);
client.AsyncPost("objects/" + classname, null, payload, delegate(int status, string response){
response_status.statusCode = status;
if (status == 201)
{
JsonResponseObject <string> data_wrapper;
data_wrapper = JsonConvert.DeserializeObject <JsonResponseObject <string> >(response, new IsoDateTimeConverter());
response_status.responseData = data_wrapper.data;
if (null != callback)
{
callback(response_status, data_wrapper.data as string);
}
}
else
{
response_status.responseData = response;
response_status.errorMessage = response;
if (null != callback)
{
callback(response_status, null);
}
}
async_result.SetCompleted();
});
return(async_result);
}
public override async Task <Collection <ExchangePairPrice> > GetPairs(CurrencySymbol baseSymbol, PriceType priceType)
{
var retVal = new Collection <ExchangePairPrice>();
var markets = await RESTClient.GetAsync <Markets>("/api/v1.1/public/getmarketsummaries");
foreach (var pair in markets.result)
{
var baseSymbolName = pair.MarketName.Substring(0, 3);
var toSymbolName = pair.MarketName.Substring(4, pair.MarketName.Length - 4);
var currentBaseSymbol = new CurrencySymbol(baseSymbolName);
if (baseSymbol != null)
{
if (!currentBaseSymbol.Equals(baseSymbol))
{
continue;
}
}
retVal.Add(new ExchangePairPrice(pair.Volume)
{
BaseSymbol = currentBaseSymbol, ToSymbol = new CurrencySymbol(toSymbolName), Price = priceType == PriceType.Ask ? pair.Ask : pair.Bid
});
}
return(retVal);
}
public void Start()
{
if (!RESTClient.IsInitialized)
{
RESTClient.Init(OnInitialized);
}
}
public void UpdatePartial()
{
using (MSSQLDbClient sqlClient = new MSSQLDbClient(ConnectionString))
{
ProductRowApiO existing = sqlClient.Fill <ProductRowApiO>(GetRecordSql);
if (existing == null)
{
this.Create();
existing = sqlClient.Fill <ProductRowApiO>(GetRecordSql);
}
Assert.NotNull(existing);
using (RESTClient restClient = new RESTClient(BaseUrl))
{
string partialJson = "{ \"ProductId\": " + existing.ProductId + ", \"CategoryId\": 2, \"SupplierId\": 1, \"UnitPrice\": 32.1 }";
RestResult <ProductRowApiO> apiResult = restClient.Execute <ProductRowApiO>("Product", RestSharp.Method.PATCH, jsonBodyPartial: partialJson, headerParameters: Headers);
Assert.True(apiResult.StatusCode == 200, apiResult.Content);
ProductRowApiO dbValue = sqlClient.Fill <ProductRowApiO>(GetRecordSql);
Assert.True(dbValue.UnitPrice == (decimal)32.1, "Incorrect text was saved.");
}
}
}
public void Update()
{
using (MSSQLDbClient sqlClient = new MSSQLDbClient(ConnectionString))
{
ProductRowApiO existing = sqlClient.Fill <ProductRowApiO>(GetRecordSql);
if (existing == null)
{
this.Create();
existing = sqlClient.Fill <ProductRowApiO>(GetRecordSql);
}
Assert.NotNull(existing);
using (RESTClient restClient = new RESTClient(BaseUrl))
{
ProductRowApiO updated = existing;
updated.UnitPrice = 123;
RestResult <ProductRowApiO> apiResult = restClient.Execute <ProductRowApiO>("Product", RestSharp.Method.PATCH, jsonBody: updated, headerParameters: Headers);
Assert.True(apiResult.StatusCode == 200, apiResult.Content);
Assert.True(apiResult.Result.UnitPrice == 123, "The updated value was not returned");
}
ProductRowApiO dbValue = sqlClient.Fill <ProductRowApiO>(GetRecordSql);
Assert.True(dbValue.UnitPrice == 123, "The updated value was not returned");
}
}
public void UpdatePartialBadly()
{
using (MSSQLDbClient sqlClient = new MSSQLDbClient(ConnectionString))
{
ProductRowApiO existingCategory = sqlClient.Fill <ProductRowApiO>(GetRecordSql);
if (existingCategory == null)
{
this.Create();
existingCategory = sqlClient.Fill <ProductRowApiO>(GetRecordSql);
}
Assert.NotNull(existingCategory);
using (RESTClient restClient = new RESTClient(BaseUrl))
{
string partialJson = "{ \"ProductId\": " + existingCategory.ProductId + " }";
RestResult <ProductRowApiO> apiResult = restClient.Execute <ProductRowApiO>("Product", RestSharp.Method.PATCH, jsonBodyPartial: partialJson, headerParameters: Headers);
Assert.False(apiResult.StatusCode == 200, apiResult.Content);
}
ProductRowApiO dbValue = sqlClient.Fill <ProductRowApiO>(GetRecordSql);
Assert.False(dbValue.ProductName == string.Empty, "Incorrect text was saved.");
}
}
public void Delete()
{
using (MSSQLDbClient sqlClient = new MSSQLDbClient(ConnectionString))
{
ProductRowApiO existingCategory = sqlClient.Fill <ProductRowApiO>(GetRecordSql);
if (existingCategory == null)
{
this.Create();
existingCategory = sqlClient.Fill <ProductRowApiO>(GetRecordSql);
}
Assert.NotNull(existingCategory);
using (RESTClient restClient = new RESTClient(BaseUrl))
{
List <KeyValuePair <string, string> > routeParams = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("key", existingCategory.ProductId.ToString())
};
RestResult <ProductRowApiO> apiResult = restClient.Execute <ProductRowApiO>("Product/{key}", RestSharp.Method.DELETE, routeParameters: routeParams, headerParameters: Headers);
Assert.True(apiResult.StatusCode == 301, apiResult.Content);
}
ProductRowApiO dbValue = sqlClient.Fill <ProductRowApiO>(GetRecordSql);
Assert.Null(dbValue);
}
}
public void Create()
{
using (MSSQLDbClient sqlClient = new MSSQLDbClient(ConnectionString))
{
ProductRowApiO existing = sqlClient.Fill <ProductRowApiO>(GetRecordSql);
if (existing != null)
{
this.Delete();
}
using (RESTClient restClient = new RESTClient(BaseUrl))
{
ProductRowApiO newItem = new ProductRowApiO()
{
ProductName = TestProductName, CategoryId = 2, QuantityPerUnit = "4 in a box", UnitPrice = (decimal)12.37, SupplierId = 1
};
RestResult <ProductRowApiO> apiResult = restClient.Execute <ProductRowApiO>("Product", RestSharp.Method.PUT, jsonBody: newItem, headerParameters: Headers);
Assert.True(apiResult.StatusCode == 201, apiResult.Content);
ProductRowApiO sqlResult = sqlClient.Fill <ProductRowApiO>(GetRecordSql);
Assert.True(sqlResult.ProductName == apiResult.Result.ProductName &&
sqlResult.CategoryId == apiResult.Result.CategoryId &&
sqlResult.QuantityPerUnit == apiResult.Result.QuantityPerUnit &&
sqlResult.ProductId == apiResult.Result.ProductId);
}
}
}
public override async Task <Collection <ExchangePairPrice> > GetPairs(CurrencySymbol baseSymbol, PriceType priceType)
{
var retVal = new Collection <ExchangePairPrice>();
var prices = await RESTClient.GetAsync <Collection <PairPrice> >("/api/v1/ticker/price");
foreach (var price in prices)
{
var toSymbolName = price.symbol.Substring(0, price.symbol.Length - 3);
var baseSymbolName = price.symbol.Substring(price.symbol.Length - 3, 3);
var currentBaseSymbol = new CurrencySymbol(baseSymbolName);
if (baseSymbol != null)
{
if (!currentBaseSymbol.Equals(baseSymbol))
{
continue;
}
}
retVal.Add(new ExchangePairPrice(null)
{
BaseSymbol = baseSymbol, ToSymbol = new CurrencySymbol(toSymbolName), Price = price.price
});
}
return(retVal);
}
private async void downPlay_Click(object sender, RoutedEventArgs e)
{
List <Record> recordList = RESTClient.GetRecordByID(int.Parse(MainPage.userSettings._userID));
if (playbackList.Items.Count != 0)
{
delPlay_Click(this, null);
}
foreach (Record record in recordList)
{
StorageFolder storageFolder = KnownFolders.VideosLibrary;
StorageFile file = await storageFolder.GetFileAsync(record.videoname);
var thumbnail = await file.GetScaledImageAsThumbnailAsync(ThumbnailMode.VideosView);
WriteableBitmap writeableBitmap = new WriteableBitmap(100, 64);
InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream();
await RandomAccessStream.CopyAsync(thumbnail, randomAccessStream);
randomAccessStream.Seek(0);
writeableBitmap.SetSource(randomAccessStream);
MediaModel media = new MediaModel(file)
{
Title = file.Name,
ArtUri = writeableBitmap,
PlaybackPosition = TimeSpan.Parse(record.record),
PlaybackHistory = DateTime.Parse(record.LastOpened)
};
pVLis.Items.Add(media);
playbackList.Items.Add(media.MediaPlaybackItem);
}
}
public async Task GetOne_ReturnsNull_WhenInvalid()
{
var client = new RESTClient("https://jsonplaceholder.typicode.com");
var blogPost = await client.GetOne <BlogPost>("posts", int.MaxValue);
Assert.Null(blogPost);
}
public override async Task <BlockChainAddressInformation> GetAddress(string address)
{
var addressModel = await RESTClient.GetAsync <Account>($"/accounts/{address}");
//TODO: Get a transaction list?
return(new BlockChainAddressInformation(addressModel.account_id, null, addressModel.balances.FirstOrDefault().balance));
}
public void StartSearch(string query)
{
Reset();
SearchQuery = query;
HasStarted = true;
restClient = new RESTClient();
Results = restClient.Get<List<string>>(endpoint, new { tag = SearchQuery });
}
static void Main(string[] args)
{
dynamic me = new RESTClient();
me.Url = "http://api.flickr.com";
me.OutputPipeLine.Add(1, new Tuple<string, Action<Request>>("addapikey", r => r.Uri = r.Uri + "&api_key=0936270ae439d42bce22ee3be8703112"));
IAmAFlickr client = Impromptu.ActLike<IAmAFlickr>(me);
Console.WriteLine ("---------------------- getinfoonpeople");
Console.WriteLine (client.GetInfoOnPeople<rsp>(new { user_id = "61304303%40N08"}));
Console.WriteLine ("---------------------- echotest");
Console.WriteLine (client.EchoTest(new { i_am_a = "banana", and_the_world_should_be_square = true }));
Console.ReadLine ();
}
public static IStorageClient GetStorageClient()
{
dynamic client = new RESTClient {Url = "http://localhost:8081"};
client.AddRule.Out = new Func<DynamicRule, byte[]>(rule =>
{
using (var ms = new MemoryStream())
{
Serializer.Serialize(ms, rule);
return ms.ToArray();
}
});
client.GetRules.In = new Func<WebResponse, IEnumerable<DynamicRule>>(wr => Serializer.Deserialize<List<DynamicRule>>(wr.GetResponseStream()));
//return null;
return Impromptu.ActLike<IStorageClient> (client);
}
public void ShouldBeAbleToDeserializeProtocolBuffers()
{
byte[] buffer;
using (var ms = new MemoryStream())
{
Serializer.Serialize(ms, new AModel { D = 0.1, I = 1, L = 2, S = "s" });
buffer = ms.ToArray();
}
var test = TestWebRequestCreate.CreateTestRequest(buffer);
test.ContentType = "application/protocol-buffers";
dynamic me = new RESTClient();
me.Url = "test://test";
var a = me.GetTest<AModel>();
Assert.AreEqual(typeof(AModel), a.GetType());
Assert.AreEqual(a.D, 0.1);
Assert.AreEqual(a.I, 1);
Assert.AreEqual(a.L, 2L);
Assert.AreEqual(a.S, "s");
}
public void EnsureThatTheSpecifiedInputEditorGetsUsed()
{
TestWebRequestCreate.CreateTestRequest("dummy");
dynamic me = new RESTClient();
me.Url = "test://test";
me.GetTest.In = new Func<Response, string>(w =>
{
string test;
using (var sr = new StreamReader(w.ResponseStream))
test = sr.ReadToEnd();
Assert.AreEqual(test, "dummy");
return "";
});
me.GetTest();
}
public void EnsureThatTheSpecifiedOuputEditorGetsUsed()
{
TestWebRequestCreate.CreateTestRequest("dummy");
dynamic me = new RESTClient();
me.Url = "test://test";
me.GetTest.Out = new Func<string, Request>(s =>
{
Assert.AreEqual(s, "test");
return new Request {Body = Encoding.UTF8.GetBytes(s)};
});
me.GetTest("test");
}
public void MultipleNounTest()
{
TestWebRequestCreate.CreateTestRequest("");
dynamic me = new RESTClient();
me.Url = "test://base";
var check = false;
me.GetMultipleNounTest.In = new Func<Response, string>(w =>
{
Assert.AreEqual(new Uri("test://base/multiple/noun/test"), w.ResponseUri);
check = true;
return "yes";
});
me.GetMultipleNounTest();
Assert.IsTrue(check);
}
public void OneWordFunctionsShouldAlwaysBeGetFunctions()
{
var request = TestWebRequestCreate.CreateTestRequest ("");
var client = new RESTClient ();
//register the default URI composer because the one below automaticaly takes precedence over the default one.
client.Container.Register(typeof (IUriComposer), typeof (DefaultUriComposer));
dynamic me = client;
me.Url = "test://base";
me.Noun.In = new Func<Response, string> (w =>
{
Assert.AreEqual (new Uri ("test://base/noun/test"), w.ResponseUri);
return "yes";
});
me.Noun ("test");
Assert.AreEqual ("GET", request.Method);
}
public void EnsureArgumentDelegatesTakePrecedenceOverPredefinedDelegates()
{
TestWebRequestCreate.CreateTestRequest(5);
dynamic me = new RESTClient();
me.Url = "test://test";
me.GetTest.In = new Func<Response, int>(s =>
{
Assert.Fail("Wrong delegate got called!");
using (var sr = new BinaryReader(s.ResponseStream))
return sr.ReadInt32();
});
var result = me.GetTest(new Func<Response, int>(s => 4));
Assert.AreEqual(result, 4);
}
public void EnsureCorrenctFillingOfOutputEditorArgumentsWhenTheyArentCorrectlySorted()
{
var isused = false;
TestWebRequestCreate.CreateTestRequest("dummy");
dynamic me = new RESTClient();
me.Url = "test://test";
me.GetTest.Out =
new Func<int, int, string, long, int, string, string, Request>((i1, i2, s1, l1, i3, s2, s3) =>
{
isused = true;
Assert.AreEqual(i1, 1);
Assert.AreEqual(i2, 2);
Assert.AreEqual(s1, "3");
Assert.AreEqual(l1, 4);
Assert.AreEqual(i3, 5);
Assert.AreEqual(s2, "6");
Assert.AreEqual(s3, "7");
return new Request();
});
me.GetTest(1, 2, 5, "3", "6", "7", (long) 4);
Assert.IsTrue(isused);
}
public void ShouldBeAbleToAddAHeaderInAOutputPipeLine()
{
var req = TestWebRequestCreate.CreateTestRequest("dummy");
dynamic me = new RESTClient();
me.Url = "test://test";
me.OutputPipeLine.Add(0.002, Tuple.Create("pipelineitem", new Action<Request>(r => r.Headers.Add("Authorization", "yes"))));
me.GetTest();
Assert.AreEqual("yes", req.Headers["Authorization"]);
}
public void ShouldBeAbleToChangeTheWayURLsAreBuiltUp()
{
TestWebRequestCreate.CreateTestRequest ("dummy");
var client = new RESTClient ();
dynamic me = client;
me.Url = "test://base";
me.GetTest.In = new Func<Response, Stream> (r =>
{
Assert.AreEqual(r.ResponseUri, "test://base/test/param/");
return r.ResponseStream;
});
me.GetTest ("param");
TestWebRequestCreate.CreateTestRequest ("dummy");
me.GetTest.In = new Func<Response, Stream> (r =>
{
Assert.AreEqual (new Uri ("test://base/test/param1/param2/"), r.ResponseUri);
return r.ResponseStream;
});
me.GetTest ("param1", "param2");
}
public void ShouldBeAbleToDeserializeADateTime()
{
var test = TestWebRequestCreate.CreateTestRequest(@"""/Date(1307871513107)/""");
test.ContentType = "application/json";
dynamic me = new RESTClient();
me.Url = "test://test";
var a = me.GetTest<DateTime>();
Assert.AreEqual(typeof (DateTime), a.GetType());
}
public Response(RESTClient client)
{
_client = client;
}
public void UrlParameterArguments()
{
TestWebRequestCreate.CreateTestRequest("dummy");
dynamic me = new RESTClient();
me.Container.Register(typeof(IUriComposer), typeof(DefaultUriComposer));
me.Url = "test://base";
me.GetTest.In = new Func<Response, Stream>(r =>
{
Assert.AreEqual(new Uri("test://base/test/param"), r.ResponseUri);
return r.ResponseStream;
});
me.GetTest("param");
TestWebRequestCreate.CreateTestRequest("dummy");
me.GetTest.In = new Func<Response, Stream>(r =>
{
Assert.AreEqual(new Uri("test://base/test/param1/param2"), r.ResponseUri);
return r.ResponseStream;
});
me.GetTest("param1", "param2");
}
public void EnsureAFunctionCallWithEverythingAlsoWorks()
{
TestWebRequestCreate.CreateTestRequest("dummy");
dynamic me = new RESTClient();
me.Container.Register(typeof (IUriComposer), typeof (DefaultUriComposer));
me.Url = "test://base";
var result = me.GetTest<string>(
/*QueryString*/
new {page = "1", items = "50"},
/*OutputEditorArguments*/
1, 2, 3, 4, "5", "6",
/*URLParam*/
"param",
/*OutputEditor*/
new Func<int, string, int, string, int, int, Request>(
(i1, s1, i2, s2, i3, i4) =>
{
Assert.AreEqual(i1, 1);
Assert.AreEqual(s1, "5");
Assert.AreEqual(i2, 2);
Assert.AreEqual(s2, "6");
Assert.AreEqual(i3, 3);
Assert.AreEqual(i4, 4);
return new Request {Body = new byte[16]};
}),
/*InputEditor*/
new Func<Response, string>(w =>
{
Assert.AreEqual(w.ResponseUri, "test://base/test/param?page=1&items=50");
using (var sr = new StreamReader(w.ResponseStream))
return sr.ReadToEnd();
}));
Assert.AreEqual(result, "dummy");
}
public void EnsureExceptionWhenThereAreArgumentsMissingForOutputEditor()
{
dynamic me = new RESTClient();
//me.GetTest.In = new Func<Stream, int> (s => 1);
me.GetTest.Out =
new Func<int, int, string, long, int, string, string, Request>(
(i1, i2, s1, l1, i3, s2, s3) => new Request {Body = new byte[12]});
me.GetTest(1, 2, "3", (long) 4, /* missing5,*/ "6", "7");
}
public void EnsureExceptionWhenGenericTypeDoesNotEqualInputEditorOutputType()
{
dynamic me = new RESTClient();
me.GetTest.In = new Func<Response, int>(s => 1);
me.GetTest<string>("test");
}
public void PutVerbTest()
{
var request = TestWebRequestCreate.CreateTestRequest("");
dynamic me = new RESTClient();
me.Url = "test://base";
me.PutTest.Out = new Func<int, Request>(i => new Request {Body = BitConverter.GetBytes(i)});
me.PutTest(1);
Assert.AreEqual(BitConverter.ToInt32(((MemoryStream) request.GetRequestStream()).ToArray(), 0), 1);
}
public void EnsureCorrenctFillingOfOutputEditorArguments()
{
TestWebRequestCreate.CreateTestRequest("dummy");
dynamic me = new RESTClient();
me.Url = "test://test";
me.GetTest.Out =
new Func<int, int, string, long, int, string, string, Request>((i1, i2, s1, l1, i3, s2, s3) =>
{
Assert.AreEqual(i1, 1);
Assert.AreEqual(i2, 2);
Assert.AreEqual(s1, "3");
Assert.AreEqual(l1, 4);
Assert.AreEqual(i3, 5);
Assert.AreEqual(s2, "6");
Assert.AreEqual(s3, "7");
return new Request();
});
me.GetTest(1, 2, "3", (long) 4, 5, "6", "7");
}
public void OutputEditorInArgumentWithLotsOfArguments()
{
TestWebRequestCreate.CreateTestRequest("dummy");
dynamic me = new RESTClient();
me.Url = "test://base";
var result = me.GetTest(1, 2, 3, 4, 5, (long) 6, "7", "8", true,
new Func<bool, string, long, string, int, int, int, int, int, Request>(
(a, b, c, d, e, f, g, h, i) =>
{
Assert.IsTrue(a);
Assert.AreEqual(b, "7");
Assert.AreEqual(c, 6);
Assert.AreEqual(d, "8");
Assert.AreEqual(e, 1);
Assert.AreEqual(f, 2);
Assert.AreEqual(g, 3);
Assert.AreEqual(h, 4);
Assert.AreEqual(i, 5);
return new Request {Body = new byte[16]};
}),
new Func<WebResponse, WebResponse>(r => r));
Assert.AreEqual(new Uri("test://base/test"), result.ResponseUri);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="pattern">zoek pattern</param>
/// <param name="limitRate">lief zijn (of niet)</param>
public RunningTotal(string pattern, bool limitRate)
{
LimitRate = limitRate;
Realtors = new ConcurrentDictionary<int, Realtor> ();
_pattern = pattern;
//de rest client http://nuget.org/packages/DRC en https://github.com/albertjan/DynamicRestClient
dynamic client = new RESTClient(uriComposer: new AlternativeUriComposer());
//geen basis url op.
client.Url = "http://partnerapi.funda.nl/feeds/Aanbod.svc";
//Iets wat ik een input editor noem een delegate die een webresponse vertaald naar het geweste object.
//Als ik de duck-casting weg zou laten zou dit automatisch gaan maar dan zou de type-safety verder op.
//Als de resquest GetJson<FundaResult>(ApiKey, params) zou zijn zou de DRC aan de hand van het
//generic-type-argument zien waarnaar hij het resultaat moet parsen. Maar ImpromptuInterface ondersteund
//niet het casten naar Interface's die Generic functies bevatten.
client.GetJson.In = new Func<WebResponse, FundaResult>(r =>
{
using (var sr = new StreamReader(r.GetResponseStream()))
{
return DRC.SimpleJson.DeserializeObject<FundaResult>(sr.ReadToEnd());
}
});
//ImpromptuInterface gebruiken om van de dynamic client een semi typesafe object te maken.
FundaClient = Impromptu.ActLike<IFundaClient>(client);
}
public void ShouldExecutePipeLineEntries()
{
TestWebRequestCreate.CreateTestRequest("dummy");
dynamic me = new RESTClient();
me.Url = "test://test";
var pipelinetest = "apeshit";
var pipelinetest2 = "apeshit";
me.InputPipeLine.Add(2.5,
Tuple.Create("pipelineitem", new Action<Response>(resp => { pipelinetest = "yep"; })));
me.OutputPipeLine.Add(0.002,
Tuple.Create("pipelineitem",
new Action<Request>(resp => { pipelinetest2 = "yep"; })));
me.GetTest.In = new Func<Response, string>(w =>
{
string test;
using (var sr = new StreamReader(w.ResponseStream))
test = sr.ReadToEnd();
Assert.AreEqual(test, "dummy");
return "";
});
me.GetTest();
Assert.AreEqual("yep", pipelinetest);
Assert.AreEqual("yep", pipelinetest2);
}
public void ShouldReturnTheContentsAsAStringWhenConvertedToOneEvenIfTheContentTypeIsSerialiazble()
{
var test =
TestWebRequestCreate.CreateTestRequest(
SimpleJson.SerializeObject(new AModel { D = 0.1, I = 1, L = 2, S = "s" }));
test.ContentType = "application/json";
dynamic me = new RESTClient();
me.Url = "test://test";
string a = me.GetTest();
Assert.AreEqual(typeof(string), a.GetType());
Assert.AreEqual("{\"I\":1,\"S\":\"s\",\"L\":2,\"D\":0.1}", a);
}
public void ShouldUseSpecifiedUrl()
{
TestWebRequestCreate.CreateTestRequest("dummy");
dynamic me = new RESTClient();
me.Url = "test://test";
me.GetTest.Url = "bananas/overthere";
me.OutputPipeLine.Add(0.1,
Tuple.Create("hi",
new Action<Request>(
r =>
Assert.AreEqual("test://test/bananas/overthere",
r.Uri))));
me.GetTest();
}
public void ShouldTryToDeserializeJsonToGenericTypeArgument()
{
var test =
TestWebRequestCreate.CreateTestRequest(
SimpleJson.SerializeObject(new AModel {D = 0.1, I = 1, L = 2, S = "s"}));
test.ContentType = "application/json";
dynamic me = new RESTClient();
me.Url = "test://test";
var a = me.GetTest<AModel>();
Assert.AreEqual(typeof (AModel), a.GetType());
}
public void ShouldTryToDeserializeXMLToGenericTypeArgument()
{
string xml;
using (var ms = new MemoryStream())
using (var sw = new StreamWriter(ms))
{
new XmlSerializer(typeof (AModel)).Serialize(sw, new AModel {D = 0.1, I = 1, L = 2, S = "s"});
sw.Flush();
ms.Position = 0;
using (var sr = new StreamReader(ms))
{
xml = sr.ReadToEnd();
}
}
var test = TestWebRequestCreate.CreateTestRequest(xml);
test.ContentType = "application/xml";
dynamic me = new RESTClient();
me.Url = "test://test";
var a = me.GetTest<AModel>();
Assert.AreEqual(typeof (AModel), a.GetType());
}
public void ShouldBeAbleToDeserializeAGuid()
{
var test = TestWebRequestCreate.CreateTestRequest(@"""378eb2ddc6d4461b9b4cf77ef0098daf""");
test.ContentType = "application/json";
dynamic me = new RESTClient();
me.Url = "test://test";
var a = me.GetTest<Guid>();
Assert.AreEqual(typeof (Guid), a.GetType());
}
public ActionResult ProcessRequest(ApiTestRequest request)
{
// Base uri
string baseUri = ConfigurationManager.AppSettings["LitmosAPIBaseUri"].ToString();
RESTResponse rs = new RESTResponse();
RESTClient client = new RESTClient(baseUri, request.ApiKey, request.Source);
RequestFactory factory = new RequestFactory(baseUri, request.ApiKey, request.Source);
switch (request.RequestType)
{
case "USERS": // Get a List of Users
// Get
var listUsers = factory.ListUsers(Request.Form["Filter"]);
// Format Response
request.ResponseBody = GetUserList(listUsers);
break;
case "USER": // Get a User
// Get
var singleUser = factory.GetUser(Request.Form["UserId"]);
// Format Response
request.ResponseBody = GetUser(singleUser);
break;
case "CREATE_USER": // Create a User
UserProfile createUser = new UserProfile(Request.Form["UserName"], Request.Form["FirstName"], Request.Form["LastName"]);
// Create
var newUser = factory.CreateUser(createUser);
// Format Response
request.ResponseBody = GetUser(newUser);
break;
case "UPDATE_USER": // Update a User
// Get User
var updateUser = factory.GetUser(Request.Form["UserId"]);
// Update User Properties
if (updateUser != null)
{
updateUser.Id = Request.Form["UserId"];
updateUser.FirstName = Request.Form["FirstName"];
updateUser.LastName = Request.Form["LastName"];
// Update
updateUser = factory.UpdateUser(Request.Form["UserId"], updateUser);
}
break;
case "TEAMS": // Get a List of Teams
request.ResponseBody = GetTeamList(factory.ListTeams(Request.Form["Filter"]));
break;
case "SUBTEAMS": // Get a List of sub Teams
// Get
var subTeams = factory.ListTeams(Request.Form["TeamId"], Request.Form["Filter"]);
// Format Response
request.ResponseBody = GetTeamList(subTeams);
break;
case "ADD_TEAMUSERS": // Get a List of Teams
var users = new UserList();
users.Add(new UserProfilePartial(){
Id = Request.Form["UserId"]
});
var userTeamSuccess = factory.AddUsersToTeam(Request.Form["TeamId"], users);
// Format Response
request.ResponseBody = userTeamSuccess ? "Users added to team!" : "Users to team FAILED";
break;
case "TEAMUSERS": // Get a List of Users
// Get
var listTeamUsers = factory.ListTeamUsers(Request.Form["TeamId"]);
// Format Response
request.ResponseBody = GetUserList(listTeamUsers);
break;
case "PROMOTE_LEADER":
var promoteLeader = factory.PromoteTeamLeader(Request.Form["TeamId"], Request.Form["UserId"]);
// Format Response
request.ResponseBody = promoteLeader ? "Users promoted to team leader!" : "Users to team FAILED";
break;
case "DEMOTE_LEADER":
var demoteTeamLeader = factory.DemoteTeamLeader(Request.Form["TeamId"], Request.Form["UserId"]);
// Format Response
request.ResponseBody = demoteTeamLeader ? "Users demoted from team leader!" : "Users to team FAILED";
break;
case "COURSES": // Get a List of Courses
// Get
var listCourses = factory.ListCourses();
// Format Response
request.ResponseBody = GetCourseList(listCourses);
break;
case "USER_COURSES": // Get a List of Courses
// Get
var listUserCourses = factory.ListUserCourses(Request.Form["UserId"]);
// Format Response
request.ResponseBody = GetUserCourseList(listUserCourses);
break;
}
if (rs != null)
{
request.ResponseStatusCode = rs.StatusCode;
request.ResponseDescription = rs.StatusDescription;
}
return View("Index", request);
}
