use of com.twinsoft.convertigo.beans.core.UrlMappingParameter in project convertigo by convertigo.
the class SwaggerUtils method parse.
public static Swagger parse(String requestUrl, UrlMapper urlMapper) {
Project project = urlMapper.getProject();
String projectName = project.getName();
String oasDirUrl = requestUrl.substring(0, requestUrl.indexOf("/" + servletMappingPath)) + "/projects/" + projectName + "/" + jsonSchemaDirectory + "/";
Swagger swagger = parseCommon(requestUrl, project);
List<Tag> tags = new ArrayList<Tag>();
Tag tag = new Tag();
tag.setName(urlMapper.getProject().getName());
tag.setDescription(urlMapper.getProject().getComment());
tags.add(tag);
swagger.setTags(tags);
// Security
Map<String, SecuritySchemeDefinition> securityDefinitions = swagger.getSecurityDefinitions();
for (UrlAuthentication authentication : urlMapper.getAuthenticationList()) {
if (AuthenticationType.Basic.equals(authentication.getType())) {
if (securityDefinitions == null || !securityDefinitions.containsKey("basicAuth")) {
BasicAuthDefinition basicAuthDefinition = new BasicAuthDefinition();
swagger.addSecurityDefinition("basicAuth", basicAuthDefinition);
SecurityRequirement securityRequirement = new SecurityRequirement();
securityRequirement.requirement("basicAuth", new ArrayList<String>());
swagger.addSecurity(securityRequirement);
}
}
}
// Models and Schemas
Map<String, Model> swagger_models = new HashMap<String, Model>();
try {
String models = getModels(oasDirUrl, urlMapper);
if (!models.isEmpty()) {
ObjectMapper mapper = Json.mapper();
JsonNode definitionNode = mapper.readTree(models);
for (Iterator<Entry<String, JsonNode>> it = GenericUtils.cast(definitionNode.fields()); it.hasNext(); ) {
Entry<String, JsonNode> entry = it.next();
swagger_models.put(entry.getKey().toString(), mapper.convertValue(entry.getValue(), Model.class));
}
}
} catch (Exception e) {
e.printStackTrace();
Engine.logEngine.warn("Unexpected exception while reading UrlMapper defined models", e);
}
swagger.setDefinitions(swagger_models);
// Mappings
Map<String, Path> swagger_paths = new HashMap<String, Path>();
try {
for (UrlMapping urlMapping : urlMapper.getMappingList()) {
Path swagger_path = new Path();
for (UrlMappingOperation umo : urlMapping.getOperationList()) {
Operation s_operation = new Operation();
s_operation.setOperationId(umo.getQName());
s_operation.setDescription(umo.getComment());
s_operation.setSummary(umo.getComment());
// Operation produces
if (umo instanceof AbstractRestOperation) {
DataContent dataOutput = ((AbstractRestOperation) umo).getOutputContent();
if (dataOutput.equals(DataContent.toJson)) {
s_operation.setProduces(Arrays.asList(MimeType.Json.value()));
} else if (dataOutput.equals(DataContent.toXml)) {
s_operation.setProduces(Arrays.asList(MimeType.Xml.value()));
} else {
s_operation.setProduces(Arrays.asList(MimeType.Json.value(), MimeType.Xml.value()));
}
}
// Operation tags
List<String> list = Arrays.asList("" + project.getName());
s_operation.setTags(list);
// Operation consumes
List<String> consumes = new ArrayList<String>();
// Operation parameters
List<Parameter> s_parameters = new ArrayList<Parameter>();
// 1 - add path parameters
for (String pathVarName : urlMapping.getPathVariableNames()) {
PathParameter s_parameter = new PathParameter();
s_parameter.setName(pathVarName);
s_parameter.setRequired(true);
s_parameter.setType("string");
// retrieve parameter description from bean
UrlMappingParameter ump = null;
try {
ump = umo.getParameterByName(pathVarName);
} catch (Exception e) {
}
if (ump != null && ump.getType() == Type.Path) {
s_parameter.setDescription(ump.getComment());
s_parameter.setType(ump.getInputType().toLowerCase());
Object value = ump.getValueOrNull();
if (value != null) {
s_parameter.setDefaultValue(String.valueOf(value));
}
}
s_parameters.add(s_parameter);
}
// 2 - add other parameters
for (UrlMappingParameter ump : umo.getParameterList()) {
Parameter s_parameter = null;
if (ump.getType() == Type.Query) {
s_parameter = new QueryParameter();
} else if (ump.getType() == Type.Form) {
s_parameter = new FormParameter();
} else if (ump.getType() == Type.Body) {
s_parameter = new BodyParameter();
if (ump instanceof IMappingRefModel) {
String modelReference = ((IMappingRefModel) ump).getModelReference();
if (!modelReference.isEmpty()) {
if (modelReference.indexOf(".jsonschema") != -1) {
modelReference = oasDirUrl + modelReference;
}
RefModel refModel = new RefModel(modelReference);
((BodyParameter) s_parameter).setSchema(refModel);
}
}
} else if (ump.getType() == Type.Header) {
s_parameter = new HeaderParameter();
} else if (ump.getType() == Type.Path) {
// ignore : should have been treated before
}
if (s_parameter != null) {
s_parameter.setName(ump.getName());
s_parameter.setDescription(ump.getComment());
s_parameter.setRequired(ump.isRequired());
if (s_parameter instanceof SerializableParameter) {
boolean isArray = ump.isMultiValued() || ump.isArray();
String _type = isArray ? "array" : ump.getDataType().name().toLowerCase();
String _collectionFormat = ump.isMultiValued() ? "multi" : (isArray ? "csv" : null);
Property _items = isArray ? getItems(ump.getDataType()) : null;
((SerializableParameter) s_parameter).setType(_type);
((SerializableParameter) s_parameter).setCollectionFormat(_collectionFormat);
((SerializableParameter) s_parameter).setItems(_items);
Object value = ump.getValueOrNull();
if (value != null) {
String collection = ((SerializableParameter) s_parameter).getCollectionFormat();
if (collection != null && collection.equals("multi")) {
Property items = new StringProperty();
// items.setDefault(String.valueOf(value));
((SerializableParameter) s_parameter).setItems(items);
// ((SerializableParameter) s_parameter).setEnumValue(Arrays.asList("val1","val2","val3"));
} else {
((AbstractSerializableParameter<?>) s_parameter).setDefaultValue(String.valueOf(value));
}
}
}
DataContent dataInput = ump.getInputContent();
if (dataInput.equals(DataContent.toJson)) {
if (!consumes.contains(MimeType.Json.value())) {
consumes.add(MimeType.Json.value());
}
} else if (dataInput.equals(DataContent.toXml)) {
if (!consumes.contains(MimeType.Xml.value())) {
consumes.add(MimeType.Xml.value());
}
}
// swagger-ui workaround for invalid request content-type for POST
if (ump.getType() == Type.Form) {
if (!DataType.File.equals(ump.getDataType())) {
if (!consumes.contains(MimeType.WwwForm.value())) {
consumes.add(MimeType.WwwForm.value());
}
} else {
if (!consumes.contains("multipart/form-data")) {
consumes.add("multipart/form-data");
}
}
}
// add parameter
if (ump.isExposed()) {
s_parameters.add(s_parameter);
}
}
}
s_operation.setParameters(s_parameters);
if (!consumes.isEmpty()) {
s_operation.setConsumes(consumes);
}
// Set operation responses
Map<String, Response> responses = new HashMap<String, Response>();
for (UrlMappingResponse umr : umo.getResponseList()) {
String statusCode = umr.getStatusCode();
if (!statusCode.isEmpty()) {
if (!responses.containsKey(statusCode)) {
Response response = new Response();
// response.setDescription(umr.getComment());
response.setDescription(umr.getStatusText());
if (umr instanceof IMappingRefModel) {
String modelReference = ((IMappingRefModel) umr).getModelReference();
if (!modelReference.isEmpty()) {
if (modelReference.indexOf(".jsonschema") != -1) {
modelReference = oasDirUrl + modelReference;
}
RefProperty refProperty = new RefProperty(modelReference);
response.setResponseSchema(new PropertyModelConverter().propertyToModel(refProperty));
}
}
responses.put(statusCode, response);
}
}
}
if (responses.isEmpty()) {
Response resp200 = new Response();
resp200.description("successful operation");
responses.put("200", resp200);
}
s_operation.setResponses(responses);
// Add operation to path
String s_method = umo.getMethod().toLowerCase();
swagger_path.set(s_method, s_operation);
}
swagger_paths.put(urlMapping.getPathWithPrefix(), swagger_path);
}
} catch (Exception e) {
e.printStackTrace();
Engine.logEngine.error("Unexpected exception while parsing UrlMapper to generate definition", e);
}
swagger.setPaths(swagger_paths);
return swagger;
}
use of com.twinsoft.convertigo.beans.core.UrlMappingParameter in project convertigo by convertigo.
the class TreeDropAdapter method move.
private boolean move(Node node, TreeObject targetTreeObject) throws EngineException {
if (targetTreeObject instanceof DatabaseObjectTreeObject) {
DatabaseObject parent = ((DatabaseObjectTreeObject) targetTreeObject).getObject();
DatabaseObject databaseObject = paste(node, null, true);
Element element = (Element) ((Element) node).getElementsByTagName("dnd").item(0);
// SEQUENCER
if (parent instanceof Sequence || parent instanceof StepWithExpressions) {
;
} else // URLMAPPER
if (parent instanceof UrlMappingOperation) {
// Set associated requestable
if (databaseObject instanceof RequestableObject) {
String dboQName = "";
if (databaseObject instanceof Sequence) {
dboQName = ((Element) element.getElementsByTagName("project").item(0)).getAttribute("name") + "." + databaseObject.getName();
} else if (databaseObject instanceof Transaction) {
dboQName = ((Element) element.getElementsByTagName("project").item(0)).getAttribute("name") + "." + ((Element) element.getElementsByTagName("connector").item(0)).getAttribute("name") + "." + databaseObject.getName();
}
UrlMappingOperation operation = (UrlMappingOperation) parent;
operation.setTargetRequestable(dboQName);
if (operation.getComment().isEmpty()) {
operation.setComment(databaseObject.getComment());
}
operation.hasChanged = true;
return true;
}
} else if (parent instanceof UrlMappingParameter) {
// Set associated mapped variable for parameter
if (databaseObject instanceof RequestableVariable) {
RequestableVariable variable = (RequestableVariable) databaseObject;
UrlMappingParameter parameter = (UrlMappingParameter) parent;
parameter.setMappedVariableName(variable.getName());
parameter.hasChanged = true;
return true;
}
}
}
return false;
}
use of com.twinsoft.convertigo.beans.core.UrlMappingParameter in project convertigo by convertigo.
the class ProjectExplorerView method loadDatabaseObject.
private void loadDatabaseObject(TreeParent parentTreeObject, DatabaseObject parentDatabaseObject, ProjectLoadingJob projectLoadingJob, final IProgressMonitor monitor) throws EngineException, IOException {
try {
new WalkHelper() {
// recursion parameters
TreeParent parentTreeObject;
ProjectLoadingJob projectLoadingJob;
// sibling parameters
ObjectsFolderTreeObject currentTreeFolder = null;
public void init(DatabaseObject databaseObject, TreeParent parentTreeObject, ProjectLoadingJob projectLoadingJob) throws Exception {
this.parentTreeObject = parentTreeObject;
this.projectLoadingJob = projectLoadingJob;
walkInheritance = true;
super.init(databaseObject);
}
protected ObjectsFolderTreeObject getFolder(TreeParent treeParent, int folderType) {
ObjectsFolderTreeObject ofto = null;
for (TreeObject to : treeParent.getChildren()) {
if (to instanceof ObjectsFolderTreeObject) {
if (((ObjectsFolderTreeObject) to).folderType == folderType) {
ofto = (ObjectsFolderTreeObject) to;
break;
}
}
}
if (ofto == null) {
ofto = new ObjectsFolderTreeObject(viewer, folderType);
treeParent.addChild(ofto);
}
return ofto;
}
@Override
protected void walk(DatabaseObject databaseObject) throws Exception {
// retrieve recursion parameters
final TreeParent parentTreeObject = this.parentTreeObject;
final ProjectLoadingJob projectLoadingJob = this.projectLoadingJob;
// retrieve sibling parameters
ObjectsFolderTreeObject currentTreeFolder = this.currentTreeFolder;
String dboName = (databaseObject instanceof Step) ? ((Step) databaseObject).getStepNodeName() : databaseObject.getName();
monitor.subTask("Loading databaseObject '" + dboName + "'...");
DatabaseObjectTreeObject databaseObjectTreeObject = null;
// first call case, the tree object already exists and its content is just refreshed
if (parentTreeObject.getObject() == databaseObject) {
databaseObjectTreeObject = (DatabaseObjectTreeObject) parentTreeObject;
} else // recursive call case, the tree object doesn't exist and must be added to the parent tree object
{
int folderType = Integer.MIN_VALUE;
if (databaseObject instanceof Connector) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_CONNECTORS;
databaseObjectTreeObject = new ConnectorTreeObject(viewer, (Connector) databaseObject, false);
} else if (databaseObject instanceof Sequence) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_SEQUENCES;
databaseObjectTreeObject = new SequenceTreeObject(viewer, (Sequence) databaseObject, false);
} else if (databaseObject instanceof MobileApplication) {
databaseObjectTreeObject = new MobileApplicationTreeObject(viewer, (MobileApplication) databaseObject, false);
} else if (databaseObject instanceof MobilePlatform) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_PLATFORMS;
databaseObjectTreeObject = new MobilePlatformTreeObject(viewer, (MobilePlatform) databaseObject, false);
} else /**
***********************************************************************************************
*/
if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.MobileComponent) {
if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.ApplicationComponent) {
databaseObjectTreeObject = new MobileApplicationComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.RouteComponent) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_ROUTES;
databaseObjectTreeObject = new MobileRouteComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.RouteEventComponent) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_EVENTS;
databaseObjectTreeObject = new MobileRouteEventComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.RouteActionComponent) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_ACTIONS;
databaseObjectTreeObject = new MobileRouteActionComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.PageComponent) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_PAGES;
databaseObjectTreeObject = new MobilePageComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIActionStack) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_SHARED_ACTIONS;
databaseObjectTreeObject = new MobileUIComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UISharedComponent) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_SHARED_COMPONENTS;
databaseObjectTreeObject = new MobileUIComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIDynamicMenu) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_MENUS;
databaseObjectTreeObject = new MobileUIComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIComponent) {
if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIAttribute) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_ATTRIBUTES;
if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIControlAttr) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_CONTROLS;
}
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIStyle) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_STYLES;
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIControlVariable) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_VARIABLES;
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UICompVariable) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_VARIABLES;
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIStackVariable) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_VARIABLES;
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIFormValidator) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_VALIDATORS;
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIAppEvent) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_EVENTS;
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIPageEvent) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_EVENTS;
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIEventSubscriber) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_EVENTS;
}
databaseObjectTreeObject = new MobileUIComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
}
} else /**
***********************************************************************************************
*/
if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.MobileComponent) {
if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.ApplicationComponent) {
databaseObjectTreeObject = new NgxApplicationComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.PageComponent) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_PAGES;
databaseObjectTreeObject = new NgxPageComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIActionStack) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_SHARED_ACTIONS;
databaseObjectTreeObject = new NgxUIComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UISharedComponent) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_SHARED_COMPONENTS;
databaseObjectTreeObject = new NgxUIComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIDynamicMenu) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_MENUS;
databaseObjectTreeObject = new NgxUIComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIComponent) {
if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIAttribute) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_ATTRIBUTES;
if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIControlAttr) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_CONTROLS;
}
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIDynamicAttr) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_ATTRIBUTES;
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIStyle) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_STYLES;
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIControlVariable) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_VARIABLES;
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UICompVariable) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_VARIABLES;
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIStackVariable) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_VARIABLES;
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIAppEvent) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_EVENTS;
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIPageEvent) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_EVENTS;
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIEventSubscriber) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_EVENTS;
}
databaseObjectTreeObject = new NgxUIComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
}
} else if (databaseObject instanceof UrlMapper) {
databaseObjectTreeObject = new UrlMapperTreeObject(viewer, (UrlMapper) databaseObject, false);
} else if (databaseObject instanceof UrlAuthentication) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_AUTHENTICATIONS;
databaseObjectTreeObject = new UrlAuthenticationTreeObject(viewer, (UrlAuthentication) databaseObject, false);
} else if (databaseObject instanceof UrlMapping) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_MAPPINGS;
databaseObjectTreeObject = new UrlMappingTreeObject(viewer, (UrlMapping) databaseObject, false);
} else if (databaseObject instanceof UrlMappingOperation) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_OPERATIONS;
databaseObjectTreeObject = new UrlMappingOperationTreeObject(viewer, (UrlMappingOperation) databaseObject, false);
} else if (databaseObject instanceof UrlMappingParameter) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_PARAMETERS;
databaseObjectTreeObject = new UrlMappingParameterTreeObject(viewer, (UrlMappingParameter) databaseObject, false);
} else if (databaseObject instanceof UrlMappingResponse) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_RESPONSES;
databaseObjectTreeObject = new UrlMappingResponseTreeObject(viewer, (UrlMappingResponse) databaseObject, false);
} else if (databaseObject instanceof Reference) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_REFERENCES;
databaseObjectTreeObject = new ReferenceTreeObject(viewer, (Reference) databaseObject, false);
} else if (databaseObject instanceof Pool) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_POOLS;
databaseObjectTreeObject = new DatabaseObjectTreeObject(viewer, databaseObject, false);
} else if (databaseObject instanceof Transaction) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_TRANSACTIONS;
databaseObjectTreeObject = new TransactionTreeObject(viewer, (Transaction) databaseObject, false);
} else if (databaseObject instanceof ScreenClass) {
if (databaseObject.getParent() instanceof IScreenClassContainer<?>) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_SCREEN_CLASSES;
databaseObjectTreeObject = new ScreenClassTreeObject(viewer, (ScreenClass) databaseObject, false);
} else {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_INHERITED_SCREEN_CLASSES;
databaseObjectTreeObject = new ScreenClassTreeObject(viewer, (ScreenClass) databaseObject, false);
}
} else if (databaseObject instanceof Sheet) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_SHEETS;
databaseObjectTreeObject = new SheetTreeObject(viewer, (Sheet) databaseObject, parentTreeObject.getObject() != databaseObject.getParent());
} else if (databaseObject instanceof TestCase) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_TESTCASES;
databaseObjectTreeObject = new TestCaseTreeObject(viewer, (TestCase) databaseObject, false);
} else if (databaseObject instanceof Variable) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_VARIABLES;
databaseObjectTreeObject = new VariableTreeObject2(viewer, (Variable) databaseObject, false);
} else if (databaseObject instanceof Step) {
if (databaseObject.getParent() instanceof Sequence) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_STEPS;
}
databaseObjectTreeObject = new StepTreeObject(viewer, (Step) databaseObject, false);
} else if (databaseObject instanceof Statement) {
if (databaseObject.getParent() instanceof Transaction) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_FUNCTIONS;
}
databaseObjectTreeObject = new StatementTreeObject(viewer, (Statement) databaseObject, false);
} else if (databaseObject instanceof Criteria) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_CRITERIAS;
databaseObjectTreeObject = new CriteriaTreeObject(viewer, (Criteria) databaseObject, parentTreeObject.getObject() != databaseObject.getParent());
} else if (databaseObject instanceof ExtractionRule) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_EXTRACTION_RULES;
databaseObjectTreeObject = new ExtractionRuleTreeObject(viewer, (ExtractionRule) databaseObject, parentTreeObject.getObject() != databaseObject.getParent());
} else if (databaseObject instanceof BlockFactory) {
databaseObjectTreeObject = new DatabaseObjectTreeObject(viewer, databaseObject, parentTreeObject.getObject() != databaseObject.getParent());
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.core.Document) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_DOCUMENTS;
com.twinsoft.convertigo.beans.core.Document document = (com.twinsoft.convertigo.beans.core.Document) databaseObject;
String documentRenderer = document.getRenderer();
if (documentRenderer.equals("DesignDocumentTreeObject"))
databaseObjectTreeObject = new DesignDocumentTreeObject(viewer, document, false);
else
databaseObjectTreeObject = new DocumentTreeObject(viewer, document, false);
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.core.Listener) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_LISTENERS;
com.twinsoft.convertigo.beans.core.Listener listener = (com.twinsoft.convertigo.beans.core.Listener) databaseObject;
String listenerRenderer = listener.getRenderer();
if (listenerRenderer.equals("FullSyncListenerTreeObject")) {
databaseObjectTreeObject = new FullSyncListenerTreeObject(viewer, listener, false);
} else {
databaseObjectTreeObject = new ListenerTreeObject(viewer, listener, false);
}
} else if (databaseObject instanceof com.twinsoft.convertigo.beans.core.Index) {
folderType = ObjectsFolderTreeObject.FOLDER_TYPE_INDEXES;
databaseObjectTreeObject = new DatabaseObjectTreeObject(viewer, databaseObject, false);
} else {
// unknow DBO case !!!
databaseObjectTreeObject = new DatabaseObjectTreeObject(viewer, databaseObject, false);
}
// no virtual folder
if (folderType == Integer.MIN_VALUE) {
parentTreeObject.addChild(databaseObjectTreeObject);
} else // virtual folder creation or reuse
{
/* fixed #5416 */
// if (currentTreeFolder == null || currentTreeFolder.folderType != folderType) {
// currentTreeFolder = new ObjectsFolderTreeObject(viewer, folderType);
// parentTreeObject.addChild(currentTreeFolder);
// }
currentTreeFolder = getFolder(parentTreeObject, folderType);
currentTreeFolder.addChild(databaseObjectTreeObject);
}
// case databaseObject has been changed through dbo::preconfigure, mark projectTreeObject as modified
if ((databaseObject.bNew) || (databaseObject.hasChanged && !databaseObject.bNew)) {
databaseObjectTreeObject.hasBeenModified(true);
}
// new value of recursion parameters
this.parentTreeObject = databaseObjectTreeObject;
}
// special databaseObject cases
if (databaseObject instanceof Project) {
Project project = (Project) databaseObject;
// Creates directories and files
createDirsAndFiles(project.getName());
// Creates or Refresh xsd and wsdl folders
IFolder xsdFolder, wsdlFolder = null;
IFolder xsdInternalFolder = null;
try {
wsdlFolder = ((ProjectTreeObject) parentTreeObject).getFolder("wsdl");
if (!wsdlFolder.exists())
wsdlFolder.create(true, true, null);
else
wsdlFolder.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
xsdFolder = ((ProjectTreeObject) parentTreeObject).getFolder("xsd");
if (!xsdFolder.exists())
xsdFolder.create(true, true, null);
else {
xsdInternalFolder = xsdFolder.getFolder("internal");
if (!xsdInternalFolder.exists())
xsdInternalFolder.create(true, true, null);
xsdFolder.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
}
} catch (Exception e) {
e.printStackTrace();
}
// Connectors
IFolder xsdConnectorInternalFolder = null;
Collection<Connector> connectors = project.getConnectorsList();
if (connectors.size() != 0) {
// Set default connector if none
if (project.getDefaultConnector() == null) {
// Report from 4.5: fix #401
ConvertigoPlugin.logWarning(null, "Project \"" + project.getName() + "\" has no default connector. Try to set a default one.");
Connector defaultConnector = connectors.iterator().next();
try {
project.setDefaultConnector(defaultConnector);
defaultConnector.hasChanged = true;
} catch (Exception e) {
ConvertigoPlugin.logWarning(e, "Unable to set a default connector for project \"" + project.getName() + "\"");
}
}
// Refresh Traces folder
IFolder ifolder = ((ProjectTreeObject) parentTreeObject).getFolder("Traces");
if (ifolder.exists()) {
try {
ifolder.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
} catch (CoreException e) {
}
}
// Creates or Refresh internal xsd connector folders
for (Connector connector : connectors) {
try {
xsdConnectorInternalFolder = xsdInternalFolder.getFolder(connector.getName());
if (!xsdConnectorInternalFolder.exists())
xsdConnectorInternalFolder.create(true, true, null);
else
xsdConnectorInternalFolder.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
} catch (Exception e) {
e.printStackTrace();
}
}
}
} else if (databaseObject instanceof Connector) {
Connector connector = (Connector) databaseObject;
// Open connector editor
if (projectLoadingJob != null && connector.isDefault) {
projectLoadingJob.setDefaultConnectorTreeObject((ConnectorTreeObject) databaseObjectTreeObject);
}
// Traces
if (connector instanceof JavelinConnector) {
String projectName = databaseObject.getProject().getName();
if (projectLoadingJob == null) {
if (MigrationManager.isProjectMigrated(projectName)) {
UnloadedProjectTreeObject unloadedProjectTreeObject = new UnloadedProjectTreeObject(databaseObjectTreeObject.viewer, projectName);
this.projectLoadingJob = new ProjectLoadingJob(databaseObjectTreeObject.viewer, unloadedProjectTreeObject);
this.projectLoadingJob.loadTrace(databaseObjectTreeObject, new File(Engine.projectDir(projectName) + "/Traces/" + connector.getName()));
}
}
if (projectLoadingJob != null) {
projectLoadingJob.loadTrace(databaseObjectTreeObject, new File(Engine.projectDir(projectName) + "/Traces/" + connector.getName()));
}
}
} else if (databaseObject instanceof Transaction) {
Transaction transaction = (Transaction) databaseObject;
// Functions
List<HandlersDeclarationTreeObject> treeObjects = new LinkedList<HandlersDeclarationTreeObject>();
String line, lineReaded;
int lineNumber = 0;
BufferedReader br = new BufferedReader(new StringReader(transaction.handlers));
line = br.readLine();
while (line != null) {
lineReaded = line.trim();
lineNumber++;
if (lineReaded.startsWith("function ")) {
try {
String functionName = lineReaded.substring(9, lineReaded.indexOf(')') + 1);
HandlersDeclarationTreeObject handlersDeclarationTreeObject = null;
if (functionName.endsWith(JavelinTransaction.EVENT_ENTRY_HANDLER + "()")) {
handlersDeclarationTreeObject = new HandlersDeclarationTreeObject(viewer, functionName, HandlersDeclarationTreeObject.TYPE_FUNCTION_SCREEN_CLASS_ENTRY, lineNumber);
} else if (functionName.endsWith(JavelinTransaction.EVENT_EXIT_HANDLER + "()")) {
handlersDeclarationTreeObject = new HandlersDeclarationTreeObject(viewer, functionName, HandlersDeclarationTreeObject.TYPE_FUNCTION_SCREEN_CLASS_EXIT, lineNumber);
} else {
handlersDeclarationTreeObject = new HandlersDeclarationTreeObject(viewer, functionName, HandlersDeclarationTreeObject.TYPE_OTHER, lineNumber);
}
if (handlersDeclarationTreeObject != null) {
treeObjects.add(handlersDeclarationTreeObject);
}
} catch (StringIndexOutOfBoundsException e) {
throw new EngineException("Exception in reading line of a transaction", e);
}
}
line = br.readLine();
}
if (treeObjects.size() != 0) {
ObjectsFolderTreeObject objectsFolderTreeObject = new ObjectsFolderTreeObject(viewer, ObjectsFolderTreeObject.FOLDER_TYPE_FUNCTIONS);
databaseObjectTreeObject.addChild(objectsFolderTreeObject);
for (HandlersDeclarationTreeObject handlersDeclarationTreeObject : treeObjects) {
objectsFolderTreeObject.addChild(handlersDeclarationTreeObject);
}
}
} else if (databaseObject instanceof Sheet) {
addTemplates((Sheet) databaseObject, databaseObjectTreeObject);
} else if (databaseObject instanceof ITablesProperty) {
ITablesProperty iTablesProperty = (ITablesProperty) databaseObject;
String[] tablePropertyNames = iTablesProperty.getTablePropertyNames();
for (int i = 0; i < tablePropertyNames.length; i++) {
String tablePropertyName = tablePropertyNames[i];
String tableRenderer = iTablesProperty.getTableRenderer(tablePropertyName);
XMLVector<XMLVector<Object>> xmlv = iTablesProperty.getTableData(tablePropertyName);
if (tableRenderer.equals("XMLTableDescriptionTreeObject")) {
XMLTableDescriptionTreeObject propertyXMLTableTreeObject = new XMLTableDescriptionTreeObject(viewer, tablePropertyName, xmlv, databaseObjectTreeObject);
databaseObjectTreeObject.addChild(propertyXMLTableTreeObject);
} else if (tableRenderer.equals("XMLRecordDescriptionTreeObject")) {
XMLRecordDescriptionTreeObject propertyXMLRecordTreeObject = new XMLRecordDescriptionTreeObject(viewer, tablePropertyName, xmlv, databaseObjectTreeObject);
databaseObjectTreeObject.addChild(propertyXMLRecordTreeObject);
}
}
}
monitor.worked(1);
// children cannot be added in the current virtual folder
this.currentTreeFolder = null;
super.walk(databaseObject);
// restore recursion parameters
this.parentTreeObject = parentTreeObject;
this.projectLoadingJob = projectLoadingJob;
// restore sibling parameters
this.currentTreeFolder = currentTreeFolder;
}
}.init(parentDatabaseObject, parentTreeObject, projectLoadingJob);
} catch (EngineException e) {
throw e;
} catch (Exception e) {
throw new EngineException("Exception in copyDatabaseObject", e);
}
}
use of com.twinsoft.convertigo.beans.core.UrlMappingParameter in project convertigo by convertigo.
the class OperationImportParametersFromVariablesAction method run.
public void run() {
Display display = Display.getDefault();
Cursor waitCursor = new Cursor(display, SWT.CURSOR_WAIT);
Shell shell = getParentShell();
shell.setCursor(waitCursor);
try {
ProjectExplorerView explorerView = getProjectExplorerView();
if (explorerView != null) {
TreeObject treeObject = explorerView.getFirstSelectedTreeObject();
Object databaseObject = treeObject.getObject();
if ((databaseObject != null) && (databaseObject instanceof UrlMappingOperation)) {
UrlMappingOperation operation = (UrlMappingOperation) databaseObject;
String targetRequestable = operation.getTargetRequestable();
if (!targetRequestable.isEmpty()) {
StringTokenizer st = new StringTokenizer(targetRequestable, ".");
int count = st.countTokens();
String projectName = st.nextToken();
String sequenceName = count == 2 ? st.nextToken() : "";
String connectorName = count == 3 ? st.nextToken() : "";
String transactionName = count == 3 ? st.nextToken() : "";
Project project = Engine.theApp.databaseObjectsManager.getProjectByName(projectName);
RequestableObject requestableObject = null;
if (sequenceName.isEmpty()) {
requestableObject = project.getConnectorByName(connectorName).getTransactionByName(transactionName);
} else {
requestableObject = project.getSequenceByName(sequenceName);
}
if (requestableObject != null && requestableObject instanceof IVariableContainer) {
IVariableContainer variableContainer = (IVariableContainer) requestableObject;
for (Variable variable : variableContainer.getVariables()) {
String variableName = variable.getName();
Object variableValue = variable.getValueOrNull();
UrlMappingParameter parameter = null;
try {
parameter = operation.getParameterByName(variableName);
} catch (Exception e) {
}
if (parameter == null) {
if (operation instanceof PostOperation || operation instanceof PutOperation)
parameter = new FormParameter();
else
parameter = new QueryParameter();
parameter.setName(variableName);
parameter.setComment(variable.getComment());
parameter.setArray(false);
parameter.setExposed(((RequestableVariable) variable).isWsdl());
parameter.setMultiValued(variable.isMultiValued());
parameter.setRequired(variable.isRequired());
parameter.setValueOrNull(!variable.isMultiValued() ? variableValue : null);
parameter.setMappedVariableName(variableName);
parameter.bNew = true;
parameter.hasChanged = true;
operation.add(parameter);
operation.hasChanged = true;
}
}
if (operation.hasChanged) {
explorerView.reloadTreeObject(treeObject);
StructuredSelection structuredSelection = new StructuredSelection(treeObject);
ConvertigoPlugin.getDefault().getPropertiesView().selectionChanged((IWorkbenchPart) explorerView, structuredSelection);
}
}
} else {
throw new ConvertigoException("Operation has no target requestable : please select one first.");
}
}
}
} catch (Throwable e) {
ConvertigoPlugin.logException(e, "Unable to import variables as new parameters in operation!");
} finally {
shell.setCursor(null);
waitCursor.dispose();
}
}
use of com.twinsoft.convertigo.beans.core.UrlMappingParameter in project convertigo by convertigo.
the class ChangeToHeaderParameterAction method run.
@Override
public void run() {
Display display = Display.getDefault();
Cursor waitCursor = new Cursor(display, SWT.CURSOR_WAIT);
Shell shell = getParentShell();
shell.setCursor(waitCursor);
try {
ProjectExplorerView explorerView = getProjectExplorerView();
if (explorerView != null) {
TreeObject treeObject = explorerView.getFirstSelectedTreeObject();
Object databaseObject = treeObject.getObject();
if ((databaseObject != null) && (databaseObject instanceof UrlMappingParameter)) {
UrlMappingParameter parameter = (UrlMappingParameter) databaseObject;
TreeParent treeParent = treeObject.getParent();
DatabaseObjectTreeObject parentTreeObject = null;
if (treeParent instanceof DatabaseObjectTreeObject)
parentTreeObject = (DatabaseObjectTreeObject) treeParent;
else
parentTreeObject = (DatabaseObjectTreeObject) treeParent.getParent();
if (parentTreeObject != null) {
// Create new Header parameter
HeaderParameter headerParameter = new HeaderParameter();
if (DatabaseObjectsManager.acceptDatabaseObjects(parameter.getParent(), headerParameter)) {
headerParameter.setComment(parameter.getComment());
headerParameter.setInputType(parameter.getInputType());
headerParameter.setArray(parameter.isArray());
headerParameter.setExposed(parameter.isExposed());
headerParameter.setMultiValued(parameter.isMultiValued());
headerParameter.setRequired(parameter.isRequired());
headerParameter.setValueOrNull(parameter.getValueOrNull());
headerParameter.setMappedVariableName(parameter.getMappedVariableName());
headerParameter.bNew = true;
headerParameter.hasChanged = true;
// Add new parameter to parent operation
UrlMappingOperation operation = (UrlMappingOperation) parameter.getParent();
operation.changeTo(headerParameter);
// Add new parameter in Tree
UrlMappingParameterTreeObject parameterTreeObject = new UrlMappingParameterTreeObject(explorerView.viewer, headerParameter);
treeParent.addChild(parameterTreeObject);
// Delete old parameter
parameter.delete();
// Rename new parameter
headerParameter.setName(parameter.getName());
// Reload in tree
parentTreeObject.hasBeenModified(true);
explorerView.reloadTreeObject(parentTreeObject);
explorerView.setSelectedTreeObject(explorerView.findTreeObjectByUserObject(headerParameter));
} else {
throw new EngineException("You cannot paste to a " + parameter.getParent().getClass().getSimpleName() + " a database object of type " + headerParameter.getClass().getSimpleName());
}
}
}
}
} catch (Throwable e) {
ConvertigoPlugin.logException(e, "Unable to change to Header parameter!");
} finally {
shell.setCursor(null);
waitCursor.dispose();
}
}
Aggregations