generate sp; added reserved words support; added escape functions

src/com/rthoni/intellij/codefromds/DataAccess/DataSourcesDataAccess.java

                 columnDataSourceDbo.data.setSqlType(type);
                 columnDataSourceDbo.data.setDefaultValue(column.getDefault());
                 columnDataSourceDbo.data.setPrimary(DasUtil.isPrimary(column));
-                columnDataSourceDbo.data.setSelected(false);
-                columnDataSourceDbo.data.setTypeNotNull(false);
-                columnDataSourceDbo.data.setType(null);
                 tableDataSourceDbo.data.addColumn(columnDataSourceDbo.data);
             }
         });
             if (dasObject instanceof DbTable) {
                 DbTable table = (DbTable) dasObject;
                 tableDataSourceDbo.data = dataSourceDbo.findTable(table.getName());
-                System.out.println("Table: " + tableDataSourceDbo.data.getName());
+//                System.out.println("Table: " + tableDataSourceDbo.data.getName());
                 DasUtil.getForeignKeys(table).forEach(fk ->
                 {
                     if (fk.getRefTable() == null) {
                     srcTable.addSourceForeignKey(fkDbo);
                     targetTable.addTargetForeignKey(fkDbo);
 
-                    System.out.println("FK: " + fkDbo.getName());
+//                    System.out.println("FK: " + fkDbo.getName());
                 });
             }
             else if (dasObject instanceof DbColumn) {
                 DbColumn column = (DbColumn) dasObject;
                 columnDataSourceDbo.data = tableDataSourceDbo.data.findColumn(column.getName());
-                System.out.println("Column: " + columnDataSourceDbo.data.getName());
+//                System.out.println("Column: " + columnDataSourceDbo.data.getName());
             }
             else if (dasObject instanceof DbIndex) {
                 DbIndex index = (DbIndex) dasObject;
-                System.out.println("Index: " + index.getName());
+//                System.out.println("Index: " + index.getName());
             }
             else if (dasObject instanceof DbConstraint) {
                 DbConstraint constraint = (DbConstraint) dasObject;
-                System.out.println("Constraint: " + constraint.getName());
+//                System.out.println("Constraint: " + constraint.getName());
             }
             else if (dasObject instanceof DbRoutine) {
                 DbRoutine sp = (DbRoutine) dasObject;
-                System.out.println("SP: " + sp.getName());
-            }
-            else {
-                System.out.println(dasObject.getClass().getName());
+                StoredProcedureDbo spDbo = new StoredProcedureDbo();
+                spDbo.setSelected(true);
+                dataSourceDbo.addStoredProcedure(spDbo);
+                spDbo.setName(sp.getName());
+//                System.out.println("SP: " + spDbo.getName());
+                DataHolder<Integer> position = new DataHolder<>();
+                position.data = 0;
+                sp.getArguments().forEach(o ->
+                {
+                    SqlTypeDbo sqlTypeDbo = new SqlTypeDbo();
+                    sqlTypeDbo.setType(o.getDataType().typeName);
+                    sqlTypeDbo.setVagueArg(o.getDataType().vagueArg);
+
+                    if (o.getArgumentDirection().isReturnOrResult()) {
+                        spDbo.setSqlType(sqlTypeDbo);
+//                        System.out.println("SP return: " + sqlTypeDbo.getType());
+                    }
+                    else {
+                        StoredProcedureArgDbo argDbo = new StoredProcedureArgDbo();
+                        argDbo.setName(o.getName().isEmpty() ? "arg" + position.data : o.getName());
+                        argDbo.setSqlType(sqlTypeDbo);
+                        argDbo.setOut(o.getArgumentDirection().isOut());
+                        spDbo.addArgument(argDbo);
+                        ++position.data;
+//                        System.out.println("SP arg: " + o.getName());
+                    }
+                });
             }
+//            else {
+//                System.out.println(dasObject.getClass().getName());
+//            }
         });
         return dataSourceDbo;
     }

