Examples with Pair com.abubusoft.kripton.common.Pair used on opensource projects

Example 1 with Pair

use of com.abubusoft.kripton.common.Pair in project kripton by xcesco.

the class ModifyRawHelper method generateJavaDoc.

/**
 * @param daoDefinition
 * @param method
 * @param methodBuilder
 * @param updateMode
 * @param whereCondition
 * @param where
 * @param methodParams
 * @param updateableParams
 *
 * @return sql generated
 */
private void generateJavaDoc(final SQLiteModelMethod method, MethodSpec.Builder methodBuilder, boolean updateMode, String whereCondition, Pair<String, List<Pair<String, TypeName>>> where, List<Pair<String, TypeName>> methodParams) {
    final List<SQLProperty> updatedProperties = new ArrayList<>();
    final One<Boolean> onWhereStatement = new One<Boolean>(false);
    String sqlModify = JQLChecker.getInstance().replace(method, method.jql, new JQLReplacerListenerImpl(method) {

        @Override
        public void onWhereStatementBegin(Where_stmtContext ctx) {
            onWhereStatement.value0 = true;
        }

        @Override
        public void onWhereStatementEnd(Where_stmtContext ctx) {
            onWhereStatement.value0 = false;
        }

        @Override
        public String onColumnNameToUpdate(String columnName) {
            SQLProperty tempProperty = currentEntity.get(columnName);
            AssertKripton.assertTrueOrUnknownPropertyInJQLException(tempProperty != null, method, columnName);
            updatedProperties.add(tempProperty);
            return tempProperty.columnName;
        }

        @Override
        public String onColumnName(String columnName) {
            SQLProperty tempProperty = currentEntity.get(columnName);
            AssertKripton.assertTrueOrUnknownPropertyInJQLException(tempProperty != null, method, columnName);
            return tempProperty.columnName;
        }

        @Override
        public String onBindParameter(String bindParameterName) {
            String resolvedParamName = method.findParameterNameByAlias(bindParameterName);
            AssertKripton.assertTrueOrUnknownParamInJQLException(resolvedParamName != null, method, bindParameterName);
            if (onWhereStatement.value0) {
                return "${" + bindParameterName + "}";
            } else {
                return ":" + bindParameterName;
            }
        }
    });
    if (updateMode) {
        methodBuilder.addJavadoc("<h2>SQL update</h2>\n");
        methodBuilder.addJavadoc("<pre>$L</pre>\n", sqlModify);
        methodBuilder.addJavadoc("\n");
        // list of updated fields
        methodBuilder.addJavadoc("<h2>Updated columns:</h2>\n");
        methodBuilder.addJavadoc("<ul>\n");
        for (SQLProperty property : updatedProperties) {
            methodBuilder.addJavadoc("\t<li>$L</li>\n", property.columnName);
        // methodBuilder.addJavadoc("<dd>is binded to query's parameter
        // <strong>$L</strong> and method's parameter
        // <strong>$L</strong></dd>\n", "${" + resolvedName + "}",
        // property.value0);
        }
        methodBuilder.addJavadoc("</ul>");
        methodBuilder.addJavadoc("\n\n");
    } else {
        methodBuilder.addJavadoc("<h2>SQL delete</h2>\n");
        methodBuilder.addJavadoc("<pre>$L</pre>\n", sqlModify);
        methodBuilder.addJavadoc("\n\n");
    }
    // list of where parameter
    methodBuilder.addJavadoc("<h2>Where parameters:</h2>\n");
    methodBuilder.addJavadoc("<dl>\n");
    for (Pair<String, TypeName> property : where.value1) {
        String rawName = method.findParameterNameByAlias(property.value0);
        methodBuilder.addJavadoc("\t<dt>$L</dt>", "${" + property.value0 + "}");
        methodBuilder.addJavadoc("<dd>is mapped to method's parameter <strong>$L</strong></dd>\n", rawName);
    }
    methodBuilder.addJavadoc("</dl>");
    methodBuilder.addJavadoc("\n\n");
    if (method.hasDynamicWhereConditions()) {
        methodBuilder.addJavadoc("<dl>\n");
        methodBuilder.addJavadoc("<dt>$L</dt><dd>is part of where conditions resolved at runtime. In above SQL it is displayed as #{$L}</dd>", method.dynamicWhereParameterName, JQLDynamicStatementType.DYNAMIC_WHERE);
        methodBuilder.addJavadoc("\n</dl>");
        methodBuilder.addJavadoc("\n\n");
    }
    // dynamic conditions
    if (method.hasDynamicWhereConditions()) {
        methodBuilder.addJavadoc("<h2>Method's parameters and associated dynamic parts:</h2>\n");
        methodBuilder.addJavadoc("<dl>\n");
        if (method.hasDynamicWhereConditions()) {
            methodBuilder.addJavadoc("<dt>$L</dt><dd>is part of where conditions resolved at runtime. In above SQL it is displayed as #{$L}</dd>", method.dynamicWhereParameterName, JQLDynamicStatementType.DYNAMIC_WHERE);
        }
        methodBuilder.addJavadoc("</dl>");
        methodBuilder.addJavadoc("\n\n");
    }
    // method parameters
    if (methodParams.size() > 0) {
        for (Pair<String, TypeName> param : methodParams) {
            String resolvedName = method.findParameterAliasByName(param.value0);
            methodBuilder.addJavadoc("@param $L", param.value0);
            if (method.isThisDynamicWhereConditionsName(param.value0)) {
                methodBuilder.addJavadoc("\n\tis used as dynamic where conditions\n");
            } else if (where.value1.contains(new Pair<>(resolvedName, param.value1))) {
                methodBuilder.addJavadoc("\n\tis used as where parameter <strong>$L</strong>\n", "${" + resolvedName + "}");
            } else {
                methodBuilder.addJavadoc("\n\tis used as updated field <strong>$L</strong>\n", resolvedName);
            }
        }
    }
    // if true, field must be associate to ben attributes
    TypeName returnType = method.getReturnClass();
    // define return value
    if (returnType == TypeName.VOID) {
    } else {
        methodBuilder.addJavadoc("\n");
        if (isIn(returnType, Boolean.TYPE, Boolean.class)) {
            if (updateMode) {
                methodBuilder.addJavadoc("@return <code>true</code> if record is updated, <code>false</code> otherwise");
            } else {
                methodBuilder.addJavadoc("@return <code>true</code> if record is deleted, <code>false</code> otherwise");
            }
        // methodBuilder.addCode("return result!=0;\n");
        } else if (isIn(returnType, Long.TYPE, Long.class, Integer.TYPE, Integer.class, Short.TYPE, Short.class)) {
            if (updateMode) {
                methodBuilder.addJavadoc("@return number of updated records");
            } else {
                methodBuilder.addJavadoc("@return number of deleted records");
            }
        // methodBuilder.addCode("return result;\n");
        } else {
            // more than one listener found
            throw (new InvalidMethodSignException(method, "invalid return type"));
        }
        methodBuilder.addJavadoc("\n");
    }
}

