/// <summary>
/// Business Search call for Trulioo API Client V1
/// </summary>
/// <param name="request"> Request object containing parameters to search for </param>
/// <returns> Contains the List of possible businesses from search </returns>
public async Task <BusinessSearchResponse> BusinessSearchAsync(BusinessSearchRequest request)
{
var resource = new ResourceName("search");
var response = await _context.PostAsync <BusinessSearchResponse>(_businessNamespace, resource, request).ConfigureAwait(false);
return(response);
}
public async Task <BusinessSearchResponse> BusinessSearchAsync(BusinessSearchRequest request)
{
ResourceName resource = new("search");
BusinessSearchResponse response = await this._context.PostAsync <BusinessSearchResponse>(ns : this._businessNamespace, resource : resource, content : request);
return(response);
}
public async Task BusinessSearchTest(BusinessSearchRequest request, BusinessSearchResponse expectedResponse)
{
using (var client = new TruliooApiClient(new Context(_username, _password)
{
Host = _hostEndpoint
}))
{
var response = await client.Business.BusinessSearchAsync(request);
Assert.Equal(expectedResponse.Record.RecordStatus, response.Record.RecordStatus);
Assert.Equal(expectedResponse.CountryCode, response.CountryCode);
Assert.Equal(expectedResponse.Record.DatasourceResults.Count(), response.Record.DatasourceResults.Count());
List <string> expectedDatasourcesNames = expectedResponse.Record.DatasourceResults.Select(x => x.DatasourceName).ToList();
List <string> actualDatasourceNames = response.Record.DatasourceResults.Select(x => x.DatasourceName).ToList();
Assert.True(expectedDatasourcesNames.All(actualDatasourceNames.Contains));
List <string> expectedBusinessNameResults = expectedResponse.Record.DatasourceResults.SelectMany(datasource => datasource.Results.Select(result => result.BusinessName)).ToList();
List <string> actualBusinessNameResults = response.Record.DatasourceResults.SelectMany(datasource => datasource.Results.Select(result => result.BusinessName)).ToList();
Assert.Equal(expectedBusinessNameResults.Count(), actualBusinessNameResults.Count());
Assert.True(expectedBusinessNameResults.All(actualBusinessNameResults.Contains));
List <string> expectedBusinessNumberResults = expectedResponse.Record.DatasourceResults.SelectMany(datasource => datasource.Results.Select(result => result.BusinessRegistrationNumber)).ToList();
List <string> actualBusinessNumberResults = response.Record.DatasourceResults.SelectMany(datasource => datasource.Results.Select(result => result.BusinessRegistrationNumber)).ToList();
Assert.Equal(expectedBusinessNumberResults.Count(), actualBusinessNumberResults.Count());
Assert.True(expectedBusinessNumberResults.All(actualBusinessNumberResults.Contains));
}
}
public async Task BusinessSearchTest(BusinessSearchRequest request, BusinessSearchResponse expectedResponse)
{
using (var client = Common.Basefact.GetTruliooKYBClient())
{
var response = await client.Business.BusinessSearchAsync(request);
Assert.Equal(expectedResponse.Record.RecordStatus, response.Record.RecordStatus);
Assert.Equal(expectedResponse.CountryCode, response.CountryCode);
Assert.Equal(expectedResponse.Record.DatasourceResults.Count(), response.Record.DatasourceResults.Count());
List <string> expectedDatasourcesNames = expectedResponse.Record.DatasourceResults.Select(x => x.DatasourceName).ToList();
List <string> actualDatasourceNames = response.Record.DatasourceResults.Select(x => x.DatasourceName).ToList();
Assert.True(expectedDatasourcesNames.All(actualDatasourceNames.Contains));
List <string> expectedBusinessNameResults = expectedResponse.Record.DatasourceResults.SelectMany(datasource => datasource.Results.Select(result => result.BusinessName)).ToList();
List <string> actualBusinessNameResults = response.Record.DatasourceResults.SelectMany(datasource => datasource.Results.Select(result => result.BusinessName)).ToList();
Assert.Equal(expectedBusinessNameResults.Count(), actualBusinessNameResults.Count());
Assert.True(expectedBusinessNameResults.All(actualBusinessNameResults.Contains));
List <string> expectedBusinessNumberResults = expectedResponse.Record.DatasourceResults.SelectMany(datasource => datasource.Results.Select(result => result.BusinessRegistrationNumber)).ToList();
List <string> actualBusinessNumberResults = response.Record.DatasourceResults.SelectMany(datasource => datasource.Results.Select(result => result.BusinessRegistrationNumber)).ToList();
Assert.Equal(expectedBusinessNumberResults.Count(), actualBusinessNumberResults.Count());
Assert.True(expectedBusinessNumberResults.All(actualBusinessNumberResults.Contains));
}
}
public void EqualsObjectCastTest()
{
bool acceptTruliooTermsAndConditions = true;
BusinessSearchRequest businessSearchRequest = new BusinessSearchRequest(countryCode: "test-countryCode", acceptTruliooTermsAndConditions: acceptTruliooTermsAndConditions);
object obj = new BusinessSearchRequest(countryCode: "test-countryCode", acceptTruliooTermsAndConditions: acceptTruliooTermsAndConditions);
Assert.True(businessSearchRequest.Equals(obj));
}
public void EqualsTest()
{
bool acceptTruliooTermsAndConditions = true;
BusinessSearchRequest acceptTruliooTermsAndConditions1 = new BusinessSearchRequest(countryCode: "test-countryCode", acceptTruliooTermsAndConditions: acceptTruliooTermsAndConditions);
Assert.Equal(acceptTruliooTermsAndConditions1, acceptTruliooTermsAndConditions1);
Assert.Equal(acceptTruliooTermsAndConditions1, new BusinessSearchRequest(countryCode: "test-countryCode", acceptTruliooTermsAndConditions: acceptTruliooTermsAndConditions));
Assert.NotEqual(acceptTruliooTermsAndConditions1, new BusinessSearchRequest(countryCode: "test-countryCode", acceptTruliooTermsAndConditions: false));
Assert.False(acceptTruliooTermsAndConditions1.Equals(null));
}
public async Task <string> BusinessSearch(BusinessSearchRequest Request, int UserID, int ProductID)
{
bool result = false;
string itNumber = string.Empty;
try
{
var config = new MapperConfiguration(
cfg =>
{
cfg.CreateMap <BusinessSearchRequest, BusinessSearch>();
}
);
var mapper = config.CreateMapper();
var business = mapper.Map <BusinessSearch>(Request);
business.SubscriberCode = subNo;
business.SecurityCode = securityCode;
var response = await client.BusinessSearchAsync(business);
result = response.ErrorCode == null ? true : false;
if (result)
{
if (response.FirstResponse != null)
{
itNumber = response.FirstResponse.ITNumber;
}
}
else
{
log.LogError(UserID.ToString(), "DataSolution.Services", "BMSRetrieveAlert", response.ErrorCode + ":" + response.ErrorMessage);
}
//log transaction
endDate = DateTime.Now;
transData = new TransactionModel.TransactionData
{
EndDate = endDate,
IsSuccessful = result,
Message = response.ErrorMessage,
ProductID = ProductID,
StartDate = startDate,
UserID = Convert.ToInt32(UserID)
};
SaveTransaction(transData);
}
catch (Exception ex)
{
log.LogError(UserID.ToString(), "DataSolutions.Web", "TransUnionCommercialService.BusinessSearch", ex.Message);
}
return(itNumber);
}
public async Task <JsonResult> ProcessCommercialRequest(string ReportType, string SearchCriteria, string SearchValue, string EnquiryReason)
{
bool result = false;
UserModel user = Session["User"] as UserModel;
BusinessSearchRequest request = new BusinessSearchRequest();
request.SearchType = SearchCriteria;
switch (SearchCriteria.Trim())
{
case "BankAccountNo":
request.BankAccount = SearchValue;
break;
case "DunsNo":
request.DunsNumber = SearchValue;
break;
case "ITNo":
request.ITNumber = SearchValue;
break;
case "Name":
request.SubjectName = SearchValue;
break;
case "RegNo":
request.RegistrationNo = SearchValue;
break;
case "TradingNo":
request.RegistrationNo = SearchValue;
break;
case "VatNo":
request.VatNumber = SearchValue;
break;
default:
break;
}
string companyITNum = await new Services.TransUnionCommercialService().BusinessSearch(request, user.UserID, 2);
if (ReportType == "ONLINE")
{
}
else if (ReportType == "INV")
{
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
public void GetHashcodeTest()
{
List <string> consentForDataSources = new List <string> {
"value 1", "value 2"
};
BusinessSearchRequest businessSearchRequest1 = new BusinessSearchRequest(countryCode: "test-countryCode");
businessSearchRequest1.AcceptTruliooTermsAndConditions = true;
businessSearchRequest1.CallBackUrl = "test-callBackUrl";
businessSearchRequest1.Timeout = 1000;
businessSearchRequest1.ConsentForDataSources = consentForDataSources;
businessSearchRequest1.Business = new BusinessSearchRequestBusinessSearchModel();
BusinessSearchRequest businessSearchRequest2 = new BusinessSearchRequest(countryCode: "test-countryCode");
businessSearchRequest2.AcceptTruliooTermsAndConditions = true;
businessSearchRequest2.CallBackUrl = "test-callBackUrl";
businessSearchRequest2.Timeout = 1000;
businessSearchRequest2.ConsentForDataSources = consentForDataSources;
businessSearchRequest2.Business = new BusinessSearchRequestBusinessSearchModel();
Assert.Equal(businessSearchRequest1.GetHashCode(), businessSearchRequest2.GetHashCode());
}
public BusinessSearchRequestTests()
{
businessSearchRequest = new BusinessSearchRequest(countryCode: "test-countryCode");
}
/// <summary>
/// Search Calling this method will perform a business search.
/// </summary>
/// <exception cref="Trulioo.SDK.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="mode">trial or live</param>
/// <param name="businessSearchRequest"></param>
/// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
/// <returns>Task of ApiResponse (BusinessSearchResponse)</returns>
public async System.Threading.Tasks.Task <Trulioo.SDK.Client.ApiResponse <BusinessSearchResponse> > SearchWithHttpInfoAsync(string mode, BusinessSearchRequest businessSearchRequest, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
{
// verify the required parameter 'mode' is set
if (mode == null)
{
throw new Trulioo.SDK.Client.ApiException(400, "Missing required parameter 'mode' when calling BusinessApi->Search");
}
// verify the required parameter 'businessSearchRequest' is set
if (businessSearchRequest == null)
{
throw new Trulioo.SDK.Client.ApiException(400, "Missing required parameter 'businessSearchRequest' when calling BusinessApi->Search");
}
Trulioo.SDK.Client.RequestOptions localVarRequestOptions = new Trulioo.SDK.Client.RequestOptions();
String[] _contentTypes = new String[] {
"application/json",
"text/json"
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json",
"text/json"
};
var localVarContentType = Trulioo.SDK.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
if (localVarContentType != null)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
}
var localVarAccept = Trulioo.SDK.Client.ClientUtils.SelectHeaderAccept(_accepts);
if (localVarAccept != null)
{
localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
}
localVarRequestOptions.PathParameters.Add("mode", Trulioo.SDK.Client.ClientUtils.ParameterToString(mode)); // path parameter
localVarRequestOptions.Data = businessSearchRequest;
// authentication (ApiKeyAuth) required
if (!String.IsNullOrEmpty(this.Configuration.GetApiKeyWithPrefix("x-trulioo-api-key")))
{
localVarRequestOptions.HeaderParameters.Add("x-trulioo-api-key", this.Configuration.GetApiKeyWithPrefix("x-trulioo-api-key"));
}
// make the HTTP request
var localVarResponse = await this.AsynchronousClient.PostAsync <BusinessSearchResponse>("/{mode}/business/v1/search", localVarRequestOptions, this.Configuration, cancellationToken).ConfigureAwait(false);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("Search", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Search Calling this method will perform a business search.
/// </summary>
/// <exception cref="Trulioo.SDK.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="mode">trial or live</param>
/// <param name="businessSearchRequest"></param>
/// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
/// <returns>Task of BusinessSearchResponse</returns>
public async System.Threading.Tasks.Task <BusinessSearchResponse> SearchAsync(string mode, BusinessSearchRequest businessSearchRequest, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
{
Trulioo.SDK.Client.ApiResponse <BusinessSearchResponse> localVarResponse = await SearchWithHttpInfoAsync(mode, businessSearchRequest, cancellationToken).ConfigureAwait(false);
return(localVarResponse.Data);
}
/// <summary>
/// Search Calling this method will perform a business search.
/// </summary>
/// <exception cref="Trulioo.SDK.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="mode">trial or live</param>
/// <param name="businessSearchRequest"></param>
/// <returns>BusinessSearchResponse</returns>
public BusinessSearchResponse Search(string mode, BusinessSearchRequest businessSearchRequest)
{
Trulioo.SDK.Client.ApiResponse <BusinessSearchResponse> localVarResponse = SearchWithHttpInfo(mode, businessSearchRequest);
return(localVarResponse.Data);
}
