abstractgraction.java

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

            Entity listEntity = listReqField.getReqEntity().getEntity();

            String listValue = convertEQLObject2String( listEntity, listField, listEqlObj );
            if( listValue != null ) {
                resField.setResFieldText( listValue );
            }
        }
    }

    /**
     * Construct response header by the Entity and Form
     * @param entity Entity object
     * @param form Form object
     * @return ResHeader object
     */
    protected ResHeader getHeader( Entity entity, Form form ) {

        ResHeader resHeader = getHeader( entity );

        // set 'has-external-sets' attr
        resHeader.setHasExternalSets( ( form.getExternalSetCount() == 0 ) ?
                                      Boolean.FALSE : Boolean.TRUE );

        // set 'linked-dataset' elements
        LinkedDataset[] linkedDatasets = form.getLinkedDataset();
        if( linkedDatasets != null ) {
            XMLBinding xmlBind = XMLFactory.getXMLBinding();
            for( int i = 0; i < linkedDatasets.length; i++ ) {
                ResLinkedDataset resLinkedDataset = new ResLinkedDataset();
                xmlBind.copyAttributes( linkedDatasets[i],
                                        resLinkedDataset,
                                        LinkedDataset.class,
                                        ResLinkedDataset.class );

                resHeader.addResLinkedDataset( resLinkedDataset );
            }
        }

        return resHeader;
    }

    /**
     * Construct response header by the Entity
     * @param entity Entity object
     * @return ResHeader object
     */
    protected ResHeader getHeader( Entity entity ) {

        ResHeader resHeader = getHeader( entity.getEfield(), entity.getDataset() );

        // set 'listfield' attr
        String listfield = entity.getListfield();
        if( listfield != null ) {
            resHeader.setListfield( listfield );
        }

        return resHeader;
    }

    /**
     * Construct response header
     * @param efields array of fields
     * @param datasets array of datasets
     * @return ResHeader object
     */
    protected ResHeader getHeader( Efield[] efields, Dataset[] datasets ) {

        ResHeader resHeader = new ResHeader();
        XMLBinding xmlBind = XMLFactory.getXMLBinding();

        // select all Efield objects
        int efieldCount = ( efields == null ) ? 0 : efields.length;
        for( int i = 0; i < efieldCount; i++ ) {
            ResHeaderField resHField = new ResHeaderField();
            Efield field = efields[i];
            String fieldName = field.getName();
            String entityName = field.getEntityName();

            // copy common attributes
            xmlBind.copyAttributes( field, resHField, Efield.class, ResHeaderField.class );

            // set 'entity'
            resHField.setEntity( entityName );

            // set 'caption'
            CustomField cfield = ctx.getCustomField( entityName, fieldName );
            if( cfield != null ) {
                resHField.setCaption( cfield.getCaption() );
            }

            // set 'hasdefvalue'
            if( field.getEqlDefsrc() != null ) {
                resHField.setHasdefvalue( Boolean.TRUE );
            } else {
                resHField.setHasdefvalue( Boolean.FALSE );
            }

            // set 'haslistref'
            if( field.getListref() != null ) {
                resHField.setHaslistref( Boolean.TRUE );
            } else {
                resHField.setHaslistref( Boolean.FALSE );
            }

            resHeader.addResHeaderField( resHField );
        }

        // select all Dataset objects
        int dataset_count = ( datasets == null ) ? 0 : datasets.length;
        for( int i = 0; i < dataset_count; i++ ) {
            ResHeaderDataset resHDataset = new ResHeaderDataset();
            Dataset dataset = datasets[i];
            String datasetName = dataset.getName();

            // set attributes
            String _entityName = dataset.getEntity();
            Entity _entity = ctx.getEntityViewConfig( _entityName );

            resHDataset.setName( dataset.getName() );
            resHDataset.setEntity( _entityName );
            resHDataset.setSendonrequest( new Boolean( ignoreSendOnRequest | dataset.getSendonrequest().booleanValue() ) );
            resHDataset.setRequired( dataset.getRequired() );
            resHDataset.setResHeader( getHeader( _entity ) );
            if( dataset.getLinkedEntity() != null ) {
                resHDataset.setLinkedEntity( dataset.getLinkedEntity() );
            }

            // set 'caption'
            CustomField cfield = ctx.getCustomField( dataset.getEntityName(), datasetName );
            if( cfield != null ) {
                resHDataset.setCaption( cfield.getCaption() );
            }

            // set external/internal
            String[] attrs = getExternalAndInternalDatasetAttr( dataset );
            resHDataset.setExternal( attrs[EXTERNAL_ATTR] );
            resHDataset.setInternal( attrs[INTERNALL_ATTR] );

            resHeader.addResHeaderDataset( resHDataset );
        }

        return( resHeader.getResHeaderFieldCount() == 0 &&
                resHeader.getResHeaderDatasetCount() == 0 ) ? null : resHeader;
    }

    // ----------------------------------------------------- inner class

    /**
     * <p>String parser helper class</p>
     * @author [ALB] Baranov Andrey
     */

    static class GRStringParser {

        private Entity entity;
        private Efield field;

        public boolean hasTick = false;
        public boolean hasDog = false;
        public boolean hasDollar = false;
        public boolean exactSearch = true;

        //
        // Constructor
        //
        public GRStringParser( Entity entity, Efield field ) {
            this.entity = entity;
            this.field = field;
        }

        //
        // Parse string user query condition with NONE operation
        // Return valid EQL string or throw exception UserQueryParseException
        //
        public final String toEQL( String rightMember )
            throws UserQueryParseException {

            // 1. find TICK and DOG
            int pos = 0;
            int size = rightMember.length();
            boolean foundEscape = false;
            for( int i = 0; i < size && pos < 2; i++ ) {
                char c = rightMember.charAt( i );
                if( c == TICK_OP && !hasTick ) {
                    pos++;
                    if( foundEscape ) {
                        break;
                    }
                    hasTick = true;

                } else if( c == DOG_OP && !hasDog ) {
                    pos++;
                    if( foundEscape ) {
                        break;
                    }
                    hasDog = true;

                } else if( c == ESCAPE_CHARACTER && !foundEscape ) {
                    foundEscape = true;

                } else {
                    break;
                }
            }
            if( pos > 0 ) {
                rightMember = rightMember.substring( pos );
            }

            // 2. find ASTERISC, QUESTION and DOLLAR
            //    replace user escapes on EQL escapes
            StringBuffer sb = new StringBuffer();
            size = rightMember.length();
            boolean evenEscapes = true;
            for( int i = 0; i < size; i++ ) {
                char c = rightMember.charAt( i );

                if( c == EQL_ASTERISC_OP || c == EQL_QUESTION_OP ) {
                    // '%' | '_'
                    sb.append( EQL_ESCAPE_CHARACTER ).append( c );

                } else if( c == ASTERISC_OP && evenEscapes ) {
                    // '*'
                    sb.append( EQL_ASTERISC_OP );
                    exactSearch = false;

                } else if( c == QUESTION_OP && evenEscapes ) {
                    // '?'
                    sb.append( EQL_QUESTION_OP );
                    exactSearch = false;

                } else if( i == ( size - 1 ) && c == DOLLAR_OP && evenEscapes ) {
                    // '$'
                    hasDollar = true;

                } else if( c == ESCAPE_CHARACTER ) {
                    // '\'
                    evenEscapes = !evenEscapes;
                    if( evenEscapes ) {
                        // add ESCAPE symbol
                        sb.append( EQL_ESCAPE_CHARACTER );
                        sb.append( EQL_ESCAPE_CHARACTER );
                    }
                    continue;

                } else {
                    // other...
                    sb.append( c );
                }

                // drop escapes
                evenEscapes = true;
            }
            rightMember = sb.toString();

            // 3. build EQL string

            // check 'left-anchored' attribute
            // if present - don't add ASTERISC before value
            if( !hasTick && !field.getLeftAnchored().booleanValue() ) {
                rightMember = EQL_ASTERISC_OP + rightMember;
                exactSearch = false;
            }

            // check 'right-anchored' attribute
            // if present - don't add ASTERISC after value
            if( !hasDollar && !field.getRightAnchored().booleanValue() ) {
                rightMember += EQL_ASTERISC_OP;
                exactSearch = false;
            }

            // return new right member string in EQL format
            return rightMember;
        }

    } // --  end of inner class


    // ----------------------------------------------------- inner class

    /**
     * <p>String parser helper class</p>
     * @author [ALB] Baranov Andrey
     */

    static class GRIgnoreWordsDetector {

        // constants
        private static final String IGNORE_WORDS_FILE = "com/queplix/config/sys/ignorewords.txt";

        // variables
        private List ignoreWords;

        private char[] checkedSymbols = new char[] {
            AND_CHARACTER,
            OR_CHARACTER,
            ASTERISC_OP,
            DOLLAR_OP
        };

        // Initialization
        public GRIgnoreWordsDetector() {
            InputStream is = getClass().getClassLoader().getResourceAsStream( IGNORE_WORDS_FILE );
            if( is == null ) {
                System.out.println( "Ignore words vocabulary not found" );
                return;
            }

            ignoreWords = new ArrayList();
            BufferedReader reader = null;
            try {
                reader = new BufferedReader( new InputStreamReader( is ) );
                String s;
                while( ( s = reader.readLine() ) != null ) {
                    if( !StringHelper.isEmpty( s ) ) {
                        String iw = s.toLowerCase();
                        ignoreWords.add( iw );
                    }
                }
                if( ignoreWords.size() == 0 ) {
                    ignoreWords = null;
                }
                System.out.println( "Ignore words list loaded: " + ignoreWords );

            } catch( IOException ex ) {
                throw new GenericSystemException( "IO exception: " + ex.getMessage(), ex );

            } finally {
                try {
                    if( reader != null ) {
                        reader.close();
                    }
                } catch( IOException ex ) {}
            }
        }

        // replace symbols in ignore words
        public final String replace( String s ) {

            if( StringHelper.isEmpty( s ) ) {
                return s;
            }

            int size = ( ignoreWords == null ) ? 0 : ignoreWords.size();
            for( int i = 0; i < size; i++ ) {
                String ignoreWord = ( String ) ignoreWords.get( i );
                int length = ignoreWord.length();

                int pos = 0;
                while( ( pos = s.toLowerCase().indexOf( ignoreWord, pos ) ) >= 0 ) {
                    s = s.substring( 0, pos ) +
                        buildIWSubstitutor( s.substring( pos, pos + length ) ) +
                        s.substring( pos + length );
                    pos += length;
                }
            }

            return s;
        }

        // build substitutor for given ignore word
        private String buildIWSubstitutor( String ignoreWord ) {

            if( StringHelper.isEmpty( ignoreWord ) ) {
                return ignoreWord;
            }

            StringBuffer sb = new StringBuffer();
            int length = ignoreWord.length();
            for( int i = 0; i < length; i++ ) {
                char c = ignoreWord.charAt( i );
                for( int j = 0; j < checkedSymbols.length; j++ ) {
                    char symbol = checkedSymbols[j];
                    if( c == symbol ) {
                        sb.append( ESCAPE_CHARACTER );
                        break;
                    }
                }
                sb.append( c );
            }

            return sb.toString();
        }

    } // --  end of inner class
}