src/com/rthoni/intellij/codefromds/business/Generator.java

 import com.rthoni.intellij.codefromds.dbo.options.GenerateOptions;
 import com.rthoni.intellij.codefromds.dbo.options.TableSelection;
 import com.rthoni.intellij.codefromds.dbo.options.TypesCastOptions;
-import com.rthoni.intellij.codefromds.dbo.template.ColumnDataSourceDbo;
-import com.rthoni.intellij.codefromds.dbo.template.DataSourceDbo;
-import com.rthoni.intellij.codefromds.dbo.template.SqlTypeDbo;
-import com.rthoni.intellij.codefromds.dbo.template.TableDataSourceDbo;
+import com.rthoni.intellij.codefromds.dbo.template.*;
+import groovy.json.StringEscapeUtils;
 import org.json.JSONArray;
 import org.json.JSONObject;
 import org.jtwig.JtwigModel;
 import org.jtwig.JtwigTemplate;
+import org.jtwig.environment.EnvironmentConfiguration;
+import org.jtwig.environment.EnvironmentConfigurationBuilder;
+import org.jtwig.functions.FunctionRequest;
+import org.jtwig.functions.SimpleJtwigFunction;
 
 import java.io.File;
 import java.io.FileOutputStream;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Vector;
+import java.util.function.Consumer;
 
 /**
  * Created by robin on 11/15/16.
         return options;
     }
 
-    public static String convertSqlType(SqlTypeDbo type, TypesCastOptions options)
+    public static String escapeReservedWords(String id, TypesCastOptions options)
     {
+        if (options.getReservedWords().contains(id)) {
+            return "_" + id;
+        }
+        return id;
+    }
+
+    public static String escapeString(String str)
+    {
+        return StringEscapeUtils.escapeJava(str);
+    }
+
+    public static void convertSqlType(SqlTypeDbo type, TypesCastOptions options)
+    {
+        if (type == null) {
+            return;
+        }
         boolean isArray = type.getType().endsWith("[]");
         String sqlTypeName = isArray ? type.getType().substring(0, type.getType().length() - 2) : type.getType();
-        String typeName = type.getType();
+        String typeName = null;
         HashMap<String, HashMap<String, String>> types = options.getTypes();
 
         if (types.containsKey(sqlTypeName)) {
                 typeName = subtype.get("*");
             }
         }
+        if (typeName == null) {
+            typeName = types.get("*").get("*");
+        }
         if (isArray) {
             typeName = options.getArrayTemplate().replace("%t", typeName);
         }
-        return typeName;
+        type.setLanguageType(typeName);
+        type.setLanguageTypeNotNull(options.getNonNullableTypes().contains(typeName));
     }
-//
+
 //    public static boolean isUnionSame(List<ColumnDataSourceDbo> part1, List<ColumnDataSourceDbo> part2, List<ColumnDataSourceDbo> list2)
 //    {
 //        List<ColumnDataSourceDbo> list1 = new Vector<>(part1);
                 ColumnSelection columnSelection = tableSelection.getColumns().stream()
                         .filter(c -> c.getColumn().getName().equals(column.getName()))
                         .findFirst().orElse(null);
-                column.setType(convertSqlType(column.getSqlType(), types));
-                column.setTypeNotNull(types.getNonNullableTypes().contains(column.getType()));
+                convertSqlType(column.getSqlType(), types);
                 column.setSelected(columnSelection.isSelected());
             }
         }
 
+        for (StoredProcedureDbo spDbo : dataSourceDbo.getStoredProcedures())
+        {
+            convertSqlType(spDbo.getSqlType(), types);
+            for (StoredProcedureArgDbo arg : spDbo.getArguments()) {
+                convertSqlType(arg.getSqlType(), types);
+            }
+        }
+
         return dataSourceDbo;
     }
 
         }
         dbo.setNonNullableTypes(nonNullableTypes);
 
+        List<String> reservedWords = new Vector<>();
+        array = obj.getJSONArray("reserved-words");
+        for (int i = 0; i < array.length(); ++i) {
+            reservedWords.add(array.getString(i));
+        }
+        dbo.setReservedWords(reservedWords);
+
         dbo.setArrayTemplate(obj.getString("arrayTemplate"));
 
         return dbo;
     }
 
-    public static void generateFile(String templatePath, String outputFile, DataSourceDbo dataSource, TableDataSourceDbo table) throws IOException
+    public static void generateFile(String templatePath, String outputFile, DataSourceDbo dataSource,
+                                    TableDataSourceDbo table, TypesCastOptions options) throws IOException
     {
         String data = Helper.readFile(templatePath);
 
         FileOutputStream file = new FileOutputStream(outputFile);
 
-        JtwigTemplate template = JtwigTemplate.inlineTemplate(data);
-        JtwigModel model = JtwigModel.newModel().with("dataSource", dataSource).with("table", table);
+        final SimpleJtwigFunction escapeReservedWords = new SimpleJtwigFunction() {
+            @Override
+            public String name() {
+                return "escapeReservedWords";
+            }
+
+            @Override
+            public Object execute(FunctionRequest functionRequest) {
+                String arg = (String) functionRequest.get(0);
+                String v = escapeReservedWords(arg, options);
+                return v;
+            }
+        };
+
+        final SimpleJtwigFunction escapeString = new SimpleJtwigFunction() {
+            @Override
+            public String name() {
+                return "escapeString";
+            }
+
+            @Override
+            public Object execute(FunctionRequest functionRequest) {
+                Object obj = functionRequest.get(0);
+                if (obj == null)
+                {
+                    return null;
+                }
+                String arg = (String) obj;
+                String v = escapeString(arg);
+                return v;
+            }
+        };
+
+        final EnvironmentConfiguration configuration = EnvironmentConfigurationBuilder
+                .configuration()
+                .functions()
+                .add(escapeReservedWords)
+                .add(escapeString)
+                .and()
+                .build();
+
+        JtwigTemplate template = JtwigTemplate.inlineTemplate(data, configuration);
+        JtwigModel model = JtwigModel.newModel()
+                .with("dataSource", dataSource)
+                .with("table", table);
 
         template.render(model, file);
 
 
         DataSourceDbo dbo = convertOptions(options, types);
 
-        generateFile(dataSourceTemplateAbsolutePath, dataSourceAbsolutePath, dbo, null);
+        generateFile(dataSourceTemplateAbsolutePath, dataSourceAbsolutePath, dbo, null, types);
         for (TableDataSourceDbo table : dbo.getTables()) {
             if (table.hasAny()) {
                 String filename = modelsAbsolutePath + File.separator + table.getName() + "." + options.getFilesExtension();
-                generateFile(modelsTemplateAbsolutePath, filename, dbo, table);
+                generateFile(modelsTemplateAbsolutePath, filename, dbo, table, types);
             }
         }
     }

src/com/rthoni/intellij/codefromds/dbo/options/TypesCastOptions.java

 
     private List<String> _nonNullableTypes;
 
+    private List<String> _reservedWords;
+
     public String getArrayTemplate() {
         return _arrayTemplate;
     }
     public void setNonNullableTypes(List<String> nonNullableTypes) {
         _nonNullableTypes = nonNullableTypes;
     }
+
+    public List<String> getReservedWords() {
+        return _reservedWords;
+    }
+
+    public void setReservedWords(List<String> reservedWords) {
+        _reservedWords = reservedWords;
+    }
 }

src/com/rthoni/intellij/codefromds/dbo/template/ColumnDataSourceDbo.java

 package com.rthoni.intellij.codefromds.dbo.template;
 
-import org.apache.commons.lang.StringEscapeUtils;
-
 /**
  * Created by robin on 11/18/16.
  */
 
     private boolean _isSelected;
 