Example 2 with Pair

use of com.abubusoft.kripton.common.Pair in project kripton by xcesco.

the class ModifyRawHelper method generateJavaDoc.

private void generateJavaDoc(final SQLiteModelMethod method, Builder methodBuilder, boolean updateMode) {
    List<Pair<String, TypeName>> methodParams = method.getParameters();
    final List<SQLProperty> updatedProperties = new ArrayList<>();
    final List<Pair<String, TypeName>> methodParamsUsedAsParameter = new ArrayList<>();
    // new
    String sqlModify = JQLChecker.getInstance().replace(method, method.jql, new JQLReplacerListenerImpl(method) {

        @Override
        public String onColumnNameToUpdate(String columnName) {
            SQLProperty tempProperty = currentEntity.get(columnName);
            AssertKripton.assertTrueOrUnknownPropertyInJQLException(tempProperty != null, method, columnName);
            updatedProperties.add(tempProperty);
            return tempProperty.columnName;
        }

        @Override
        public String onColumnName(String columnName) {
            SQLProperty tempProperty = currentEntity.get(columnName);
            AssertKripton.assertTrueOrUnknownPropertyInJQLException(tempProperty != null, method, columnName);
            return tempProperty.columnName;
        }

        @Override
        public String onBindParameter(String bindParameterName) {
            String resolvedParamName = method.findParameterNameByAlias(bindParameterName);
            AssertKripton.assertTrueOrUnknownParamInJQLException(resolvedParamName != null, method, bindParameterName);
            methodParamsUsedAsParameter.add(new Pair<>(resolvedParamName, method.findParameterType(resolvedParamName)));
            return "${" + bindParameterName + "}";
        }
    });
    if (updateMode) {
        methodBuilder.addJavadoc("<h2>SQL update</h2>\n");
        methodBuilder.addJavadoc("<pre>$L</pre>\n", sqlModify);
        methodBuilder.addJavadoc("\n");
        // list of updated fields
        methodBuilder.addJavadoc("<h2>Updated columns:</h2>\n");
        methodBuilder.addJavadoc("<ul>\n");
        for (SQLProperty property : updatedProperties) {
            methodBuilder.addJavadoc("\t<li>$L</li>\n", property.columnName);
        }
        methodBuilder.addJavadoc("</ul>");
        methodBuilder.addJavadoc("\n\n");
    } else {
        methodBuilder.addJavadoc("<h2>SQL delete</h2>\n");
        methodBuilder.addJavadoc("<pre>$L</pre>\n", sqlModify);
        methodBuilder.addJavadoc("\n\n");
    }
    // list of where parameter
    methodBuilder.addJavadoc("<h2>Parameters:</h2>\n");
    methodBuilder.addJavadoc("<dl>\n");
    for (Pair<String, TypeName> property : methodParamsUsedAsParameter) {
        String rawName = method.findParameterNameByAlias(property.value0);
        methodBuilder.addJavadoc("\t<dt>$L</dt>", "${" + property.value0 + "}");
        methodBuilder.addJavadoc("<dd>is mapped to method's parameter <strong>$L</strong></dd>\n", rawName);
    }
    methodBuilder.addJavadoc("</dl>");
    methodBuilder.addJavadoc("\n\n");
    if (method.hasDynamicWhereConditions()) {
        methodBuilder.addJavadoc("<dl>\n");
        methodBuilder.addJavadoc("<dt>$L</dt><dd>is part of where conditions resolved at runtime. In above SQL it is displayed as #{$L}</dd>", method.dynamicWhereParameterName, JQLDynamicStatementType.DYNAMIC_WHERE);
        methodBuilder.addJavadoc("\n</dl>");
        methodBuilder.addJavadoc("\n\n");
    }
    // dynamic conditions
    if (method.hasDynamicWhereConditions()) {
        methodBuilder.addJavadoc("<h2>Method's parameters and associated dynamic parts:</h2>\n");
        methodBuilder.addJavadoc("<dl>\n");
        if (method.hasDynamicWhereConditions()) {
            methodBuilder.addJavadoc("<dt>$L</dt><dd>is part of where conditions resolved at runtime. In above SQL it is displayed as #{$L}</dd>", method.dynamicWhereParameterName, JQLDynamicStatementType.DYNAMIC_WHERE);
        }
        methodBuilder.addJavadoc("</dl>");
        methodBuilder.addJavadoc("\n\n");
    }
    // method parameters
    if (methodParams.size() > 0) {
        for (Pair<String, TypeName> param : methodParams) {
            String resolvedName = method.findParameterAliasByName(param.value0);
            methodBuilder.addJavadoc("@param $L", param.value0);
            if (method.isThisDynamicWhereConditionsName(param.value0)) {
                methodBuilder.addJavadoc("\n\tis used as dynamic where conditions\n");
            } else {
                methodBuilder.addJavadoc("\n\tis used as for parameter <strong>$L</strong>\n", resolvedName);
            }
        }
    }
    // if true, field must be associate to ben attributes
    TypeName returnType = method.getReturnClass();
    // define return value
    if (returnType == TypeName.VOID) {
    } else {
        methodBuilder.addJavadoc("\n");
        if (isIn(returnType, Boolean.TYPE, Boolean.class)) {
            if (updateMode) {
                methodBuilder.addJavadoc("@return <code>true</code> if record is updated, <code>false</code> otherwise");
            } else {
                methodBuilder.addJavadoc("@return <code>true</code> if record is deleted, <code>false</code> otherwise");
            }
            methodBuilder.addCode("return result!=0;\n");
        } else if (isIn(returnType, Long.TYPE, Long.class, Integer.TYPE, Integer.class, Short.TYPE, Short.class)) {
            if (updateMode) {
                methodBuilder.addJavadoc("@return number of updated records");
            } else {
                methodBuilder.addJavadoc("@return number of deleted records");
            }
        // methodBuilder.addCode("return result;\n");
        } else {
            // more than one listener found
            throw (new InvalidMethodSignException(method, "invalid return type"));
        }
        methodBuilder.addJavadoc("\n");
    }
}

