public void AuthenticationMechanism()
{
var client = new RestClient("http://*****:*****@email.com", password = "******" });
var response = client.ExecutePostTaskAsync(request).GetAwaiter().GetResult();
var access_token = response.DeserializeResponse()["access_token"];
var jwtAuth = new JwtAuthenticator(access_token);
client.Authenticator = jwtAuth;
var getRequest = new RestRequest("posts/{postid}", Method.GET);
getRequest.AddUrlSegment("postid", 5);
//Perform the Get Operation
var result = client.ExecuteAsyncRequest <Posts>(getRequest).GetAwaiter().GetResult();
//Assert.That(result.Data.author, Is.EqualTo("Karthik KK"), "The author is not correct");
}
public void AuthenticationMechanismWithJSONFile()
{
var client = new RestClient("http://*****:*****@"TestData/Data.json";
request.RequestFormat = DataFormat.Json;
var jsonData = JsonConvert.DeserializeObject <User>(File.ReadAllText(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, file)).ToString());
request.AddJsonBody(jsonData);
var response = client.ExecutePostAsync(request).GetAwaiter().GetResult();
var access_token = response.DeserializeResponse()["access_token"];
var jwtAuth = new JwtAuthenticator(access_token);
client.Authenticator = jwtAuth;
var getRequest = new RestRequest("posts/{postid}", Method.GET);
getRequest.AddUrlSegment("postid", 5);
//Perform Get operation
var result = client.ExecuteAsyncRequest <Posts>(getRequest).GetAwaiter().GetResult();
Assert.That(result.Data.author, Is.EqualTo("Karthik KK"), "The author is not correct");
}
public void AuthenticatingUser()
{
var client = new RestClient("https://fast-fjord-65171.herokuapp.com/");
var request = new RestRequest("api/users/login", Method.POST);
var file = @"TestData\User.json";
var jsonData = JsonConvert.DeserializeObject <LoginUser>(File.ReadAllText(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, file)).ToString());
request.AddJsonBody(jsonData);
var response = client.ExecutePostTaskAsync(request).GetAwaiter().GetResult();
var access_token = response.DeserializeResponse()["token"];
var token = access_token.Split(' ')[1];
var jwtAuth = new JwtAuthenticator(token);
client.Authenticator = jwtAuth;
var postRequest = new RestRequest("api/posts", Method.POST);
postRequest.AddJsonBody(new { text = "Posting this with RestSharp" });
var postResponse = client.ExecutePostTaskAsync(postRequest).GetAwaiter().GetResult();
//var result = postResponse.DeserializeResponse()["text"];
//Console.WriteLine(result);
var result = postResponse.DeserializeResponse();
foreach (KeyValuePair <string, string> data in result)
{
Console.WriteLine($"{data.Key} - {data.Value}");
}
}
private async void AddBar_Click(object sender, RoutedEventArgs e)
{
if (showusers.SelectedIndex >= 0)
{
curentaccount = showusers.SelectedItem as Account;
SetBarcode setBarcode = new SetBarcode(curentaccount);
setBarcode.ShowDialog();
var act = App.accesstoken;
var Client = new RestClient(ConfigurationManager.AppSettings["api"].ToString());
var authentication = new JwtAuthenticator(act);
Client.Authenticator = authentication;
var request = new RestRequest("api/Customer/getCustomers", Method.GET);
var response = await Client.ExecuteGetTaskAsync <CoreResponse>(request);
var deserialize = new JsonDeserializer();
var output = deserialize.Deserialize <Dictionary <string, string> >(response);
var result = output["data"];
var account = JsonConvert.DeserializeObject <List <Account> >(result);
showusers.ItemsSource = null;
showusers.ItemsSource = account;
}
}
public void AuthenticationMechanism()
{
var client = new RestClient("http://*****:*****@email.com",
password = "******"
});
var response = client.ExecutePostAsync(request).GetAwaiter().GetResult();
var access_token = response.DeserializeResponse()["access_token"];
var jwtAuth = new JwtAuthenticator(access_token);
client.Authenticator = jwtAuth;
var getRequest = new RestRequest("posts/{postid}", Method.GET);
getRequest.AddUrlSegment("postid", 5);
var result = client.ExecuteGetAsync <Posts>(getRequest).GetAwaiter().GetResult();
Assert.Equal("Karthik KK", result.Data.author);
}
public void AuthenticationMechanismWithJsonFile()
{
var client = new RestClient("http://*****:*****@"TestData/Data.json";
//desserializando o objeto User, pegando os valores do arquivo Data.json e adicionando no body da request
var jsonData = JsonConvert.DeserializeObject <User>(File.ReadAllText(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, file)).ToString());
request.AddJsonBody(jsonData);
var response = client.ExecutePostAsync(request).GetAwaiter().GetResult();
var access_token = response.DeserializeResponse()["access_token"];
var jwtAuth = new JwtAuthenticator(access_token);
client.Authenticator = jwtAuth;
var getRequest = new RestRequest("posts/{postid}", Method.GET);
getRequest.AddUrlSegment("postid", 5);
var result = client.ExecuteGetAsync <Posts>(getRequest).GetAwaiter().GetResult();
Assert.Equal("Karthik KK", result.Data.author);
}
public JwtAuthenticator Refresh(JwtAuthenticator jwt)
{
if (string.IsNullOrEmpty(jwt.access) && string.IsNullOrEmpty(jwt.refresh))
{
throw new JwtEmptyTokenException();
}
else
{
var client = new RestClient(Connection());
var auth = new RestRequest(RefreshUri, Method.POST)
{
RequestFormat = DataFormat.Json
};
auth.AddBody(new
{
refresh = jwt.refresh
});
var resp = client.Execute(auth);
if (resp.StatusCode == System.Net.HttpStatusCode.OK)
{
var token = JsonConvert.DeserializeObject <JwtRefresher>(resp.Content);
return(new JwtAuthenticator()
{
access = token.access,
refresh = jwt.refresh
});
}
else
{
/// if Jwt's refresh token was expire, you have to force user to log-in again.
throw new JwtRefreshExpiredException();
}
}
}
/// <summary>
/// Set up Default Settings.
/// You can change it after creating instance.
/// </summary>
public JwtRestClient()
{
Server = "yes24.cert.com"; // ip address is not robust porperties, so we just replace it with hostname, like yes24.cert.com
Port = 8000;
Scheme = HttpScheme.HTTP;
ObtainUri = "/api/auth/token/obtain/";
RefreshUri = "/api/auth/token/refresh/";
TestsUri = "/tests/";
Token = new JwtAuthenticator();
}
public void Authenticate(IRestClient client, IRestRequest request)
{
string accessToken = _authenticationContext.AcquireTokenAsync(_resource, _clientCredential)
.Result
.AccessToken;
JwtAuthenticator _jwtAuthenticator = new JwtAuthenticator(accessToken);
_jwtAuthenticator.Authenticate(client, request);
}
public void ThenVerifyStatusCodeReturnsOkAndSaveTheAuthenticationToken()
{
int StatusCode = (int)_settings.Response.StatusCode;
Assert.AreEqual(200, StatusCode, "Post login failed");
//using JWTAuthenticator for setting authorization token for the subsequent api calls
var jwtAuth = new JwtAuthenticator(acctoken.ToString());
_settings.RestClient.Authenticator = jwtAuth;
}
public ServiceClient(IHttpContextAccessor contextAccessor, IOptions <ApplicationOptions> optionsAccessor)
{
_contextAccessor = contextAccessor;
BaseUrl = new Uri(optionsAccessor.Value.OpenIdConnect.RedirectUri);
var token = _contextAccessor.HttpContext.GetTokenAsync(OpenIdConnectDefaults.AuthenticationScheme, OpenIdConnectParameterNames.AccessToken).Result;
if (token != null)
{
Authenticator = new JwtAuthenticator(token);
}
}
public async Task AuthenticateOnNullObject_Exception()
{
var versioningManager = new JwtAuthenticator("foobar");
ArgumentNullException ex;
ex = await Assert.ThrowsAsync <ArgumentNullException>(() => versioningManager.AuthenticateAsync(requestMessage: null));
Assert.Equal("requestMessage", ex.ParamName);
ex = await Assert.ThrowsAsync <ArgumentNullException>(() => versioningManager.AuthenticateAsync(httpClient: null));
Assert.Equal("httpClient", ex.ParamName);
}
public Parasut(string companyId = null, string clientId = null, string clientSecret = null, string username = null, string password = null)
{
CompanyId = companyId;
ClientId = clientId;
ClientSecret = clientSecret;
Username = username;
Password = password;
var authentication = new JwtAuthenticator(GetParasutAccessToken());
RestClient.Authenticator = authentication;
}
public void GivenIAuthenticateTheUserWithFollowingDetails(Table table)
{
dynamic data = table.CreateDynamicInstance();
_settings.Request = new RestRequest("", Method.POST);
_settings.Request.RequestFormat = DataFormat.Json;
_settings.Request.AddBody(new { name = data.userName.ToString(), job = data.password.ToString() });
_settings.Response = _settings.RestClient.ExecutePostTaskAsync(_settings.Request).GetAwaiter().GetResult();
var access_token = _settings.Response.GetResponseObject("access_token");
var authenticator = new JwtAuthenticator(access_token);
_settings.RestClient.Authenticator = authenticator;
}
public void GivenIGetJWTAuthenticationOfUserWithFollowingDetails(Table table)
{
dynamic data = table.CreateDynamicInstance();
_settings.Request = new RestRequest("auth/login", Method.POST);
_settings.Request.AddJsonBody(new { email = (string)data.Email, password = (string)data.Password });
//Get access token
_settings.Response = _settings.RestClient.ExecutePostAsync(_settings.Request).GetAwaiter().GetResult();
var access_token = _settings.Response.GetResponseObject("access_token");
//Authentication
var authenticator = new JwtAuthenticator(access_token);
_settings.RestClient.Authenticator = authenticator;
}
/// <summary>
/// DRF use json data format, We just use object to send data.
/// This is for Model Based Communication. But there is something huddle to overcome.
/// How datetime is converted.
/// See, https://docs.microsoft.com/ko-kr/dotnet/csharp/programming-guide/classes-and-structs/how-to-initialize-a-dictionary-with-a-collection-initializer
///
/// </summary>
/// <param name="data"></param>
public IRestResponse Insert(object data, JwtAuthenticator jwt)
{
var client = new RestClient(Connection());
var req = GetRequest(TestsUri,
data,
Method.POST,
DataFormat.Json,
new Dictionary <string, string>()
{
{ "Authorization", string.Format("Bearer {0}", jwt.access) }
});
var res = client.Execute(req);
return(res);
}
public void GivenIGetJwtAuthenticationOfUserWithFollowingDetails(Table table)
{
settings.RestClient.BaseUrl = new System.Uri("http://localhost:3000/");
dynamic data = table.CreateDynamicInstance();
settings.request = new RestRequest("auth/login", Method.GET);
settings.request.RequestFormat = DataFormat.Json;
settings.request.AddJsonBody(new { email = (string)data.email, password = (string)data.password });
//get access token
settings.Response = settings.RestClient.ExecutePostAsync(settings.request).GetAwaiter().GetResult();
var access_token = settings.Response.GetResponseObject("access_token");
//Authentication
var authenticator = new JwtAuthenticator(access_token);
settings.RestClient.Authenticator = authenticator;
}
public async Task AuthenticateWithHttpClient_Sucess(string token, string expectedAuthHeader, string errorMessage)
{
string error = null;
var replaceAuthHeader = errorMessage == null;
var authenticator = new JwtAuthenticator(token)
{
ReplaceAuthorizationHeader = replaceAuthHeader
};
authenticator.OnTrace += (msg) => error = msg;
Assert.True(await authenticator.AuthenticateAsync(httpClient));
Assert.Equal(replaceAuthHeader, await authenticator.AuthenticateAsync(httpClient));
Assert.Equal(errorMessage, error);
Assert.NotNull(httpClient.DefaultRequestHeaders.Authorization);
Assert.Equal(authenticator.Header, httpClient.DefaultRequestHeaders.Authorization);
Assert.Equal(expectedAuthHeader, httpClient.DefaultRequestHeaders.Authorization.ToString());
}
public void ExecuteAuthentication()
{
var client = new RestClient("https://reqres.in/api/");
var request = new RestRequest("login", Method.POST);
request.RequestFormat = DataFormat.Json;
request.AddBody(new { email = "*****@*****.**", password = "******" });
var reponse = client.ExecutePostTaskAsync(request).GetAwaiter().GetResult();
var access_token = reponse.DeserializeResponse()["token"];
var jwtAuth = new JwtAuthenticator(access_token);
client.Authenticator = jwtAuth;
var getrequest = new RestRequest("users/{userid}", Method.POST);
getrequest.AddUrlSegment("userid", 14);
}
public async Task <LoginResult> Login(string username, string password, string deviceId = null,
string initialDisplayName = "TensorMatrix")
{
var methodQueryResult = await QueryLoginMethods();
if (!methodQueryResult.SupportedMethods.Any(x => x.Type == "m.login.password"))
{
throw new UnsupportedLoginMethodException("Homeserver does not support password-based login.");
}
var result = await Post.To("/_matrix/client/r0/login")
.Using(RestClient)
.AddBody(new PasswordLoginRequest <MxidIdentifier>
{
Identifier = new MxidIdentifier {
User = username
},
DeviceId = deviceId,
InitialDeviceDisplayName = initialDisplayName,
Password = password
})
.On(400, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res)))
.On(403, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res)))
.On(429, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res)))
.WhenSucceeded(new Action <LoginResult>(r =>
{
MxId = MxId.Parse(r.UserId);
JwtAuthenticator = new JwtAuthenticator(r.AccessToken);
RestClient.Authenticator = JwtAuthenticator;
DeviceId = r.DeviceId;
if (r.WellKnown != null)
{
RestClient.BaseUrl = new Uri(r.WellKnown.HomeServer.BaseUrl);
}
LoggedIn?.Invoke(this, new LoginEventArgs(MxId, r.AccessToken, r.DeviceId));
}))
.Execute <LoginResult>();
return(result);
}
/* public void GivenIHaveJwtAccessToken()
* {
* var client = new RestClient("http://*****:*****@email.com", password = "******" });
* var response = client.ExecutePostAsync(request).GetAwaiter().GetResult();
* var access_token = response.DeserializeResponse()["access_token"];
* var jwtAuth= new JwtAuthenticator(access_token);
* client.Authenticator = jwtAuth;
* var getRequest = new RestRequest("products/{id}", Method.GET);
* getRequest.AddUrlSegment("id", 4);
* var result = client.ExecuteGetAsync<Posts>(getRequest).GetAwaiter().GetResult();
* Assert.That(result.Data.name, Is.EqualTo("Product004"), "name is not correct");
*
* }*/
public void GivenIHaveJwtAccessTokenWithjsonFile()
{
/* var htmlReporter = new ExtentV3HtmlReporter(@"C:\Users\Shanthi\source\repos\RestSharpAPIConsoleApp\RestSharpAPIConsoleApp\ExtentReport.html");
* htmlReporter.Config.Theme = Theme.Dark;
* var extent = new AventStack.ExtentReports.ExtentReports();
* extent.AttachReporter(htmlReporter);
*
* //Feature
*
* var feature = extent.CreateTest<Feature>("GetAccesstoken");
* //Scenario
* var scenario = feature.CreateNode<Scenario>("Get access token");
* //Steps
* scenario.CreateNode<Given>("I have jwt access token");
*
*
* extent.Flush();
*
*/
var client = new RestClient("http://*****:*****@"TestData\Data.json";
//you need to deserilize the object in order to rest perform the operation
var jsonData = JsonConvert.DeserializeObject <user>(File.ReadAllText(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, file)).ToString());
request.AddJsonBody(jsonData);
var response = client.ExecutePostAsync(request).GetAwaiter().GetResult();
var access_token = response.DeserializeResponse()["access_token"];
var jwtAuth = new JwtAuthenticator(access_token);
client.Authenticator = jwtAuth;
var getRequest = new RestRequest("products/{id}", Method.GET);
getRequest.AddUrlSegment("id", 4);
var result = client.ExecuteGetAsync <Posts>(getRequest).GetAwaiter().GetResult();
Assert.That(result.Data.name, Is.EqualTo("Product004"), "name is not correct");
}
public void ShouldNotAuthenticate()
{
// Create a valid token.
const string validSecret = "a valid secret that needs to be at least 16 characters long";
const string invalidSecret = "an invalid secret that needs to be at least 16 characters long";
const string issuer = "example.com";
const string audience = "example.com";
const string username = "******";
var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(validSecret));
var signingCredentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256, SecurityAlgorithms.Sha256Digest);
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, username),
};
var token = new JwtSecurityToken(
issuer: issuer,
audience: audience,
claims: claims,
expires: DateTime.UtcNow.AddSeconds(1), // Expired!
notBefore: DateTime.UtcNow,
signingCredentials: signingCredentials);
var tokenHandler = new JwtSecurityTokenHandler();
var encodedToken = tokenHandler.WriteToken(token);
using (var stream = new MemoryStream())
{
var writer = new DataWriter(stream);
writer.Write($"Token={encodedToken}");
stream.Seek(0, SeekOrigin.Begin);
var authenticator = new JwtAuthenticator(new[] { invalidSecret });
Assert.ThrowsException <SecurityException>(() =>
{
authenticator.Authenticate(stream);
});
}
}
public IActionResult Pay(UserViewModel vm)
{
var request = new RestRequest("api/payment/", Method.POST)
{
RequestFormat = DataFormat.Json
};
request.AddJsonBody(vm);
var accessToken = _userToken;
var authenticator = new JwtAuthenticator(accessToken);
_client.Authenticator = authenticator;
var response = _client.Execute <dynamic>(request);
if (!response.IsSuccessful)
{
return(View("~/Views/Gateway/Unauthorized.cshtml"));
}
return(View("~/Views/Gateway/Success.cshtml"));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllersWithViews();
services.AddSingleton <IRepository, Repository.Repository>();
services.AddSingleton <IAuthenticationService, JwtAuthenticator>();
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(options =>
{
options.RequireHttpsMetadata = false;
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidIssuer = JwtAuthenticator.ISSUER,
ValidateAudience = true,
ValidateLifetime = true,
IssuerSigningKey = JwtAuthenticator.GetSymmetricSecurityKey(),
ValidateIssuerSigningKey = true,
};
});
}
public static List <DataTransferObject> GetData(string token)
{
DataTransferObject result;
List <DataTransferObject> results = new List <DataTransferObject>();
string[] apiCalls = new[]
{
"equipment",
"vehicle"
};
foreach (var apiCall in apiCalls)
{
var clientDestination = new RestClient("https://api-test.abax.cloud/v1/" + apiCall);
var authentication = new JwtAuthenticator(token);
clientDestination.Authenticator = authentication;
var request = new RestRequest(Method.GET);
var response = clientDestination.Execute(request);
if (response.IsSuccessful)
{
response.Content = JValue.Parse(response.Content).ToString(Formatting.Indented);
result = new DataTransferObject();
result.data = response.Content;
result.origin = apiCall;
results.Add(result);
}
else if (!response.IsSuccessful && getFailureCount <= 3)
{
getFailureCount++;
AuthenticateToken.GetToken();
}
}
return(results);
}
public async void getallusers()
{
var act = App.accesstoken;
var Client = new RestClient(ConfigurationManager.AppSettings["api"].ToString());
var authentication = new JwtAuthenticator(act);
Client.Authenticator = authentication;
var request = new RestRequest("api/Customer/getCustomers", Method.GET);
var response = await Client.ExecuteGetTaskAsync <CoreResponse>(request);
var deserialize = new JsonDeserializer();
var output = deserialize.Deserialize <Dictionary <string, string> >(response);
var result = output["data"];
var account = JsonConvert.DeserializeObject <List <Account> >(result);
showusers.ItemsSource = account;
}
public void RequestInURLEncodedFromAndValidateTheResponse(string baseUrlEStoreBaseURL, Method method, string endPointURL, RequestParams requestParams)
{
_settings.MyRestClient = new RestClient(ConfigurationManager.AppSettings[baseUrlEStoreBaseURL]);
if (context.ContainsKey("accessToken"))
{
var authenticator = new JwtAuthenticator(context["accessToken"].ToString());
_settings.MyRestClient.Authenticator = authenticator;
}
if (context.ContainsKey("cookie_token_1") && context.ContainsKey("cookie_token_2"))
{
CookieContainer cookiecon = new CookieContainer();
string[] items = context["cookie_token_1"].ToString().Split('#');
cookiecon.Add(new Cookie(items[0], items[1], items[2], items[3]));
items = context["cookie_token_2"].ToString().Split('#');
cookiecon.Add(new Cookie(items[0], items[1], items[2], items[3]));
_settings.MyRestClient.CookieContainer = cookiecon;
}
//create cookiecon to save cookies in previous response
_settings.MyRestRequest = new RestRequest(ConfigurationManager.AppSettings[endPointURL], method);
foreach (KeyValuePair <string, string> kvPairs in requestParams.Headers)
{
_settings.MyRestRequest.AddHeader(kvPairs.Key, kvPairs.Value);
}
foreach (KeyValuePair <string, string> kvPairs in requestParams.Parameters)
{
_settings.MyRestRequest.AddParameter(kvPairs.Key, kvPairs.Value);
}
foreach (KeyValuePair <string, string> kvPairs in requestParams.QueryParameters)
{
_settings.MyRestRequest.AddQueryParameter(kvPairs.Key, kvPairs.Value);
}
_settings.MyRestResponse = _settings.MyRestClient.ExecuteAsyncRequest(_settings.MyRestRequest).GetAwaiter().GetResult();
context["RestSettings"] = _settings;
}
public void Updates_Auth_Header()
{
var client = new RestClient();
var request = new RestRequest();
var authenticator = new JwtAuthenticator(_expectedAuthHeaderContent);
client.Authenticator = authenticator;
client.Authenticator.Authenticate(client, request);
authenticator.SetBearerToken("second_header_auth_token");
client.Authenticator.Authenticate(client, request);
var paramList = request.Parameters.FindAll(p => p.Name.Equals("Authorization"));
Assert.AreEqual(1, paramList.Count);
var authParam = paramList[0];
Assert.True(authParam.Type == ParameterType.HttpHeader);
Assert.AreNotEqual(_expectedAuthHeaderContent, authParam.Value);
Assert.AreEqual("Bearer second_header_auth_token", authParam.Value);
}
public async Task Updates_Auth_Header()
{
var client = new RestClient();
var request = new RestRequest();
var authenticator = new JwtAuthenticator(_expectedAuthHeaderContent);
client.Authenticator = authenticator;
await client.Authenticator.Authenticate(client, request);
authenticator.SetBearerToken("second_header_auth_token");
await client.Authenticator.Authenticate(client, request);
var paramList = request.Parameters.Where(p => p.Name.Equals(KnownHeaders.Authorization)).ToList();
Assert.Single(paramList);
var authParam = paramList[0];
Assert.True(authParam.Type == ParameterType.HttpHeader);
Assert.NotEqual(_expectedAuthHeaderContent, authParam.Value);
Assert.Equal("Bearer second_header_auth_token", authParam.Value);
}
public void ExecuteAuthenticationwithjson()
{
var client = new RestClient("https://reqres.in/api/");
var request = new RestRequest("login", Method.POST);
var file = @"TestData\Data.json";
request.RequestFormat = DataFormat.Json;
var jsondata = JsonConvert.DeserializeObject <User>(File.ReadAllText(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, file)).ToString());
request.AddJsonBody(jsondata);
var reponse = client.ExecutePostTaskAsync(request).GetAwaiter().GetResult();
var access_token = reponse.DeserializeResponse()["token"];
var jwtAuth = new JwtAuthenticator(access_token);
client.Authenticator = jwtAuth;
var getrequest = new RestRequest("users/{userid}", Method.POST);
getrequest.AddUrlSegment("userid", 14);
}