-    private String _type;
-
     private SqlTypeDbo _sqlType;
 
     private boolean _notNull;
 
-    private boolean _typeNotNull;
-
     private String _defaultValue;
 
     public String getName() {
     }
 
     public String getType() {
-        return _type;
-    }
-
-    public void setType(String type) {
-        _type = type;
+        return _sqlType != null ? _sqlType.getLanguageType() : null;
     }
 
     public SqlTypeDbo getSqlType() {
     }
 
     public boolean isTypeNotNull() {
-        return _typeNotNull;
-    }
-
-    public void setTypeNotNull(boolean typeNotNull) {
-        _typeNotNull = typeNotNull;
+        return _sqlType != null && _sqlType.isLanguageTypeNotNull();
     }
 
     public String getDefaultValue() {
         return _defaultValue;
     }
 
-    public String getDefaultValueEscaped() {
-        return StringEscapeUtils.escapeJava(_defaultValue);
-    }
-
     public boolean hasDefaultValue()
     {
         return _defaultValue != null && !_defaultValue.equals("");

src/com/rthoni/intellij/codefromds/dbo/template/DataSourceDbo.java

 
     private List<TableDataSourceDbo> _tables = new Vector<>();
 
+    private List<StoredProcedureDbo> _storedProcedures = new Vector<>();
+
+    public List<StoredProcedureDbo> getStoredProcedures() {
+        return _storedProcedures;
+    }
+
+    public void addStoredProcedure(StoredProcedureDbo storedProcedures) {
+        _storedProcedures.add(storedProcedures);
+    }
+
     public String getName() {
         return _name;
     }

src/com/rthoni/intellij/codefromds/dbo/template/SqlTypeDbo.java

 
     private String vagueArg;
 
+    private String _languageType;
+
+    private boolean _languageTypeNotNull;
+
     public String getType() {
         return _type;
     }
     public void setVagueArg(String vagueArg) {
         this.vagueArg = vagueArg;
     }
+
+    public String getLanguageType() {
+        return _languageType;
+    }
+
+    public void setLanguageType(String languageType) {
+        _languageType = languageType;
+    }
+
+    public boolean isLanguageTypeNotNull() {
+        return _languageTypeNotNull;
+    }
+
+    public void setLanguageTypeNotNull(boolean languageTypeNotNull) {
+        _languageTypeNotNull = languageTypeNotNull;
+    }
 }