Example 3 with Pair

use of com.abubusoft.kripton.common.Pair in project kripton by xcesco.

the class SelectPaginatedResultHelper method generate.

@Override
public void generate(TypeSpec.Builder classBuilder, boolean mapFields, SQLiteModelMethod method) {
    SQLiteDaoDefinition daoDefinition = method.getParent();
    String pagedResultName = buildSpecializedPagedResultClass(classBuilder, method);
    Set<JQLProjection> fieldList = JQLChecker.getInstance().extractProjections(method, method.jql.value, daoDefinition.getEntity());
    {
        MethodSpec.Builder methodBuilder = generateMethodBuilder(method);
        // create PaginatedResult
        String separator = "";
        methodBuilder.addCode("$L paginatedResult=new $L(", pagedResultName, pagedResultName);
        for (Pair<String, TypeName> item : method.getParameters()) {
            // field
            methodBuilder.addCode(separator + "$L", item.value0);
            separator = ", ";
        }
        methodBuilder.addCode(");\n");
        generateCommonPart(method, classBuilder, methodBuilder, fieldList, selectType.isMapFields(), GenerationType.NO_CONTENT, null);
        methodBuilder.addStatement("return paginatedResult");
        classBuilder.addMethod(methodBuilder.build());
    }
    // generate paged result method
    {
        MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(method.getName()).addModifiers(Modifier.PRIVATE);
        generateMethodSignature(method, methodBuilder, TypeUtility.parameterizedTypeName(TypeUtility.className(List.class), TypeUtility.typeName(daoDefinition.getEntityClassName())), ParameterSpec.builder(TypeUtility.typeName(pagedResultName), "paginatedResult").build());
        generateCommonPart(method, classBuilder, methodBuilder, fieldList, selectType.isMapFields(), GenerationType.NO_METHOD_SIGN, null, JavadocPart.build(JavadocPartType.ADD_PARAMETER, "paginatedResult", "handler of paginated result"), JavadocPart.build(JavadocPartType.RETURN, "", "result list"));
        generateSpecializedPart(method, classBuilder, methodBuilder, fieldList, selectType.isMapFields());
        classBuilder.addMethod(methodBuilder.build());
    }
}

