abstractgraction.java

CRM源码This file describes some issues that should be implemented in future and how it should be imple

        throws UserQueryParseException {

        if( cond_op != NONE_OP && cond_op != NE_OP ) {
            //
            // Use default operation
            //
            parseUserSimpleCondition( leftMember, rightMember, cond_op, entity, field, ret );
            return;
        }

        //
        // Parse string
        //
        GRStringParser grsParser = new GRStringParser( entity, field );
        rightMember = grsParser.toEQL( rightMember );

        if( grsParser.exactSearch ) {
            //
            // No any advanced search options found - use default operation
            //
            parseUserSimpleCondition( leftMember, rightMember, cond_op, entity, field, ret );
            return;
        }

        // call user transformer and add in EQL interpreter prepared statement
        eqlPS.setObject( psCount++, convertString2EQLObject( entity, field, rightMember ) );
        if( !grsParser.hasDog && !ignoreLower ) {
            ret.append( "LOWER(" ).append( leftMember ).append( ")" );
            if( cond_op == NE_OP ) {
                ret.append( " NOT LIKE " );
            } else {
                ret.append( " LIKE " );
            }
            ret.append( "LOWER(" ).append( PS_CHARACTER ).append( ")" );
        } else {
            ret.append( leftMember );
            if( cond_op == NE_OP ) {
                ret.append( " NOT LIKE " );
            } else {
                ret.append( " LIKE " );
            }
            ret.append( PS_CHARACTER );
        }
    }

    /**
     * Parse string user date condition
     * @param leftMember left member of query
     * @param rightMember right member of query
     * @param cond_op number of condition operation
     * @param entity given entity
     * @param field given field
     * @param ret result string buffer
     * @throws UserQueryParseException
     */
    protected void parseUserDateCondition( String leftMember,
                                           String rightMember,
                                           int cond_op,
                                           Entity entity,
                                           Efield field,
                                           StringBuffer ret )
        throws UserQueryParseException {

        if( cond_op != NONE_OP ) {
            //
            // Use default operation
            //
            parseUserSimpleCondition( leftMember, rightMember, cond_op, entity, field, ret );
            return;
        }

        String firstRightMember = rightMember;
        String secondRightMember = rightMember;

        int pos = rightMember.indexOf( BETWEEN_OP );
        if( pos > 0 ) {
            //
            // found BETWEEN operation
            //
            firstRightMember = rightMember.substring( 0, pos );
            secondRightMember = rightMember.substring( pos + BETWEEN_OP.length() );
        }

        // detect is second date has time part or not for comparing duration
        // (only for timestamp fields)
        boolean useDuration = false;
        if( field.getSqltype().getType() == SqlSType.TIMESTAMP_TYPE ) {
            useDuration = !ExtDateParser.hasTimePart( secondRightMember );
        }

        if( getLogger().isInfoEnabled() ) {
            INFO( "[parse date] 1: '" + firstRightMember +
                  "' 2: '" + secondRightMember +
                  "' useDuration=" + useDuration );
        }

        // get first EQL date object
        EQLDateObject dateObject1 = ( EQLDateObject )
            convertString2EQLObject( entity, field, firstRightMember );

        // get second EQL date object
        EQLDateObject dateObject2;
        if( firstRightMember.equals( secondRightMember ) ) {
            dateObject2 = dateObject1;
        } else {
            dateObject2 = ( EQLDateObject ) convertString2EQLObject( entity, field, secondRightMember );
        }

        boolean exchangeDates = dateObject1.getValue().compareTo( dateObject2.getValue() ) > 0;
        if( exchangeDates ) {
            // exchange dates so they are in ascending order
            EQLDateObject dateTemp = dateObject1;
            dateObject1 = dateObject2;
            dateObject2 = dateTemp;
        }

        if( useDuration ) {
            // get second EQL date object (plus one day)
            if( exchangeDates ) {
                dateObject2 = ( EQLDateObject )
                    convertString2EQLObject( entity, field, firstRightMember + "+1d" );
            } else {
                dateObject2 = ( EQLDateObject )
                    convertString2EQLObject( entity, field, secondRightMember + "+1d" );
            }
        }

        if( getLogger().isInfoEnabled() ) {
            INFO( "[parse date] 1: '" + dateObject1.toString() +
                  "' 2: '" + dateObject2.toString() );
        }

        if( useDuration ) {
            eqlPS.setObject( psCount++, dateObject1 );
            eqlPS.setObject( psCount++, dateObject2 );

            ret.append( leftMember );
            ret.append( " >= " );
            ret.append( PS_CHARACTER );
            ret.append( " AND " );
            ret.append( leftMember );
            ret.append( " < " );
            ret.append( PS_CHARACTER );

        } else if( !firstRightMember.equals( secondRightMember ) ) {
            eqlPS.setObject( psCount++, dateObject1 );
            eqlPS.setObject( psCount++, dateObject2 );

            ret.append( leftMember );
            ret.append( " >= " );
            ret.append( PS_CHARACTER );
            ret.append( " AND " );
            ret.append( leftMember );
            ret.append( " <= " );
            ret.append( PS_CHARACTER );

        } else {
            eqlPS.setObject( psCount++, dateObject1 );

            ret.append( leftMember );
            ret.append( " = " );
            ret.append( PS_CHARACTER );
        }
    }

    /**
     * Parse memo user query condition
     * @param leftMember left member of query
     * @param rightCond right condition (with operation) of query
     * @param entity given entity
     * @param field given field
     * @param ret result string buffer
     * @throws UserQueryParseException
     */
    protected void parseUserMemoCondition( String leftMember,
                                           String rightCond,
                                           Entity entity,
                                           Efield field,
                                           StringBuffer ret )
        throws UserQueryParseException {

        //
        // Parse string
        //
        GRStringParser grsParser = new GRStringParser( entity, field );
        rightCond = grsParser.toEQL( rightCond );

        // call user transformer and add in EQL interpreter prepared statement
        eqlPS.setObject( psCount++, convertString2EQLObject( entity, field, rightCond ) );

        ret.append( leftMember );
        ret.append( " LIKE " );
        ret.append( PS_CHARACTER );
    }

    /**
     * Create new ResRecord object
     * @param eqlRes EQLRes object
     * @param pos position in EQL response
     * @return array of ResRecord objects or null
     * @throws EQLException
     */
    protected ResRecord createResRecord( EQLRes eqlRes, int pos )
        throws EQLException {

        // create new record
        ResRecord resRecord = createResRecordStub( pos );
        EQLResRecord eqlResRecord = eqlRes.getRecord( pos );

        // set values
        int cellCount = eqlResRecord.size();
        for( int i = 0; i < cellCount; i++ ) {
            setFieldValue( resRecord, eqlResRecord.getResCell( i ), ignoreSendOnRequest );
        }

        // set datasets
        int datasetSize = eqlResRecord.getDResSize();
        for( int i = 0; i < datasetSize; i++ ) {
            EQLDRes dRes = eqlResRecord.getDRes( i );
            Dataset dataset = dRes.getReqDataset().getDataset();

            ResRecord[] resDatasetRecords = createResRecords( dRes );
            if( resDatasetRecords != null ) {
                // dataset has records - create ResDataset
                ResDataset resDataset = createResDatasetStub( resRecord, dataset );
                resDataset.setResRecord( resDatasetRecords );

                // dataset - loaded
                resDataset.setLoaded( Boolean.TRUE );
            }
        }

        return resRecord;
    }

    /**
     * Create ResRecord stub
     * @param pos position
     * @return stub for ResRecord
     */
    protected ResRecord createResRecordStub( int pos ) {
        ResRecord record = new ResRecord();
        record.setId( new Integer( pos ) );
        return record;
    }

    /**
     * Create ResField stub and add it in ResRecord
     * @param record ResRecord object
     * @param efield Efield object
     * @return stub for ResField
     */
    protected ResField createResFieldStub( ResRecord record, Efield efield ) {
        ResField rfield = new ResField();
        rfield.setEntity( efield.getEntityName() );
        rfield.setName( efield.getName() );
        record.addResField( rfield );
        record.putObject( efield.getName(), rfield );
        return rfield;
    }

    /**
     * Create ResDataset stub and add it in ResRecord
     * @param record ResRecord object
     * @param dataset Dataset object
     * @return stub for ResDataset
     */
    protected ResDataset createResDatasetStub( ResRecord record,
                                               Dataset dataset ) {

        String entityName1 = dataset.getEntityName();
        String entityName2 = dataset.getEntity();

        ResDataset rdataset = new ResDataset();
        rdataset.setEntity( entityName2 );
        rdataset.setName( dataset.getName() );
        record.addResDataset( rdataset );
        record.putObject( dataset.getName(), rdataset );

        // set external/internal (it will be deprecated)
        String[] attrs = getExternalAndInternalDatasetAttr( dataset );
        rdataset.setExternal( attrs[EXTERNAL_ATTR] );
        rdataset.setInternal( attrs[INTERNALL_ATTR] );

        return rdataset;
    }

    /**
     * Create new fake ResRecord
     * @param fields array of Efield objects
     * @return one ResRecord
     */
    protected ResRecord[] createFakeResRecord( Efield[] fields ) {
        // return one fake record
        ResRecord[] resRecords = new ResRecord[1];
        resRecords[0] = new ResRecord();
        resRecords[0].setId( new Integer( 0 ) );

        // add fake fields
        if( fields != null ) {
            for( int i = 0; i < fields.length; i++ ) {
                createResFieldStub( resRecords[0], fields[i] );
            }
        }

        return resRecords;
    }

    /**
     * Get 'external' and 'internal' dataset attributes
     * @param dataset Dataset object
     * @return array [0] - external, [1] - internal
     */
    protected String[] getExternalAndInternalDatasetAttr( Dataset dataset ) {

        Entity datasetEntity = ctx.getEntityViewConfig( dataset.getEntity() );
        Entity topEntity = ctx.getEntityViewConfig( dataset.getEntityName() );

        // set <code>external</code> and <code>internal</code> attributes
        /** @todo support compound keys */
        Efield fieldExt = EntityHelper.getEfieldBySrc(
            dataset.getDataschema().getTable( 0 ).getKey( 0 ),
            topEntity );

        Efield fieldInt = EntityHelper.getEfieldBySrc(
            dataset.getDataschema().getTable( 1 ).getKey( 0 ),
            datasetEntity );

        return new String[] {fieldExt.getName(), fieldInt.getName()};
    }

    /**
     * Set field value as formatted string
     * @param resRecord ResRecord object
     * @param resCell EQLResCell object
     * @param ignoreSendOnRequest consider Efield send on request attribute or not
     */
    protected void setFieldValue( ResRecord resRecord,
                                  EQLResCell resCell,
                                  boolean ignoreSendOnRequest ) {
        // get EQL object
        EQLObject eqlObj = resCell.getEQLObject();

        EQLReqField reqField = resCell.getReqField();
        Efield field = reqField.getField();
        Entity entity = reqField.getReqEntity().getEntity();
        boolean sendOnReq = field.getSendonrequest().booleanValue();

        // create new record field
        ResField resField = createResFieldStub( resRecord, field );

        // set has-content flag
        if( resCell.isNull() ) {
            resField.setHasContent( Boolean.FALSE );
        }

        if( ignoreSendOnRequest || sendOnReq ) {
            // set value
            String value = convertEQLObject2String( entity, field, eqlObj );
            if( value != null ) {
                resField.setResFieldValue( value );
            }

            // get field list value and set it
            setListFieldValue( resCell, resField );

            // field - loaded
            resField.setLoaded( Boolean.TRUE );

        } else {
            // field - not loaded
            resField.setLoaded( Boolean.FALSE );
        }
    }

    /**
     * Set result list field value as formatted string
     * @param resCell EQLResCell object
     * @param resField ResField object
     */
    protected void setListFieldValue( EQLResCell resCell, ResField resField ) {

        EQLResCell listResCell = resCell.getListField();
        if( listResCell != null && !listResCell.isNull() ) {
            EQLObject listEqlObj = listResCell.getEQLObject();
            EQLReqField listReqField = listResCell.getReqField();
            Efield listField = listReqField.getField();