src/com/rthoni/intellij/codefromds/dbo/template/StoredProcedureArgDbo.java

+package com.rthoni.intellij.codefromds.dbo.template;
+
+/**
+ * Created by robin on 4/13/17.
+ */
+public class StoredProcedureArgDbo {
+
+    private String name;
+
+    private SqlTypeDbo _sqlType;
+
+    private boolean _isOut;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getType() {
+        return _sqlType != null ? _sqlType.getLanguageType() : null;
+    }
+
+    public SqlTypeDbo getSqlType() {
+        return _sqlType;
+    }
+
+    public void setSqlType(SqlTypeDbo sqlType) {
+        _sqlType = sqlType;
+    }
+
+    public boolean isOut() {
+        return _isOut;
+    }
+
+    public void setOut(boolean out) {
+        _isOut = out;
+    }
+}

src/com/rthoni/intellij/codefromds/dbo/template/StoredProcedureDbo.java

+package com.rthoni.intellij.codefromds.dbo.template;
+
+import java.util.List;
+import java.util.Vector;
+
+/**
+ * Created by robin on 4/13/17.
+ */
+public class StoredProcedureDbo {
+
+    private String _name;
+
+    private List<StoredProcedureArgDbo> _arguments = new Vector<>();
+
+    private SqlTypeDbo _sqlType;
+
+    private boolean _isSelected;
+
+    public String getName() {
+        return _name;
+    }
+
+    public void setName(String name) {
+        _name = name;
+    }
+
+    public List<StoredProcedureArgDbo> getArguments() {
+        return _arguments;
+    }
+
+    public void addArgument(StoredProcedureArgDbo arguments) {
+        _arguments.add(arguments);
+    }
+
+    public String getType() {
+        return _sqlType != null ? _sqlType.getLanguageType() : null;
+    }
+
+    public SqlTypeDbo getSqlType() {
+        return _sqlType;
+    }
+
+    public void setSqlType(SqlTypeDbo sqlType) {
+        _sqlType = sqlType;
+    }
+
+    public boolean isSelected() {
+        return _isSelected;
+    }
+
+    public void setSelected(boolean selected) {
+        _isSelected = selected;
+    }
+}