Example 4 with Pair

use of com.abubusoft.kripton.common.Pair in project kripton by xcesco.

the class MigrationSQLChecker method prepareParser.

protected Pair<ParserRuleContext, CommonTokenStream> prepareParser(final String jql) {
    JqlLexer lexer = new JqlLexer(CharStreams.fromString(jql));
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    JqlParser parser = new JqlParser(tokens);
    parser.removeErrorListeners();
    parser.addErrorListener(new JQLBaseErrorListener() {

        @Override
        public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) {
            AssertKripton.assertTrue(false, "unespected char at pos %s of SQL '%s'", charPositionInLine, jql);
        }
    });
    ParserRuleContext context = parser.parse();
    return new Pair<>(context, tokens);
}

Example 5 with Pair

use of com.abubusoft.kripton.common.Pair in project kripton by xcesco.

the class BindTableGenerator method visit.

private void visit(SQLiteDatabaseSchema schema, GeneratedTypeElement entity) throws Exception {
    int indexCounter = 0;
    // generate the class name that represents the table
    String classTableName = getTableClassName(entity.getSimpleName());
    PackageElement pkg = elementUtils.getPackageElement(entity.packageName);
    String packageName = pkg.isUnnamed() ? null : pkg.getQualifiedName().toString();
    AnnotationProcessorUtilis.infoOnGeneratedClasses(BindDataSource.class, packageName, classTableName);
    classBuilder = TypeSpec.classBuilder(classTableName).addModifiers(Modifier.PUBLIC).addSuperinterface(SQLiteTable.class);
    ;
    BindTypeContext context = new BindTypeContext(classBuilder, TypeUtility.typeName(packageName, classTableName), Modifier.STATIC, Modifier.PRIVATE);
    // javadoc for class
    classBuilder.addJavadoc("<p>");
    classBuilder.addJavadoc("\nEntity <code>$L</code> is associated to table <code>$L</code>\n", entity.getSimpleName(), entity.getTableName());
    classBuilder.addJavadoc("This class represents table associated to entity.\n");
    classBuilder.addJavadoc("</p>\n");
    JavadocUtility.generateJavadocGeneratedBy(classBuilder);
    classBuilder.addJavadoc(" @see $T\n", TypeUtility.className(entity.getName()));
    {
        // @formatter:off
        // table_name
        FieldSpec fieldSpec = FieldSpec.builder(String.class, "TABLE_NAME", Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL).initializer("\"$L\"", entity.getTableName()).addJavadoc("Costant represents typeName of table $L\n", entity.getTableName()).build();
        classBuilder.addField(fieldSpec);
    // @formatter:on
    }
    StringBuilder bufferTable = new StringBuilder();
    StringBuilder bufferForeignKey = new StringBuilder();
    // shared between create table and drop table
    StringBuilder bufferIndexesCreate = new StringBuilder();
    StringBuilder bufferDropTable = new StringBuilder();
    StringBuilder bufferIndexesDrop = new StringBuilder();
    bufferTable.append("CREATE TABLE " + entity.getTableName());
    // define column typeName set
    String separator = "";
    bufferTable.append(" (");
    // for each column, that need to be persisted on table
    for (SQLProperty item : entity.getCollection()) {
        bufferTable.append(separator);
        bufferTable.append(item.columnName);
        // every column is a long
        bufferTable.append(" " + SQLTransformer.lookup(TypeName.LONG).getColumnTypeAsString());
        switch(item.columnType) {
            case PRIMARY_KEY:
                bufferTable.append(" PRIMARY KEY AUTOINCREMENT");
                break;
            case UNIQUE:
                bufferTable.append(" UNIQUE");
                break;
            case INDEXED:
                bufferIndexesCreate.append(String.format(" CREATE INDEX idx_%s_%s ON %s(%s);", entity.getTableName(), item.columnName, entity.getTableName(), item.columnName));
                bufferIndexesDrop.append(String.format(" DROP INDEX IF EXISTS idx_%s_%s;", entity.getTableName(), item.columnName));
                break;
            case STANDARD:
                break;
        }
        boolean nullable = item.isNullable();
        // null
        if (!nullable && item.columnType != ColumnType.PRIMARY_KEY) {
            bufferTable.append(" NOT NULL");
        }
        // foreign key
        String foreignClassName = item.foreignClassName;
        if (item.hasForeignKeyClassName()) {
            SQLiteEntity reference = model.getEntity(foreignClassName);
            if (reference == null) {
                // check if we have a DAO associated into DataSource
                // definition
                boolean found = false;
                for (SQLiteDaoDefinition daoDefinition : schema.getCollection()) {
                    if (daoDefinition.getEntityClassName().equals(foreignClassName)) {
                        found = true;
                    }
                }
                if (!found) {
                    throw new NoDaoElementFound(schema, TypeUtility.className(foreignClassName));
                } else {
                    throw new InvalidBeanTypeException(item, foreignClassName);
                }
            }
            bufferForeignKey.append(", FOREIGN KEY(" + item.columnName + ") REFERENCES " + reference.getTableName() + "(" + reference.getPrimaryKey().columnName + ")");
            if (item.onDeleteAction != ForeignKeyAction.NO_ACTION) {
                bufferForeignKey.append(" ON DELETE " + item.onDeleteAction.toString().replaceAll("_", " "));
            }
            if (item.onUpdateAction != ForeignKeyAction.NO_ACTION) {
                bufferForeignKey.append(" ON UPDATE " + item.onUpdateAction.toString().replaceAll("_", " "));
            }
            // Same entity can not be own dependency.
            if (!entity.getClassName().equals(TypeUtility.typeName(reference.getElement()))) {
                entity.referedEntities.add(reference);
            }
        }
        separator = ", ";
    }
    // add foreign key
    bufferTable.append(bufferForeignKey.toString());
    bufferTable.append(");");
    // add indexes creation one table
    if (bufferIndexesCreate.length() > 0) {
        bufferTable.append(bufferIndexesCreate.toString());
    }
    // add single column indexes (NOT UNIQUE)
    {
        Pair<String, String> multiIndexes = buldIndexes(entity, false, indexCounter);
        if (!StringUtils.isEmpty(multiIndexes.value0)) {
            bufferTable.append(multiIndexes.value0 + ";");
            bufferIndexesDrop.append(multiIndexes.value1 + ";");
        }
    }
    {
        // create table SQL
        // @formatter:off
        FieldSpec.Builder fieldSpec = FieldSpec.builder(String.class, "CREATE_TABLE_SQL").addModifiers(Modifier.STATIC, Modifier.FINAL, Modifier.PUBLIC);
        // @formatter:on
        // @formatter:off
        fieldSpec.addJavadoc("<p>\nDDL to create table $L\n</p>\n", entity.getTableName());
        fieldSpec.addJavadoc("\n<pre>$L</pre>\n", bufferTable.toString());
        // @formatter:on
        classBuilder.addField(fieldSpec.initializer("$S", bufferTable.toString()).build());
    }
    // with tables
    if (bufferIndexesDrop.length() > 0) {
        bufferDropTable.append(bufferIndexesDrop.toString());
    }
    bufferDropTable.append("DROP TABLE IF EXISTS " + entity.getTableName() + ";");
    {
        // @formatter:off
        FieldSpec fieldSpec = FieldSpec.builder(String.class, "DROP_TABLE_SQL").addModifiers(Modifier.STATIC, Modifier.FINAL, Modifier.PUBLIC).initializer("$S", bufferDropTable.toString()).addJavadoc("<p>\nDDL to drop table $L\n</p>\n", entity.getTableName()).addJavadoc("\n<pre>$L</pre>\n", bufferDropTable.toString()).build();
        // @formatter:on
        classBuilder.addField(fieldSpec);
    }
    // define column typeName set
    for (ModelProperty item : entity.getCollection()) {
        item.accept(this);
    }
    ManagedPropertyPersistenceHelper.generateFieldPersistance(context, entity.getCollection(), PersistType.BYTE, true, Modifier.STATIC, Modifier.PUBLIC);
    model.sqlForCreate.add(bufferTable.toString());
    model.sqlForDrop.add(bufferDropTable.toString());
    generateColumnsArray(entity);
    TypeSpec typeSpec = classBuilder.build();
    JavaWriterHelper.writeJava2File(filer, packageName, typeSpec);
}