integratorreports.java

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

                    gridRequest.getProps().isDoCount(),
                    gridRequest.getProps().getPage(),
                    gridRequest.getProps().getPageSize(),
                    gridRequest.getProps().getSortField());
            RequestBuilder requestBuilder
                    = RequestBuilderFactory.createRequestBuilder(REPORT_SAVING_ENTITY,
                                Collections.<EntityData>emptyList(), props, ls, ctx);

            gridResult = IntegratorHelper.getNotEmptyResult(0, requestBuilder, REPORT_SAVING_ENTITY,
                    EntityViewHelper.FieldsModificator.CUSTOMIZED_GRID, ls, ctx);
        } catch (UserQueryParseException ex) {
            IntegratorHelper.throwException("Incorrect value: " + ex.getValue() + ". Entity: " + ex.getEntityName() + ". Field: " +
                    ex.getFieldCaption(), ex);
        } catch (EQLSystemException ex) {
            IntegratorHelper.throwException("EQL System Exception. " + ex.getMessage(), ex);
        } catch (EQLException ex) {
            IntegratorHelper.throwException("EQL Exception. " + ex.getMessage(), ex);
        } catch (RuntimeException th) {
            IntegratorHelper.reThrowException(th);
        }
        return gridResult;
    }

    public static LoadReportResponseObject loadReport(EntityIDRequestObject request, HttpServletRequest httpServletRequest)
            throws DisplayableException {
        LoadReportResponseObject response = null;

        ServletContext ctx = httpServletRequest.getSession().getServletContext();
        LogonSession ls = WebLoginManager.getLogonSession(httpServletRequest);

        try {
            ActionContext actx = IntegratorHelper.getActionContext(ctx);
            IntegratedRecordSet result = EntityFacade.getEntityByIDRequest(REPORT_SAVING_ENTITY, request.getRowID(), ls, actx);
            if(result.getRowsCount() > 0) {
                IntegratedRecord resultRecord = result.getRecordSet().get(0);
                Map<String,FieldData> fieldsData = resultRecord.getFieldSet();
                Map<String, FieldMeta> fieldsMeta = result.getRecordMeta();

                FieldData serializedReportData = fieldsData.get(ReportSerializeHelper.SERIALIZED_REPORTS_FIELD_ID);
                String serializedReport = EntitySerializeHelper.getValueStringRepresentation(serializedReportData,
                        fieldsMeta.get(ReportSerializeHelper.SERIALIZED_REPORTS_FIELD_ID));

                AdhocReport report = ReportSerializeHelper.deSerializeReport(serializedReport, ls, actx);

                ReportInconsistency inconsistency = checkPrivileges(report, ls, actx);
                String warningMessage;
                switch(inconsistency.getType()) {
                    case WARNING:
                        //do not break here
                    case OK: {
                        warningMessage = buildWarningMessage(inconsistency, ls.getUser(), actx);
                        FieldData reportNameData = fieldsData.get(REPORT_NAME_FIELD_ID);
                        String reportName = EntitySerializeHelper.getValueStringRepresentation(reportNameData,
                                fieldsMeta.get(REPORT_NAME_FIELD_ID));
                        response = new LoadReportResponseObject(reportName, warningMessage, report.getFilters(), report.getReportFields());
                        break;
                    }
                    case ERROR: {
                        IntegratorHelper.throwException(buildErrorMessage(inconsistency, ls.getUser(), actx));
                    }
                }
            }
        } catch (EQLException ex) {
            IntegratorHelper.throwException("EQL Exception. " + ex.getMessage(), ex);
        } catch (RuntimeException th) {
            IntegratorHelper.reThrowException(th);
        }
        return response;
    }

    private static String buildWarningMessage(ReportInconsistency inc,
                                              User user,
                                              ActionContext actx) {
        String message = "";
        int size = inc.getAnavailableReportFields().size();
        if(size > 0) {
            Collection<EntityElement> reportFields = inc.getAnavailableReportFields();
            Collection<String> values = new ArrayList<String>(size);
            for(EntityElement field : reportFields) {
                Object[] params = new Object[]{
                        field.getFormId(),
                        field.getElementId(),
                        field.getElementCaption()
                };
                values.add(EntityOperationsHelper.
                        getLocalizedServerMessage(ENTITY_ELEMENT_DESCRIPTION_MESSAGE_ID,
                                params, user.getLangID(), actx));
            }
            String joined = join(values, VALUES_DELIM, MAX_FORMS_ENUMERATION_LENGHT / 2);

            message += EntityOperationsHelper.
                        getLocalizedServerMessage(ADHOC_REPORT_COULDNT_GET_FIELD_MESSAGE_ID,
                                new Object[] {joined}, user.getLangID(), actx);
            message += "\n";
        }

        Collection<EntityData> filters = inc.getAnavailableFilterField();
        if(filters.size() > 0) {
            Collection<String> values = new ArrayList<String>(size);
            for(EntityData filter : filters) {
                String fieldsEnum = getFields(filter.getFields());
                Object[] params = new Object[]{
                        filter.getEntityID(),
                        fieldsEnum
                };
                values.add(EntityOperationsHelper.
                        getLocalizedServerMessage(ENTITY_DATA_DESCRIPTION_MESSAGE_ID,
                                params, user.getLangID(), actx));
            }
            String joined = join(values, VALUES_DELIM, MAX_FORMS_ENUMERATION_LENGHT / 2);

            message += EntityOperationsHelper.
                        getLocalizedServerMessage(ADHOC_REPORT_COULDNT_SET_FILTER_MESSAGE_ID,
                                new Object[] {joined}, user.getLangID(), actx);
        }

        return message;
    }

    private static String getFields(FieldData[] fields) {
        Collection<String> fieldsNames = new ArrayList<String>(fields.length);
        for(FieldData fieldData : fields) {
            fieldsNames.add(fieldData.getFieldID());
        }
        return join(fieldsNames, VALUES_DELIM, MAX_FORMS_ENUMERATION_LENGHT);
    }

    private static String buildErrorMessage(ReportInconsistency inconsistency,
                                            User user,
                                            ActionContext actx) {

        String forms = join(inconsistency.getAnavailableForms(), VALUES_DELIM,
                MAX_FORMS_ENUMERATION_LENGHT);

        return EntityOperationsHelper.
                getLocalizedServerMessage(ADHOC_REPORT_HAVENT_ACCESS_MESSAGE_ID,
                        new Object[] {forms}, user.getLangID(), actx);
    }

    private static String join(Collection<String> col, String delim, int maxSize) {
        String ret = "";
        boolean firstCome = true;
        for(String value : col) {
            if(!firstCome) {
                ret += delim;
            }
            ret += value;
            firstCome = false;
        }
        if(ret.length() > maxSize) {
            ret = ret.substring(0, maxSize) + "...";
        }
        return ret;
    }

    private static ReportInconsistency checkPrivileges(AdhocReport report,
                                                       LogonSession ls,
                                        ActionContext actx) {
        ReportInconsistency inc = new ReportInconsistency();
        PermissionSet permissions = AccessRightsManager.getPermissionSetForUser(ls.getUser());

        Map<String, Map<String, FieldMeta>> entityMetaCache = new HashMap<String, Map<String, FieldMeta>>();

        List<EntityElement> reportFields = report.getReportFields();
        for(EntityElement field : reportFields) {
            //check on permission
            if(permissions.getPermissionObject(PermissionObjectType.FORM,
                    field.getFormId()) == null) {
                inc.formNotAvailable(field.getFormId());
            }
            String entityName = EntityOperationsHelper.getEntityNameFromFormID(
                    field.getFormId());
            //check if all fields are in entity
            Map<String, FieldMeta> meta;
            if(entityMetaCache.containsKey(entityName)) {
                meta = entityMetaCache.get(entityName);
            } else {
                meta = EntityViewHelper.getMetaForEntity(entityName,
                        EntityViewHelper.FieldsModificator.FORM, false, ls,
                        actx);
                entityMetaCache.put(entityName, meta);
            }
            if(!meta.containsKey(field.getElementId())) {
                inc.reportElementNotAvailable(field);
            }
        }

        //check if all fields are in entity 
        List<EntityData> filters = report.getFilters();
        for(EntityData filter : filters) {
            String entityName = filter.getEntityID();
            Map<String, FieldMeta> meta;
            if(entityMetaCache.containsKey(entityName)) {
                meta = entityMetaCache.get(entityName);
            } else {
                meta = EntityViewHelper.getMetaForEntity(entityName,
                        EntityViewHelper.FieldsModificator.FORM, false, ls,
                        actx);
                entityMetaCache.put(entityName, meta);
            }
            for(FieldData data : filter.getFields()) {
                if(!meta.containsKey(data.getFieldID())) {
                    inc.reportFilterNotAvailable(filter);
                }
            }
        }
        return inc;
    }

    public static SearchGridRecordsResponseObject deleteReport(AdhocDeleteReportRequest reportId, HttpServletRequest httpServletRequest)
            throws DisplayableException {
        SearchGridRecordsResponseObject response = null;

        ServletContext ctx = httpServletRequest.getSession().getServletContext();
        LogonSession ls = WebLoginManager.getLogonSession(httpServletRequest);
        ActionContext actx = IntegratorHelper.getActionContext(ctx);
        try {
            EntityFacade.deleteRecord(REPORT_SAVING_ENTITY, reportId.getReportId(), actx, ls);

            response = loadReportList(reportId, httpServletRequest);
        } catch (EQLException ex) {
            IntegratorHelper.throwException("EQL Exception. " + ex.getMessage(), ex);
        } catch (RuntimeException th) {
            IntegratorHelper.reThrowException(th);
        }
        return response;
    }
}