public ActWebAPIModelEditPage(ActWebAPIModel Act)
{
InitializeComponent();
mAct = Act;
if (mAct.APImodelGUID != new Guid())
{
AAMB = WorkSpace.Instance.SolutionRepository.GetRepositoryItemByGuid <ApplicationAPIModel>(mAct.APImodelGUID);
}
bool mappedNew = false;
if (AAMB == null)//API mapped for this action is missing, Map new API
{
mappedNew = true;
ChangeAPIMapping(mappedNew);
}
if (AAMB != null)
{
WorkSpace.Instance.RefreshGlobalAppModelParams(AAMB);
UpdateOptionalValuesAndParams(!mappedNew);
SetFieldsGrid();
}
else
{
//Show empty page, action is not mapped to any API
}
}
public void APIModelExecutionTest()
{
//Arrange
Activity Activity1 = new Activity();
Activity1.Active = true;
Activity1.ActivityName = "Web API Model";
Activity1.CurrentAgent = wsAgent;
mBF.Activities.Add(Activity1);
ActWebAPIModel actWebAPIModel = new ActWebAPIModel();
actWebAPIModel.APImodelGUID = Guid.Parse("fcac0742-4747-4939-99ab-2d23c33ab74e");
actWebAPIModel.APIModelParamsValue.Add(new EnhancedActInputValue()
{
Param = "<<COUNTRYNAME>>", Value = "israel", ValueForDriver = "israel"
});
actWebAPIModel.Description = "Testing Action";
actWebAPIModel.Active = true;
actWebAPIModel.EnableRetryMechanism = false;
mBF.Activities[0].Acts.Add(actWebAPIModel);
mDriver.StartDriver();
//Act
mGR.RunRunner();
//Assert
//TODO: add some assert??
}
public override void Finish()
{
foreach (ApplicationAPIModel aamb in AAMList)
{
ActWebAPIModel aNew = new ActWebAPIModel();
aNew.Description = aamb.Name + "- API Model Execution";
aNew.Active = true;
aNew.SupportSimulation = aamb.SupportSimulation;
aNew.APImodelGUID = aamb.Guid;
aNew.APIModelParamsValue = GetEnhancedUpdatedParams(aamb.MergedParamsList);
aNew.ReturnValues = ConvertTemplateReturnValues(aamb.ReturnValues);
aNew.AddNewReturnParams = true;
aNew.SolutionFolder = App.UserProfile.Solution.Folder.ToUpper();
actions.Add(aNew);
//adding the new act after the selected action in the grid
int selectedActIndex = -1;
if (actions.CurrentItem != null)
{
selectedActIndex = actions.IndexOf((Act)actions.CurrentItem);
}
if (selectedActIndex >= 0)
{
actions.Move(actions.Count - 1, selectedActIndex + 1);
}
}
}
private ActWebAPISoap CreateActWebAPISOAP(ApplicationAPIModel AAMB, ActWebAPIModel ActWebAPIModel)
{
ActWebAPISoap actWebAPISoap = new ActWebAPISoap();
FillAPIBaseFields(AAMB, actWebAPISoap, ActWebAPIModel);
return(actWebAPISoap);
}
private ActWebAPIRest CreateActWebAPIREST(ApplicationAPIModel AAMB, ActWebAPIModel ActWebAPIModel)
{
ActWebAPIRest actWebAPIBase = new ActWebAPIRest();
FillAPIBaseFields(AAMB, actWebAPIBase, ActWebAPIModel);
return(actWebAPIBase);
}
/// <summary>
/// This method is used to convert the legacy service actions to api actions from the businessflows provided
/// </summary>
/// <param name="businessFlows"></param>
/// <param name="parameterizeRequestBody"></param>
/// <param name="configuredValidationRequired"></param>
public void ConvertToApiActionsFromBusinessFlows(ObservableList <BusinessFlowToConvert> businessFlows, bool parameterizeRequestBody, bool pullValidations, RepositoryFolder <ApplicationAPIModel> apiModelFolder)
{
ActWebAPIModel webAPIModel = new ActWebAPIModel();
foreach (var bf in businessFlows)
{
try
{
if (!mStopConversion)
{
bf.ConversionStatus = eConversionStatus.Pending;
if (IsValidWebServiceBusinessFlow(bf.BusinessFlow))
{
for (int activityIndex = 0; activityIndex < bf.BusinessFlow.Activities.Count(); activityIndex++)
{
Activity activity = bf.BusinessFlow.Activities[activityIndex];
RepositoryItemKey ta = WorkSpace.Instance.Solution.ApplicationPlatforms.Where(x => x.ItemName == activity.TargetApplication).FirstOrDefault().Key;
if (activity != null && activity.Active && WorkSpace.Instance.Solution.GetApplicationPlatformForTargetApp(ta.ItemName) == ePlatformType.WebServices)
{
bf.ConvertedActionsCount += ConvertActivity(parameterizeRequestBody, pullValidations, activity, ta, apiModelFolder);
}
}
}
bf.ConversionStatus = eConversionStatus.Finish;
}
}
catch (Exception ex)
{
Reporter.ToLog(eLogLevel.ERROR, "Error occurred while trying to convert action", ex);
}
}
}
/// <summary>
/// This method will convert the Activity Actions
/// </summary>
/// <param name="parameterizeRequestBody"></param>
/// <param name="pullValidations"></param>
/// <param name="activity"></param>
/// <param name="ta"></param>
private int ConvertActivity(bool parameterizeRequestBody, bool pullValidations, Activity activity, RepositoryItemKey ta, RepositoryFolder <ApplicationAPIModel> apiModelFolder)
{
int convertionConter = 0;
for (int actionIndex = 0; actionIndex < activity.Acts.Count; actionIndex++)
{
try
{
Act act = (Act)activity.Acts[actionIndex];
if (act.Active && (act.GetType() == typeof(ActWebAPIRest) || act.GetType() == typeof(ActWebAPISoap)))
{
// get the index of the action that is being converted
int selectedActIndex = activity.Acts.IndexOf(act);
//Create/Update API Model
bool isModelExists = true;
ApplicationAPIModel applicationModel = GetAPIModelIfExists(act);
if (applicationModel == null)
{
isModelExists = false;
applicationModel = new ApplicationAPIModel();
applicationModel.TargetApplicationKey = ta;
CreateAPIModelFromWebserviceAction(ref applicationModel, act, pullValidations, parameterizeRequestBody);
}
//Parse optional values
Dictionary <System.Tuple <string, string>, List <string> > optionalValuesPulledFromConvertedAction = new Dictionary <Tuple <string, string>, List <string> >();
if (applicationModel.AppModelParameters != null && applicationModel.AppModelParameters.Count > 0)
{
optionalValuesPulledFromConvertedAction = ParseParametersOptionalValues(applicationModel, (ActWebAPIBase)act);
}
//Create WebAPIModel action
ActWebAPIModel actApiModel = GetNewAPIModelAction(applicationModel, act, optionalValuesPulledFromConvertedAction);
activity.Acts.Insert(selectedActIndex + 1, actApiModel);
actionIndex++;
act.Active = false;
if (!isModelExists)
{
apiModelFolder.AddRepositoryItem(applicationModel);
}
else
{
WorkSpace.Instance.SolutionRepository.SaveRepositoryItem(applicationModel);
}
convertionConter++;
}
}
catch (Exception ex)
{
Reporter.ToLog(eLogLevel.ERROR, "Error occurred while trying to convert the action", ex);
}
}
return(convertionConter);
}
/// <summary>
/// This method will create the new api model action
/// </summary>
/// <param name="applicationModel"></param>
/// <param name="act"></param>
/// <returns></returns>
private ActWebAPIModel GetNewAPIModelAction(ApplicationAPIModel applicationModel, Act act, Dictionary <System.Tuple <string, string>, List <string> > optionalValuesPulledFromConvertedAction)
{
AutoMapper.MapperConfiguration mapConfigUIElement = new AutoMapper.MapperConfiguration(cfg => { cfg.CreateMap <Act, ActWebAPIModel>(); });
ActWebAPIModel newActModel = mapConfigUIElement.CreateMapper().Map <Act, ActWebAPIModel>(act);
newActModel.APImodelGUID = applicationModel.Guid;
newActModel.Active = true;
newActModel.Reset();
newActModel.APIModelParamsValue = GetAPIActionParams(applicationModel.AppModelParameters, optionalValuesPulledFromConvertedAction);
//newActModel.ReturnValues = GetAPIModelActionReturnValues(applicationModel.ReturnValues); //For now we want to keep original validations on action
return(newActModel);
}
private void SetExecutionValue <T>(T param, ActWebAPIModel actWebAPIModel)
{
AppModelParameter p = param as AppModelParameter;
EnhancedActInputValue enhanceInput = actWebAPIModel.APIModelParamsValue.Where(x => x.ParamGuid == p.Guid).FirstOrDefault();
if (enhanceInput != null)
{
p.ExecutionValue = enhanceInput.ValueForDriver;
}
else
{
p.ExecutionValue = p.GetDefaultValue();
}
if (p is GlobalAppModelParameter && p.ExecutionValue.Equals(GlobalAppModelParameter.CURRENT_VALUE))
{
p.ExecutionValue = ((GlobalAppModelParameter)p).CurrentValue;
}
}
private ApplicationAPIModel SetAPIModelData(ApplicationAPIModel AAMB, ActWebAPIModel actWebAPIModel)
{
WorkSpace.Instance.RefreshGlobalAppModelParams(AAMB);
//Duplicate Model for not changing on cache
ApplicationAPIModel AAMBDuplicate = (ApplicationAPIModel)AAMB.CreateCopy(false);
//Set model params with actual execution value
foreach (AppModelParameter modelParam in AAMBDuplicate.AppModelParameters)
{
SetExecutionValue(modelParam, actWebAPIModel);
}
foreach (GlobalAppModelParameter globalParam in AAMBDuplicate.GlobalAppModelParameters)
{
SetExecutionValue(globalParam, actWebAPIModel);
}
actWebAPIModel.ActAppModelParameters = AAMBDuplicate.MergedParamsList;
//Replace Placeholders with Execution Values
AAMBDuplicate.SetModelConfigsWithExecutionData();
return(AAMBDuplicate);
}
private ObservableList <ActInputValue> ConvertAPIModelKeyValueToActInputValues(ObservableList <APIModelKeyValue> GingerCoreNETHttpHeaders, ActWebAPIModel actWebAPIModel)
{
ObservableList <ActInputValue> GingerCoreHttpHeaders = new ObservableList <ActInputValue>();
if (GingerCoreNETHttpHeaders != null)
{
foreach (APIModelKeyValue AMKV in GingerCoreNETHttpHeaders)
{
ActInputValue AIV = new ActInputValue();
AIV.Param = AMKV.Param;
AIV.ValueForDriver = ReplacePlaceHolderParameneterWithActual(AMKV.Value, actWebAPIModel.APIModelParamsValue);
GingerCoreHttpHeaders.Add(AIV);
}
}
return(GingerCoreHttpHeaders);
}
private void FillAPIBaseFields(ApplicationAPIModel AAMB, ActWebAPIBase actWebAPIBase, ActWebAPIModel actWebAPIModel)
{
ApplicationAPIModel AAMBDuplicate = SetAPIModelData(AAMB, actWebAPIModel);
//Initilizing Act Properties
actWebAPIBase.AddNewReturnParams = actWebAPIModel.AddNewReturnParams;
actWebAPIBase.SolutionFolder = actWebAPIModel.SolutionFolder;
actWebAPIBase.SupportSimulation = actWebAPIModel.SupportSimulation;
actWebAPIBase.AddOrUpdateInputParamValue(nameof(ActWebAPIBase.UseLegacyJSONParsing), "False");
actWebAPIBase.Description = actWebAPIModel.Description;
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIRest.Fields.RequestType, AAMBDuplicate.RequestType.ToString());
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIRest.Fields.ReqHttpVersion, AAMBDuplicate.ReqHttpVersion.ToString());
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIRest.Fields.ResponseContentType, AAMBDuplicate.ResponseContentType.ToString());
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIRest.Fields.CookieMode, AAMBDuplicate.CookieMode.ToString());
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIRest.Fields.ContentType, AAMBDuplicate.ContentType.ToString());
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPISoap.Fields.SOAPAction, AAMBDuplicate.SOAPAction);
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.EndPointURL, AAMBDuplicate.EndpointURL);
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.NetworkCredentialsRadioButton, AAMBDuplicate.NetworkCredentials.ToString());
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.URLUser, AAMBDuplicate.URLUser);
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.URLDomain, AAMBDuplicate.URLDomain);
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.URLPass, AAMBDuplicate.URLPass);
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.DoNotFailActionOnBadRespose, AAMBDuplicate.DoNotFailActionOnBadRespose.ToString());
actWebAPIBase.HttpHeaders = ConvertAPIModelKeyValueToActInputValues(AAMBDuplicate.HttpHeaders, actWebAPIModel);
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.RequestBodyTypeRadioButton, AAMBDuplicate.RequestBodyType.ToString());
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.RequestBody, AAMBDuplicate.RequestBody);
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.CertificateTypeRadioButton, AAMBDuplicate.CertificateType.ToString());
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.CertificatePath, AAMBDuplicate.CertificatePath);
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.ImportCetificateFile, AAMBDuplicate.ImportCetificateFile.ToString());
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.CertificatePassword, AAMBDuplicate.CertificatePassword);
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.SecurityType, AAMBDuplicate.SecurityType.ToString());
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.AuthorizationType, AAMBDuplicate.AuthorizationType.ToString());
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.TemplateFileNameFileBrowser, AAMBDuplicate.TemplateFileNameFileBrowser.ToString());
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.AuthUsername, AAMBDuplicate.AuthUsername.ToString());
actWebAPIBase.AddOrUpdateInputParamValueAndCalculatedValue(ActWebAPIBase.Fields.AuthPassword, AAMBDuplicate.AuthPassword.ToString());
actWebAPIBase.ReturnValues = actWebAPIModel.ReturnValues;
}
