entityfacade.java

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

        Reqs reqs = createRequest(requestedEntityName, props, false);

        try {
            ReqFilters reqFilters = getReqFilters(filterEntities, ls, ctx);
            if(!StringHelper.isEmpty(eqlFilters)) {
                reqs.setEqlFilters(eqlFilters);
            }
            reqs.setReqFilters(reqFilters);
        } catch (Exception e) {
            logger.ERROR("Couldn't create filter, see caused by error", e);
        }
        return reqs;
    }

    /**
     * Create request object for 2.6 core, with given properties with requested entity definition.
     *
     * @param entityName
     * @param props
     * @param isNew
     * @return
     */
    public static Reqs createRequest(String entityName, RequestProperties props, boolean isNew) {
        Reqs reqs = createRequest(props);
        ReqEntity reqEntity = new ReqEntity();
        reqEntity.setName(entityName);
        reqEntity.setNew(isNew);

        if(props.getSortField() != null && props.getSortField().getSortOrder() != null) {
            reqEntity.setSortfield(props.getSortField().getFieldID());
            reqEntity.setSortdir(props.getSortField().getSortOrder() ? OrderDirectionSType.ASC:OrderDirectionSType.DESC);
        }
        reqs.getReq().setReqEntity(reqEntity);
        return reqs;
    }

    /**
     * Create request object with given properties, without requested entity object defenition.
     *
     * @param props
     * @return
     */
    public static Reqs createRequest(RequestProperties props) {
        Reqs reqs = new Reqs();
        reqs.setDocount(props.isDoCount());
        reqs.setDoheader(props.isDoHeader());
        reqs.setGetrequest(props.isGetRequest());
        reqs.setIgnoreSendOnRequest(props.isIgnoreSendOnRequest());
        reqs.setPage(props.getPage());
        reqs.setPagesize(props.getPagesize());
        Req req = new Req();
        reqs.setReq(req);
        return reqs;
    }

    public static Reqs buildRequestByID(String entityID, Long rowID, RequestProperties props, LogonSession ls, ActionContext ctx)
            throws EQLException, CouldntGetEJBException, IncorrectEntityDescriptionException {
        FieldData pkeyDataField = getPkeyFilter(entityID, rowID, ctx);

        FieldData[] filters = new FieldData[]{pkeyDataField};
        ArrayList<EntityData> filtersEntity = new ArrayList<EntityData>(1);
        EntityData entity = new EntityData(entityID, rowID, filters);
        filtersEntity.add(entity);

        return buildReqsFromEntities(filtersEntity, null, entityID, props, ls, ctx);
    }

    public static Reqs buildRequestByIDs(String entityID, Collection<Long> rowIDs, RequestProperties props, LogonSession ls, ActionContext ctx)
            throws EQLException, CouldntGetEJBException, IncorrectEntityDescriptionException {
        ArrayList<EntityData> filtersEntity = new ArrayList<EntityData>(rowIDs.size());

        for(Long rowID : rowIDs) {
            FieldData pkeyDataField = getPkeyFilter(entityID, rowID, ctx);

            FieldData[] filters = new FieldData[]{pkeyDataField};

            EntityData entity = new EntityData(entityID, rowID, filters);
            filtersEntity.add(entity);
        }

        return buildReqsFromEntities(filtersEntity, null, entityID, props, ls, ctx);
    }

    /**
     * Creates filters for multiple entities.
     *
     * @param filterEntities
     * @param ls
     * @param ctx
     * @return filters.
     */
    public static ReqFilters getReqFilters(Collection<EntityData> filterEntities, LogonSession ls, ActionContext ctx) {
        ReqFilters reqFilters = new ReqFilters();
        try {
            for(EntityData filterEntity : filterEntities) {
                Map<String, FieldMeta> metas = EntityViewHelper.getMetaForEntity(filterEntity.getEntityID(),
                        EntityViewHelper.FieldsModificator.FORM, false, ls, ctx);

                for(FieldData filterData : filterEntity.getFields()) {
                    FieldMeta fieldMeta = metas.get(filterData.getFieldID());
                    if(fieldMeta != null) {
                        addRequestFilter(filterEntity.getEntityID(), fieldMeta, filterData, reqFilters, ls, ctx);
                    } else {
                        //for debug purposes only
                        String fieldsInEntity = "";
                        for(String key : metas.keySet()) {
                            fieldsInEntity = fieldsInEntity + ", " + key;
                        }
                        logger.ERROR("Wasn't able to find metadata for field [" + filterData.getFieldID() + "], entity ["
                                + filterEntity.getEntityID() + "]. Filter for field [" + filterData.getFieldID()
                                + "] won't be included to request. \n. Here are entities fields [" + fieldsInEntity + "]. ");
                    }
                }
            }
        } catch (Exception e) {
            logger.ERROR("Couldn't create filter, see caused by error. ", e);
        }
        return reqFilters;
    }

    /**
     * Creates and adds filter for the given entity filed meta and entity field data
     *
     * @param entityName
     * @param fieldMeta
     * @param filterData
     * @param reqFilters
     * @param ctx
     * @throws CouldntGetEJBException
     */
    private static void addRequestFilter(String entityName, FieldMeta fieldMeta, FieldData filterData, ReqFilters reqFilters,
                                         LogonSession ls, ActionContext ctx) throws CouldntGetEJBException {


        int type = fieldMeta.getDataType();
        if(type == FieldMeta.MULTISELECT || type == FieldMeta.ENTITYLINK || type == FieldMeta.IN_FORM_GRID) {
            Collection<ReqFilter> filters = createDatasetFilters(entityName, fieldMeta, filterData, ls, ctx);
            for(ReqFilter filter : filters) {
                addNotEmptyFilter(reqFilters, filter);
            }
        } else {
            ReqFilter filter = EntitySerializeHelper.createEFieldFilter(
                    entityName, fieldMeta, filterData, ls);
            addNotEmptyFilter(reqFilters, filter);
        }
    }

    private static void addNotEmptyFilter(ReqFilters reqFilters, ReqFilter filter) {
        if(filter != null) {//can be used to determine empty value request, or unapropriate type
            ReqFiltersTypeItem item = new ReqFiltersTypeItem();
            item.setReqFilter(filter);
            reqFilters.addReqFiltersTypeItem(item);
        }
    }

    /**
     * Creates filter for the given dataset meta and dataset data.
     * If data has unsupported type or value is empty method it
     * return null object.
     *
     * @param locationEntityName
     * @param fieldMeta
     * @param filterData
     * @param ls
     * @param ctx
     * @return
     * @throws CouldntGetEJBException
     */
    private static Collection<ReqFilter> createDatasetFilters(
            String locationEntityName, FieldMeta fieldMeta,
            FieldData filterData,
            LogonSession ls, ActionContext ctx) throws CouldntGetEJBException {
        List<ReqFilter> filters = new LinkedList<ReqFilter>();

        switch(fieldMeta.getDataType()) {
            case FieldMeta.MULTISELECT: {
                MultiselectFieldData msfd = (MultiselectFieldData) filterData;
                DatasetDescriptor meta = EntityViewHelper.getDatasetMetadata(locationEntityName, fieldMeta.getFieldID(), ctx);
                ReqFilter filter = new ReqFilter();
                filter.setEntity(meta.getBindingEntity());
                filter.setName(meta.getBindingEntityFkeyFieldNameToLinked());
                //add filtering values
                long[] selectedIndexes = msfd.getItemsSelected().getSelectedIDs();
                for(long selectedIndex : selectedIndexes) {
                    filter.addReqFilterValue(String.valueOf(selectedIndex));//simply set selected row id, need to call {@link EntitySerializerHelper}
                }
                filter.setConditiontype(ConditionSType.OR);
                filters.add(filter);
                break;
            }
            case FieldMeta.IN_FORM_GRID: {
                InFormGridFieldData inGridData = (InFormGridFieldData) filterData;
                DatasetDescriptor meta = EntityViewHelper.getDatasetMetadata(locationEntityName, fieldMeta.getFieldID(), ctx);
                RowData[] rows = inGridData.getGridData().getRows();
                //initialize filters. We can have 2 different cases: 1 - can search by id when linked, or 2 - by filters.
                //in first case we can filter by binding entity and linked entity, in second only by linked.
                //to be simpler we always would filter by linked.

                String filteringEntity = meta.getLinkedEntity();
                String filteringField = meta.getLinkedEntityPkeyFieldName();

                boolean filtersAdded = false;

                for(RowData row : rows) {
                    Long id = row.getId();
                    if(id != null) {
                        ReqFilter filter = new ReqFilter();
                        filter.setEntity(filteringEntity);
                        filter.setName(filteringField);
                        filter.addReqFilterValue(String.valueOf(id));
                        filters.add(filter);
                    } else {
                        if(!filtersAdded) {
                            Map<String, FieldMeta> metas = EntityViewHelper.getMetaForEntity(filteringEntity,
                                    EntityViewHelper.FieldsModificator.FORM,
                                    false, ls, ctx);
                            Collection<FieldData> fieldFilters = inGridData.getFilters();
                            for(FieldData fieldFilter : fieldFilters) {
                                String fieldId = fieldFilter.getFieldID();
                                FieldMeta filterMeta = metas.get(fieldId);
                                if(filterMeta != null) {
                                    ReqFilter filter = new ReqFilter();
                                    filter.setEntity(filteringEntity);
                                    filter.setName(fieldId);
                                    String strValue = EntitySerializeHelper.getValueStringRepresentation(fieldFilter, filterMeta);
                                    filter.addReqFilterValue(strValue);
                                    filters.add(filter);
                                } else {
                                    logger.WARN("Couldn't find field meta for field [" +
                                    fieldId + "] in entity [" + filteringEntity + "].");
                                }
                            }
                            filtersAdded = true;
                        } else {
                            logger.WARN("Several rows in grid without row id. "
                                    + "We can have only one filters set. Values [" + 
                            row.toString() + "].");
                        }
                    }
                }
                break;
            }
        }
        return filters;
    }

    public static FieldData getPkeyFilter(String entityName, Long pkeyValue, ActionContext ctx)
            throws CouldntGetEJBException, IncorrectEntityDescriptionException {
        String recordKeyName = EntityViewHelper.getPkeyID(entityName, ctx);
        return new TextboxFieldData(recordKeyName, String.valueOf(pkeyValue));
    }
}