public void When_the_file_metadata_is_PUTed()
{
var newDocumentDetails = new Document("a new example document", "a description of the new example document");
var apiCall = new XmlApiCall();
apiCall.SetRequestAuthenticationMechanism(new OAuth2AuthenticationMechanism(Configuration.OAuth2Token));
_response = apiCall.Post(Configuration.ExampleCreateDocUri, newDocumentDetails);
var doc = XmlConverter.FromXml<Document>(_response.Response);
var editUrl = doc.GetLinkFor("edit").Href;
var parentUrl = doc.GetLinkFor("parent").Href;
var putData = new Document("newTitle", "newDescription")
{
Links = new List<Link>
{
new Link
{
Rel = "parent"
,Href = parentUrl
}
}
};
_response = apiCall.Put(editUrl, putData);
}
public void When_the_file_metadata_is_POSTed()
{
var newDocumentDetails = new Document("a new example document", "a description of the new example document");
var apiCall = new JsonApiCall();
apiCall.SetRequestAuthenticationMechanism(new OAuth2AuthenticationMechanism(Configuration.OAuth2Token));
_response = apiCall.Post(Configuration.ExampleCreateDocUri, newDocumentDetails);
}
public static string FormatSearchException(IApiResponse response)
{
return String.Format(
"StatusCode: {0}; Error Code: {1}; Error Message: {2}",
response.StatusCode,
response.Error.Code,
response.Error.Message);
}
public void When_i_request_the_users_details()
{
var apiCall = new SimulatedJsonApiCall();
var simulatedResponse = new SimulatedApiResponse {Response = _simulatedResponse, Status = HttpStatusCode.OK};
apiCall.Response = simulatedResponse;
apiCall.SetRequestAuthenticationMechanism(new OAuth2AuthenticationMechanism(Configuration.OAuth2Token));
_response = apiCall.Get(Configuration.GetTestUserUri);
}
// Authenticate API Key Methods
public bool AuthenticateKey(string apikey, IApiResponse response)
{
if (apikey.Trim().Length < 1)
{
response.Errors.Add(new ApiError("KEY", "Api Key is invalid or missing."));
return false;
}
ApiKey key = MTApp.AccountServices.ApiKeys.FindByKey(apikey);
if (key == null)
{
response.Errors.Add(new ApiError("KEY", "Api Key is invalid or missing."));
return false;
}
if (key.Key != apikey)
{
response.Errors.Add(new ApiError("KEY", "Api Key is invalid or missing."));
return false;
}
if (key.StoreId < 0)
{
response.Errors.Add(new ApiError("KEY", "Api Key is invalid or missing."));
return false;
}
long storeID = key.StoreId;
MTApp.CurrentStore = MTApp.AccountServices.Stores.FindById(storeID);
if (MTApp.CurrentStore == null)
{
response.Errors.Add(new ApiError("STORENOTFOUND", "No store was found at this URL."));
return false;
}
if (MTApp.CurrentStore.Id < 0)
{
response.Errors.Add(new ApiError("STORENOTFOUND2", "No store was found at this URL."));
return false;
}
if (MTApp.CurrentStore.Status == MerchantTribe.Commerce.Accounts.StoreStatus.Deactivated)
{
response.Errors.Add(new ApiError("STOREDISABLED", "Store is not active. Contact an Administrator for Assistance"));
return false;
}
return true;
}
public void ProcessRequest(IApiRequest request, IApiResponse response)
{
if (string.IsNullOrWhiteSpace(request.Path)) return;
ApiPath apiPath;
ApiConfig config = ApiConfig.GetInstance();
if (!config.RequestPathCollection.TryGetValue(request.Path, out apiPath)) return;
if (apiPath == null) return;
var apiInstance = Activator.CreateInstance(apiPath.ServiceType);
var method = apiPath.ServiceType.GetMethod(apiPath.Operation);
var paraTypes = apiPath.Parameters;
List<object> parameters = null;
if (paraTypes != null)
{
parameters = paraTypes.Select(paraType => GetParameter(paraType, request)).ToList();
}
var _response = method.Invoke(apiInstance, parameters == null ? null : parameters.ToArray());
if (_response == null) throw new ArgumentNullException("request");
response.Content = _response;
response.ContentType = "text/json";
}
/// <summary>
/// Checks if the Api Response Status Failed
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="apiResponse"></param>
/// <returns></returns>
public static bool Failed <T>(this IApiResponse <T> apiResponse)
{
return(apiResponse.Status == ApiResponseStatus.Failed);
}
public async Task <Dictionary <string, ClanHistory> > GetClanHistoryWeeklyAsync(string clanTag, ClanHistoryFilter clanHistoryFilter = null)
{
IApiResponse <Dictionary <string, ClanHistory> > apiResponse = await GetClanHistoryWeeklyResponseAsync(clanTag, clanHistoryFilter);
return(apiResponse.Model);
}
public ApiResponseList(string name, IApiResponse[] apiResponse)
: this(name, apiResponse.ToList())
{
}
public void SetUp()
{
//Arrange
#region "Arrange"
//Creating Dummy Product List
_ProductList = new List <Product>
{
new Product {
Id = 1,
ProdSname = "Test Product 1",
ProdLname = "Test Product 1",
ProdCode = "test1",
GmidUnit = 1,
MinQty = 10,
ReorderQty = 10,
ActiveStatus = "A",
DeleteStatus = "A"
},
new Product {
Id = 2,
ProdSname = "Test Product 2",
ProdLname = "Test Product 2",
ProdCode = "test2",
GmidUnit = 1,
MinQty = 10,
ReorderQty = 10,
ActiveStatus = "A",
DeleteStatus = "A"
},
new Product {
Id = 3,
ProdSname = "Test Product 3",
ProdLname = "Test Product 3",
ProdCode = "test3",
GmidUnit = 1,
MinQty = 10,
ReorderQty = 10,
ActiveStatus = "A",
DeleteStatus = "A"
},
new Product {
Id = 4,
ProdSname = "Test Product 4",
ProdLname = "Test Product 4",
ProdCode = "test4",
GmidUnit = 1,
MinQty = 10,
ReorderQty = 10,
ActiveStatus = "A",
DeleteStatus = "A"
}
};
//logger
_mockLogger = new Mock <ILogger <ProductController> >();
// Mock the API Response
_mockResponse = new ApiResponse();
//Mapper Configuration
var mappingConfig = new MapperConfiguration(mc =>
{
mc.AddProfile(new MockMappingProfile());
});
_mockMapper = mappingConfig.CreateMapper();
#endregion
//Setup MockProductManager
mockProductManager = new MockProductManager();
}
private async Task <bool> SendTracesAsync(ArraySegment <byte> traces, int numberOfTraces, IApiRequest request, bool finalTry)
{
IApiResponse response = null;
try
{
try
{
_statsd?.Increment(TracerMetricNames.Api.Requests);
response = await request.PostAsync(traces).ConfigureAwait(false);
}
catch
{
// count only network/infrastructure errors, not valid responses with error status codes
// (which are handled below)
_statsd?.Increment(TracerMetricNames.Api.Errors);
throw;
}
if (_statsd != null)
{
// don't bother creating the tags array if trace metrics are disabled
string[] tags = { $"status:{response.StatusCode}" };
// count every response, grouped by status code
_statsd?.Increment(TracerMetricNames.Api.Responses, tags: tags);
}
// Attempt a retry if the status code is not SUCCESS
if (response.StatusCode < 200 || response.StatusCode >= 300)
{
if (finalTry)
{
try
{
string responseContent = await response.ReadAsStringAsync().ConfigureAwait(false);
Log.Error <int, string>("Failed to submit traces with status code {StatusCode} and message: {ResponseContent}", response.StatusCode, responseContent);
}
catch (Exception ex)
{
Log.Error <int>(ex, "Unable to read response for failed request with status code {StatusCode}", response.StatusCode);
}
}
return(false);
}
try
{
var tracer = _tracer ?? Tracer.Instance;
if (tracer.AgentVersion == null)
{
var version = response.GetHeader(AgentHttpHeaderNames.AgentVersion);
tracer.AgentVersion = version ?? string.Empty;
}
if (response.ContentLength != 0 && Tracer.Instance.Sampler != null)
{
var responseContent = await response.ReadAsStringAsync().ConfigureAwait(false);
if (responseContent != _cachedResponse)
{
var apiResponse = JsonConvert.DeserializeObject <ApiResponse>(responseContent);
tracer.Sampler.SetDefaultSampleRates(apiResponse?.RateByService);
_cachedResponse = responseContent;
}
}
}
catch (Exception ex)
{
Log.Error(ex, "Traces sent successfully to the Agent at {AgentEndpoint}, but an error occurred deserializing the response.", _apiRequestFactory.Info(_tracesEndpoint));
}
}
finally
{
response?.Dispose();
}
return(true);
}
private static string StartSpidering()
{
Console.WriteLine("Spider: " + _target);
_apiResponse = _api.spider.scan(_apikey, _target, "");
string scanid = ((ApiResponseElement)_apiResponse).Value;
return scanid;
}
public HomeController(IApiResponse iapiResponse, IMapper imapper)
{
_iapiResponse = iapiResponse;
_imapper = imapper;
}
private static string CreateNewUser(string contextId, string userName)
{
_apiResponse = _api.users.newUser(_apikey, contextId, userName);
string userId = ((ApiResponseElement)_apiResponse).Value;
return userId;
}
private static void SetUserNameAndPassword(string contextId, string userId, string userName, string password)
{
string userAuthenticationConfigFormat = "username={0}&password={1}";
string userAuthenticationConfig = string.Format(userAuthenticationConfigFormat, userName, password);
_apiResponse = _api.users.setAuthenticationCredentials(_apikey, contextId, userId, userAuthenticationConfig);
if ("OK" == ((ApiResponseElement)_apiResponse).Value)
Console.WriteLine("User credentials set");
}
public void OnHttpRequest(ApiReader reader, IApiResponse response)
{
throw new NotImplementedException();
}
/// <summary>
/// Checks if the Api Response Status Succeeded
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="apiResponse"></param>
/// <returns></returns>
public static bool Succeeded <T>(this IApiResponse <T> apiResponse)
{
return(apiResponse.Status == ApiResponseStatus.Succeeded);
}
public BadResponseException(IApiResponse responseMessage) : base()
{
ResponseMessage = responseMessage;
StatusCode = HttpStatusCode.InternalServerError;
}
public BadResponseException(string message, HttpStatusCode statusCode, IApiResponse responseMessage) : base(message)
{
ResponseMessage = responseMessage;
StatusCode = statusCode;
}
public BadResponseException(IApiResponse responseMessage) : base()
{
ResponseMessage = responseMessage;
}
public BadResponseException(string message, IApiResponse responseMessage) : base(message)
{
ResponseMessage = responseMessage;
}
public FakeHttpConnection(IApiResponse response = null, IHalKitConfiguration config = null)
{
_response = response;
Configuration = config ?? new HalKitConfiguration(new Uri("http://foo.api.com"));
}
public SslConnectionRequiredException(IApiResponse response, ApiError apiError) : base(response, apiError)
{
}
/// <summary>
///
/// </summary>
/// <param name="clientId"></param>
/// <returns></returns>
public async Task <IdentityServer4.Models.Client> FindClientByIdAsync(string clientId)
{
if (clientId.Length < 2)
{
return(null);
}
// For in memory trusted clients
var inMemoryClient = FindClientByIdInMemoryAsync(clientId);
if (inMemoryClient != null)
{
return(inMemoryClient);
}
var apiInfo = new ApiInfo("account", method: "query");
var pathWithQuery = $"/service/account?username={clientId}";
bool requiresSecret = true;
//Not email and not phone number
if (!clientId.Contains('@') && clientId.Length > 15)
{
requiresSecret = true;
pathWithQuery = $"/service/account?userId={clientId}";
}
IApiResponse <AuthUser> response = await _apiClient.GetAsync <AuthUser>(apiInfo, pathWithQuery);
if (response.IsError || response.Content == null)
{
return(null);
}
var client = response.Content;
//Simplification of moderator rights. All of these claims will be given the 'moderator' claim
//Even though not secure, it only applies to moderators
List <string> moderatorClaims = new List <string> {
"moderator", "callcentre", "sales", "admin", "webmaster"
};
var userClaims = new List <Claim>();
// sub claim should be reserved for userId to conform with industry standards
// roles currently persisted as sub claims
// here assigning them to role claims in principal
if (client.Claims.Any(tbl => (tbl.Type == JwtClaimTypes.Role || tbl.Type == JwtClaimTypes.Subject) && moderatorClaims.Contains(tbl.Value)))
{
userClaims.Add(new Claim(JwtClaimTypes.Role, "moderator"));
}
if (client.Claims.Any(tbl => (tbl.Type == JwtClaimTypes.Role || tbl.Type == JwtClaimTypes.Subject) && tbl.Value == "root"))
{
userClaims.Add(new Claim(JwtClaimTypes.Role, "root"));
}
var user = new IdentityServer4.Models.Client
{
ClientId = client.UserName,
ClientSecrets = new List <Secret>()
{
new Secret()
{
Value = client.PasswordHash
}
},
AllowedGrantTypes = GrantTypes.ClientCredentials,
RequireClientSecret = requiresSecret,
AllowedScopes = { "account" },
Claims = userClaims,
AccessTokenLifetime = 604800,
ClientClaimsPrefix = string.Empty
};
// sub claim is assigned userId instead
user.Claims.Add(new Claim(JwtClaimTypes.Subject, client.Id));
user.Claims.Add(new Claim(JwtClaimTypes.PreferredUserName, client.UserName));
user.Claims.Add(new Claim(ClaimTypes.Email, client.Email));
IApiResponse <ApiUserModel> userResponse = await _apiClient.GetAsync <ApiUserModel>(new ApiInfo("user", "query"), $"{Backends.User}/{client.Id}", userClaim : client.Id);
//Only active accounts may log in
if (userResponse.IsError || userResponse.Content == null || userResponse.Content.State != "Active")
{
return(null);
}
var package = userResponse.Content.Package;
var source = userResponse.Content.ReportingSource;
var group = userResponse.Content.Group;
if (!string.IsNullOrWhiteSpace(source))
{
user.Claims.Add(new Claim("source", source));
}
if (!string.IsNullOrWhiteSpace(group))
{
user.Claims.Add(new Claim("group", group));
}
if (!string.IsNullOrWhiteSpace(package))
{
user.Claims.Add(new Claim("package", package));
}
return(user);
}
private static string StartActiveScanning()
{
Console.WriteLine("Active Scanner: " + _target);
_apiResponse = _api.ascan.scan(_apikey, _target, "", "", "", "", "");
string activeScanId = ((ApiResponseElement)_apiResponse).Value;
return activeScanId;
}
public UserAgentRequiredException(IApiResponse response, ApiError apiError) : base(response, apiError)
{
}
// Write an API response out serialized as JSON
public void WriteJson(IApiResponse api)
{
try
{
this.WriteText(JsonConvert.SerializeObject(api, Injection.Kernel.Get<IServerSettings>().JsonFormatting), "application/json");
}
catch (Exception e)
{
logger.Error(e);
}
}
public RequestEventArgs(IApiRequest request, IApiResponse response) : base()
{
this.Request = request;
this.Response = response;
}
public OrganizationToken(IEndpoint endpoint, IPartnerAccessToken partnerAccessToken, IApiResponse response)
{
m_endpoint = endpoint;
m_partnerAccessToken = partnerAccessToken;
m_response = response;
}
public RequestFailureEventArgs(IApiRequest request, IApiResponse response, RequestFailureReason reason, bool foregroundAction) : base(request, response)
{
this.FailureReason = reason;
this.ForegroundAction = foregroundAction;
}
private async Task <bool> SendTracesAsync(Span[][] traces, IApiRequest request)
{
IApiResponse response = null;
try
{
try
{
_statsd?.Increment(TracerMetricNames.Api.Requests);
response = await request.PostAsync(traces, _formatterResolver).ConfigureAwait(false);
}
catch
{
// count only network/infrastructure errors, not valid responses with error status codes
// (which are handled below)
_statsd?.Increment(TracerMetricNames.Api.Errors);
throw;
}
if (_statsd != null)
{
// don't bother creating the tags array if trace metrics are disabled
string[] tags = { $"status:{response.StatusCode}" };
// count every response, grouped by status code
_statsd?.Increment(TracerMetricNames.Api.Responses, tags: tags);
}
// Attempt a retry if the status code is not SUCCESS
if (response.StatusCode < 200 || response.StatusCode >= 300)
{
return(false);
}
try
{
if (response.ContentLength != 0 && Tracer.Instance.Sampler != null)
{
var responseContent = await response.ReadAsStringAsync().ConfigureAwait(false);
if (responseContent != _cachedResponse)
{
var apiResponse = JsonConvert.DeserializeObject <ApiResponse>(responseContent);
Tracer.Instance.Sampler.SetDefaultSampleRates(apiResponse?.RateByService);
_cachedResponse = responseContent;
}
}
}
catch (Exception ex)
{
Log.Error(ex, "Traces sent successfully to the Agent at {0}, but an error occurred deserializing the response.", _tracesEndpoint);
}
}
finally
{
response?.Dispose();
}
return(true);
}
public RequestFailureEventArgs(IApiRequest request, IApiResponse response, RequestFailureReason reason, bool foregroundAction, Action onResume) : this(request, response, reason, foregroundAction)
{
this.OnResume = onResume;
}
//public async Task<IApiResponse<List<ClanSummary>>> GetTopClansResponseAsync(LocationsEnum locationEnum = LocationsEnum.None,
// ClanSummaryFilter clanSummaryFilter = null)
//{
// var apiResponse =
// await _restApiClient.GetApiResponseAsync<List<ClanSummary>>(UrlPathBuilder.GetTopClansUrl(locationEnum),
// clanSummaryFilter?.ToQueryParams());
// return apiResponse;
//}
//public async Task<IApiResponse<List<Clan>>> GetPopularPlayersResponseAsync(ClanFilter clanFilter = null)
//{
// var apiResponse =
// await _restApiClient.GetApiResponseAsync<List<Clan>>(UrlPathBuilder.PopularClansUrl,
// clanFilter?.ToQueryParams());
// return apiResponse;
//}
//public async Task<IApiResponse<List<ClanSummary>>> GetTopWarClanWarsResponseAsync(
// LocationsEnum locationEnum = LocationsEnum.None, ClanSummaryFilter clanSummaryFilter = null)
//{
// var apiResponse =
// await _restApiClient.GetApiResponseAsync<List<ClanSummary>>(
// UrlPathBuilder.GetTopWarClanWarsUrl(locationEnum), clanSummaryFilter?.ToQueryParams());
// return apiResponse;
//}
public async Task <List <ClanSummary> > SearchClanAsync(ClanSummaryFilter clanSummaryFilter = null)
{
IApiResponse <List <ClanSummary> > apiResponse = await SearchClanResponseAsync(clanSummaryFilter);
return(apiResponse.Model);
}
public async Task <IActionResult> GetAllShoppingListsAsync()
{
IApiResponse response = await _service.GetAllAsync();
return(new ObjectResult(response));
}
public static bool IsResource(this IApiResponse response)
{
return(response is IApiItemResponse || response is IApiCollectionResponse);
}
private async Task <IdentityServer4.Models.Client> FindClientByIdAsync(string clientId)
{
if (clientId.Length < 2)
{
return(null);
}
if (ClientDates.ContainsKey(clientId))
{
if (ClientDates[clientId] > DateTime.Now.AddHours(-1))
{
if (Clients.TryGetValue(clientId, out var cacheClient))
{
return(cacheClient);
}
}
}
var apiInfo = new ApiInfo("account", method: "query");
string pathWithQuery = $"/service/account/?token={clientId}";
IApiResponse <AuthUser> response = await _apiClient.GetAsync <AuthUser>(apiInfo, pathWithQuery);
if (response.IsError || response.Content == null)
{
return(null);
}
var client = response.Content;
var userClaims = new List <Claim>();
foreach (var claim in client.Claims)
{
if (claim.Type == JwtClaimTypes.Role)
{
userClaims.Add(new Claim(JwtClaimTypes.Role, claim.Value));
}
else if (claim.Type == JwtClaimTypes.Subject && claim.Value != client.Id)
{
userClaims.Add(new Claim(JwtClaimTypes.Role, claim.Value));
}
else if (claim.Type != JwtClaimTypes.Subject)
{
userClaims.Add(new Claim(claim.Type, claim.Value));
}
}
userClaims.Add(new Claim(JwtClaimTypes.Subject, client.Id));
userClaims.Add(new Claim(JwtClaimTypes.PreferredUserName, client.UserName));
userClaims.Add(new Claim(JwtClaimTypes.Email, client.Email));
IdentityServer4.Models.Client user = new IdentityServer4.Models.Client
{
ClientId = client.UserName,
ClientSecrets = new List <Secret>()
{
new Secret()
{
Value = client.PasswordHash
}
},
AllowedGrantTypes = GrantTypes.ClientCredentials,
RequireClientSecret = false,
AllowedScopes = { "account" },
Claims = userClaims
};
IApiResponse <ApiUserModel> userResponse = await _apiClient.GetAsync <ApiUserModel>(new ApiInfo("user", "query"), $"{Backends.User}/{client.Id}", userClaim : client.Id);
if (userResponse.IsError || userResponse.Content == null)
{
return(null);
}
var package = userResponse.Content.Package;
var source = userResponse.Content.ReportingSource;
var group = userResponse.Content.Group;
if (!string.IsNullOrWhiteSpace(source))
{
user.Claims.Add(new Claim("source", source));
}
if (!string.IsNullOrWhiteSpace(group))
{
user.Claims.Add(new Claim("group", group));
}
if (!string.IsNullOrWhiteSpace(package))
{
user.Claims.Add(new Claim("package", package));
}
Clients.TryAdd(clientId, user);
ClientDates.TryAdd(clientId, DateTime.Now);
foreach (var pair in ClientDates)
{
if (pair.Value < DateTime.Now.AddHours(-1))
{
Clients.TryRemove(pair.Key, out _);
ClientDates.TryRemove(pair.Key, out _);
}
}
return(user);
}
public InvalidSellerListingActionException(IApiResponse response, ApiError error) : base(response, error)
{
}
private static void EnableUser(string contextId, string userId)
{
_apiResponse = _api.users.setUserEnabled(_apikey, contextId, userId, "true");
if ("OK" == ((ApiResponseElement)_apiResponse).Value)
Console.WriteLine("user enabled");
}
private static bool IsFormsAuthenticationSupported()
{
bool isFormsAuthenticatedSupported = false;
string formsAuthenticationString = "formBasedAuthentication";
_apiResponse = _api.authentication.getSupportedAuthenticationMethods();
Console.WriteLine("Supported authentication methods are:" + Environment.NewLine);
foreach (var authenticationMethod in ((ApiResponseList)_apiResponse).List)
{
string authenticationMethodName = ((ApiResponseElement)authenticationMethod).Value;
if (formsAuthenticationString.IndexOf(authenticationMethodName, StringComparison.InvariantCultureIgnoreCase) > -1)
{
isFormsAuthenticatedSupported = true;
}
Console.WriteLine(authenticationMethodName + Environment.NewLine);
}
return isFormsAuthenticatedSupported;
}
private static void SetFormsBasedAuthentication(string contextId, string formBasedAuthenticationConfiguration)
{
_apiResponse = _api.authentication.setAuthenticationMethod(_apikey, contextId, "formBasedAuthentication", formBasedAuthenticationConfiguration);
if ("OK" == ((ApiResponseElement)_apiResponse).Value)
Console.WriteLine("formBasedAuthentication is configured");
}
private static void EnableForcedUserMode()
{
_apiResponse = _api.forcedUser.setForcedUserModeEnabled(_apikey, true);
}
public void When_i_request_the_users_details()
{
var apiCall = new JsonApiCall();
apiCall.SetRequestAuthenticationMechanism(new OAuth2AuthenticationMechanism(Configuration.OAuth2Token));
_response = apiCall.Get(Configuration.GetTestUserUri);
}
private static void IncludeUrlToContext(string contextName, string urlToIncludeInContext)
{
_apiResponse = _api.context.includeInContext(_apikey, contextName, urlToIncludeInContext);
if ("OK" == ((ApiResponseElement)_apiResponse).Value)
Console.WriteLine("{0} included to context {1}", urlToIncludeInContext, contextName);
}
private static void EnableForcedUserMode()
{
_apiResponse = _api.forcedUser.setForcedUserModeEnabled(true);
}
private static void SetASpecificForcedUser(string contextId, string userId)
{
_apiResponse = _api.forcedUser.setForcedUser(_apikey, contextId, userId);
}
private static void SetASpecificForcedUser(string contextId, string userId)
{
_apiResponse = _api.forcedUser.setForcedUser(contextId, userId);
}
private static void SetLoggedInIndicatorForFormsBasedAuthentication(string contextId)
{
string loggedInIndicator = @"\Q<form action=""/SqliModernApp/Account/LogOff"" id=""logoutForm"" method=""post"">\E";
_apiResponse = _api.authentication.setLoggedInIndicator(_apikey, contextId, loggedInIndicator);
if ("OK" == ((ApiResponseElement)_apiResponse).Value)
Console.WriteLine("loggedInIndicator is set");
}
/// <summary>
/// Asserts that request was successful.
/// </summary>
/// <param name="response">API response object</param>
protected static void AssertRequestWasSuccessful(IApiResponse response)
{
Assert.True(response.Successful);
Assert.False(response.WasCancelled);
Assert.Null(response.ThrownException);
}
private static void ShutdownZAP()
{
_apiResponse = _api.core.shutdown("");
if ("OK" == ((ApiResponseElement)_apiResponse).Value)
Console.WriteLine("ZAP shutdown success " + _target);
}
/// <summary> /// Gets a response object to be set on the returned entity. /// </summary> /// <param name="response">The API response.</param> /// <returns>An object to be set on the returned entity.</returns> protected override object GetEntityResponse(IApiResponse response) => new GetSwiftResponse(response);
private static void StartAjaxSpidering()
{
Console.WriteLine("Ajax Spider: " + _target);
_apiResponse = _api.ajaxspider.scan(_apikey, _target, "");
if ("OK" == ((ApiResponseElement)_apiResponse).Value)
Console.WriteLine("Ajax Spider started for " + _target);
}
public static void PrintResults(IApiResponse<SearchQueryResult> searchResults)
{
if (searchResults.IsSuccess)
{
List<SearchQueryRecord> results = searchResults.Body.Records.ToList();
for (int i = 0; i < 10; i++)
{
Console.WriteLine();
Console.WriteLine(String.Format("\tScore: {0} ", results[i].Score));
foreach (var prop in results[i].Properties)
{
Console.WriteLine("\t" + prop.Key + " " + prop.Value);
}
}
Console.WriteLine();
}
}
private static string CreateContext(string contextName)
{
_apiResponse = _api.context.newContext(_apikey, contextName);
string contextId = ((ApiResponseElement)_apiResponse).Value;
Console.WriteLine("{0} context created with id {1}", contextName, contextId);
return contextId;
}
public ValidationFailedException(IApiResponse response, ApiError apiError) : base(response, apiError)
{
}
