public static List <ApplicationAPIModel> CompareAPIModels(ApplicationAPIModel learnedModel, List <ApplicationAPIModel> existingAPIs)
{
if (learnedModel.APIType == ApplicationAPIUtils.eWebApiType.REST)
{
// Filter matching APIs based on Request Http Version
existingAPIs = existingAPIs.Where(m => m.ReqHttpVersion == learnedModel.ReqHttpVersion).ToList();
// Filter matching APIs based on Response Content Type
existingAPIs = existingAPIs.Where(m => m.ResponseContentType == learnedModel.ResponseContentType).ToList();
// Filter matching APIs based on Content Type
existingAPIs = existingAPIs.Where(m => m.ContentType == learnedModel.ContentType).ToList();
}
// Filter matching APIs based on URL Domain
existingAPIs = existingAPIs.Where(m => m.URLDomain == learnedModel.URLDomain).ToList();
// Filter matching APIs based on HTTP Headers
//existingAPIs = existingAPIs.Where(m => m.HttpHeaders.Equals(learnedModel.HttpHeaders)).ToList();
for (int i = existingAPIs.Count - 1; i >= 0; i--)
{
ApplicationAPIModel apiMod = existingAPIs[i];
foreach (APIModelKeyValue headerPair in apiMod.HttpHeaders)
{
APIModelKeyValue apiHeaderExistings = learnedModel.HttpHeaders.Where(h => h.Param == headerPair.Param && h.Value == headerPair.Value).FirstOrDefault();
if (apiHeaderExistings != null)
{
continue;
}
else
{
existingAPIs.RemoveAt(i);
break;
}
}
}
// Filter matching APIs based on Request Body
existingAPIs = existingAPIs.Where(m => m.RequestBody != null && m.RequestBody.Equals(learnedModel.RequestBody)).ToList();
return(existingAPIs);
}
public void APIParsingSavingAndPulling()
{
// Arrange
//Act
ApplicationAPIModel AAMS1 = new ApplicationAPIModel();
AAMS1.Name = "Soap1";
AAMS1.Description = "Description";
AAMS1.EndpointURL = "EndpointURL";
AAMS1.ReqHttpVersion = ApplicationAPIUtils.eHttpVersion.HTTPV10;
AppModelParameter AMDP = new AppModelParameter()
{
PlaceHolder = "placeholder", Description = "Description"
};
OptionalValue OV1 = new OptionalValue("Value1");
OptionalValue OV2 = new OptionalValue("Value2");
AMDP.OptionalValuesList.Add(OV1);
AMDP.OptionalValuesList.Add(OV2);
AAMS1.AppModelParameters = new ObservableList <AppModelParameter>();
AAMS1.AppModelParameters.Add(AMDP);
APIModelKeyValue AMKV = new APIModelKeyValue("param", "value");
//AAMS1.APIModelKeyValueHeaders = new ObservableList<APIModelKeyValue>();
//AAMS1.APIModelKeyValueHeaders.Add(AMKV);
AAMS1.NetworkCredentials = ApplicationAPIUtils.eNetworkCredentials.Custom;
AAMS1.URLUser = "******";
AAMS1.URLDomain = "URLDomain";
AAMS1.URLPass = "******";
AAMS1.DoNotFailActionOnBadRespose = true;
AAMS1.HttpHeaders = new ObservableList <APIModelKeyValue>();
AAMS1.HttpHeaders.Add(AMKV);
AAMS1.RequestBodyType = ApplicationAPIUtils.eRequestBodyType.FreeText;
AAMS1.CertificateType = ApplicationAPIUtils.eCretificateType.AllSSL;
AAMS1.CertificatePath = "CertificatePath";
AAMS1.ImportCetificateFile = true;
AAMS1.CertificatePassword = "******";
AAMS1.SecurityType = ApplicationAPIUtils.eSercurityType.Ssl3;
AAMS1.AuthorizationType = ApplicationAPIUtils.eAuthType.BasicAuthentication;
AAMS1.TemplateFileNameFileBrowser = "TemplateFileNameFileBrowser";
AAMS1.ImportRequestFile = "ImportRequestFile";
AAMS1.AuthUsername = "******";
AAMS1.AuthPassword = "******";
//APIParameter APIP = new APIParameter("parameterName", "parameterType", 1, 2);
//AAMS1.ParametersList = new ObservableList<APIParameter>();
//AAMS1.ParametersList.Add(APIP);
AAMS1.SOAPAction = "SOAPAction";
SR.AddRepositoryItem(AAMS1);
//SR.ClearRepositoryItemsCache<ApplicationAPIModel>(); //TODO: we need to make sure this test run as stand alone or it will mess other UT
ObservableList <ApplicationAPIModel> AAMBList = SR.GetAllRepositoryItems <ApplicationAPIModel>();
ApplicationAPIModel AAMS2 = (ApplicationAPIModel)(from x in AAMBList where x.Guid == AAMS1.Guid select x).FirstOrDefault();
// TODO: change 'Value Check' to the name of the field
//Assert
Assert.AreEqual(AAMS2.Name, "Soap1", "Value Check");
Assert.AreEqual(AAMS2.Description, "Description", "Value Check");
Assert.AreEqual(AAMS2.EndpointURL, "EndpointURL", "Value Check");
Assert.AreEqual(AAMS2.ReqHttpVersion, ApplicationAPIUtils.eHttpVersion.HTTPV10, "Value Check");
Assert.AreEqual(AAMS2.AppModelParameters.Count, 1, "Value Check");
Assert.AreEqual(AAMS2.AppModelParameters[0].OptionalValuesList.Count, 2, "Value Check");
//Assert.AreEqual(AAMS2.APIModelKeyValueHeaders.Count, 1, "Value Check");
Assert.AreEqual(AAMS2.NetworkCredentials, ApplicationAPIUtils.eNetworkCredentials.Custom, "Value Check");
Assert.AreEqual(AAMS2.URLUser, "URLUser", "Value Check");
Assert.AreEqual(AAMS2.URLDomain, "URLDomain", "Value Check");
Assert.AreEqual(AAMS2.URLPass, "URLPass", "Value Check");
Assert.AreEqual(AAMS2.DoNotFailActionOnBadRespose, true, "Value Check");
Assert.AreEqual(AAMS2.HttpHeaders.Count, 1, "Value Check");
Assert.AreEqual(AAMS2.RequestBodyType, ApplicationAPIUtils.eRequestBodyType.FreeText, "Value Check");
Assert.AreEqual(AAMS2.CertificateType, ApplicationAPIUtils.eCretificateType.AllSSL, "Value Check");
Assert.AreEqual(AAMS2.CertificatePath, "CertificatePath", "Value Check");
Assert.AreEqual(AAMS2.ImportCetificateFile, true, "Value Check");
Assert.AreEqual(AAMS2.CertificatePassword, "CertificatePassword", "Value Check");
Assert.AreEqual(AAMS2.SecurityType, ApplicationAPIUtils.eSercurityType.Ssl3, "Value Check");
Assert.AreEqual(AAMS2.AuthorizationType, ApplicationAPIUtils.eAuthType.BasicAuthentication, "Value Check");
Assert.AreEqual(AAMS2.TemplateFileNameFileBrowser, "TemplateFileNameFileBrowser", "Value Check");
Assert.AreEqual(AAMS2.ImportRequestFile, "ImportRequestFile", "Value Check");
Assert.AreEqual(AAMS2.AuthUsername, "AuthUsername", "Value Check");
Assert.AreEqual(AAMS2.AuthPassword, "AuthPassword", "Value Check");
//Assert.AreEqual(AAMS2.ParametersList.Count, 1, "Value Check");
Assert.AreEqual(AAMS2.SOAPAction, "SOAPAction", "Value Check");
}
private void AddHttpHeaderRow(object sender, RoutedEventArgs e)
{
APIModelKeyValue AMBKV = new APIModelKeyValue();
mApplicationAPIModel.HttpHeaders.Add(AMBKV);
}
private ApplicationAPIModel GenerateBasicModel(SwaggerOperation Operation, SwaggerOperationMethod method, ref bool supportBody, string path)
{
ApplicationAPIModel AAM = new ApplicationAPIModel();
System.Text.RegularExpressions.Regex reg = new System.Text.RegularExpressions.Regex("{[a-zA-Z]*}");
foreach (var Match in reg.Matches(path))
{
string modal = "<" + Match.ToString().ToUpper() + ">";
path = path.Replace(Match.ToString(), modal);
AAM.AppModelParameters.Add(new AppModelParameter(modal, Match.ToString() + "in url", "", "", new ObservableList <OptionalValue>()));
}
AAM.EndpointURL = Swaggerdoc.BaseUrl + path;
AAM.APIType = ApplicationAPIUtils.eWebApiType.REST;
AAM.Name = Operation.Summary;
if (string.IsNullOrWhiteSpace(AAM.Name))
{
AAM.Name = Operation.OperationId;
}
AAM.URLDomain = Swaggerdoc.BaseUrl;
supportBody = true;
switch (method)
{
case SwaggerOperationMethod.Get:
AAM.RequestType = ApplicationAPIUtils.eRequestType.GET;
supportBody = false;
break;
case SwaggerOperationMethod.Delete:
AAM.RequestType = ApplicationAPIUtils.eRequestType.DELETE;
break;
case SwaggerOperationMethod.Head:
AAM.RequestType = ApplicationAPIUtils.eRequestType.Head;
break;
case SwaggerOperationMethod.Options:
AAM.RequestType = ApplicationAPIUtils.eRequestType.Options;
break;
case SwaggerOperationMethod.Patch:
AAM.RequestType = ApplicationAPIUtils.eRequestType.PATCH;
break;
case SwaggerOperationMethod.Post:
AAM.RequestType = ApplicationAPIUtils.eRequestType.POST;
break;
case SwaggerOperationMethod.Put:
AAM.RequestType = ApplicationAPIUtils.eRequestType.PUT;
break;
case SwaggerOperationMethod.Trace:
AAM.RequestType = ApplicationAPIUtils.eRequestType.POST;
break;
case SwaggerOperationMethod.Undefined:
AAM.RequestType = ApplicationAPIUtils.eRequestType.POST;
break;
}
foreach (SwaggerParameter param in Operation.Parameters)
{
if (param.Kind == SwaggerParameterKind.Header)
{
string modelName = "<" + param.Name + ">";
APIModelKeyValue header = new APIModelKeyValue();
header.ItemName = param.Name;
header.Param = param.Name;
header.Value = modelName;
AAM.AppModelParameters.Add(new AppModelParameter(modelName, param.Name + " in headers", "", "", new ObservableList <OptionalValue>()));
AAM.HttpHeaders.Add(header);
}
}
return(AAM);
}
/// <summary>
/// This method is used to create or update API Model from Soap action
/// </summary>
/// <param name="actionToConvert"></param>
/// <param name="path"></param>
/// <returns></returns>
private void CreateAPIModelFromWebserviceAction(ref ApplicationAPIModel aPIModel, Act actionToConvert, bool pullValidations, bool parameterizeRequestBody)
{
try
{
aPIModel.ItemName = actionToConvert.ItemName;
if (actionToConvert.GetType() == typeof(ActWebAPIRest))
{
aPIModel.APIType = ApplicationAPIUtils.eWebApiType.REST;
}
else
{
aPIModel.APIType = ApplicationAPIUtils.eWebApiType.SOAP;
}
SetPropertyValue(aPIModel, nameof(ActWebAPIBase.Fields.RequestBody), nameof(ApplicationAPIModel.RequestBody), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIRest.Fields.RequestType), nameof(ApplicationAPIModel.RequestType), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIRest.Fields.ReqHttpVersion), nameof(ApplicationAPIModel.ReqHttpVersion), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIRest.Fields.ResponseContentType), nameof(ApplicationAPIModel.ResponseContentType), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIRest.Fields.CookieMode), nameof(ApplicationAPIModel.CookieMode), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIRest.Fields.ContentType), nameof(ApplicationAPIModel.ContentType), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPISoap.Fields.SOAPAction), nameof(ApplicationAPIModel.SOAPAction), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIBase.Fields.EndPointURL), nameof(ApplicationAPIModel.EndpointURL), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIBase.Fields.URLUser), nameof(ApplicationAPIModel.URLUser), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIBase.Fields.URLDomain), nameof(ApplicationAPIModel.URLDomain), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIBase.Fields.URLPass), nameof(ApplicationAPIModel.URLPass), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIBase.Fields.CertificatePath), nameof(ApplicationAPIModel.CertificatePath), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIBase.Fields.DoNotFailActionOnBadRespose), nameof(ApplicationAPIModel.DoNotFailActionOnBadRespose), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIBase.Fields.ImportCetificateFile), nameof(ApplicationAPIModel.ImportCetificateFile), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIBase.Fields.CertificatePassword), nameof(ApplicationAPIModel.CertificatePassword), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIBase.Fields.SecurityType), nameof(ApplicationAPIModel.SecurityType), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIBase.Fields.AuthorizationType), nameof(ApplicationAPIModel.AuthorizationType), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIBase.Fields.TemplateFileNameFileBrowser), nameof(ApplicationAPIModel.TemplateFileNameFileBrowser), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIBase.Fields.AuthUsername), nameof(ApplicationAPIModel.AuthUsername), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIBase.Fields.AuthPassword), nameof(ApplicationAPIModel.AuthPassword), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIBase.Fields.CertificateTypeRadioButton), nameof(ApplicationAPIModel.CertificateType), actionToConvert);
SetPropertyValue(aPIModel, nameof(ActWebAPIBase.Fields.NetworkCredentialsRadioButton), nameof(ApplicationAPIModel.NetworkCredentials), actionToConvert);
if (!string.IsNullOrEmpty(Convert.ToString(aPIModel.TemplateFileNameFileBrowser)))
{
aPIModel.RequestBodyType = ApplicationAPIUtils.eRequestBodyType.TemplateFile;
}
if (((ActWebAPIBase)actionToConvert).HttpHeaders != null)
{
if (aPIModel.HttpHeaders == null)
{
aPIModel.HttpHeaders = new ObservableList <APIModelKeyValue>();
}
foreach (var header in ((ActWebAPIBase)actionToConvert).HttpHeaders)
{
APIModelKeyValue keyVal = new APIModelKeyValue();
keyVal.ItemName = header.ItemName;
keyVal.Param = header.ItemName;
keyVal.FileName = header.ItemName;
keyVal.Value = header.Value;
aPIModel.HttpHeaders.Add(keyVal);
}
}
if (parameterizeRequestBody)
{
ParameterizeApiModellBody(aPIModel, actionToConvert, parameterizeRequestBody);
}
if (pullValidations)
{
foreach (var exitingRV in actionToConvert.ReturnValues)
{
ActReturnValue actR = new ActReturnValue();
if (string.IsNullOrEmpty(exitingRV.Expected) == false)
{
actR.Expected = exitingRV.Expected;
}
if (exitingRV.StoreTo == ActReturnValue.eStoreTo.ApplicationModelParameter)
{
actR.StoreTo = exitingRV.StoreTo;
actR.StoreToValue = exitingRV.StoreToValue;
}
if (actR.Expected != null || actR.StoreTo != ActReturnValue.eStoreTo.None)
{
actR.Active = true;
actR.Param = exitingRV.Param;
actR.Path = exitingRV.Path;
aPIModel.ReturnValues.Add(actR);
}
}
}
}
catch (Exception ex)
{
Reporter.ToLog(eLogLevel.ERROR, "Error occurred while creating the API Model from webservice Action", ex);
}
}
