entityserializehelper.java

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

                }
                data = new CheckBoxData(fieldID, value);
                break;
            }
            case FieldMeta.DATEFIELD: {
                Date startDate = null;
                Date endDate = null;
                Locale locale = SecurityHelper.getJavaLocale(user.getCountryID(), user.getLangID());
                TimeZone tz = SecurityHelper.getJavaTimezone(user.getTimeZoneID());
                String datePattern = user.getDatePattern();
                String timePattern = user.getTimePattern();
                boolean dayPosFirst = user.isDatePositionFirst();

                /*String pattern = datePattern == null ? "" : datePattern;
                if(fieldValue != null && datePattern.length() < fieldValue.length()) {
                    pattern += timePattern == null ? "" : " "+timePattern;
                }*/

                String[] rawDateRange = getDatesFromString(fieldValue);
                if(rawDateRange != null) {
                    try {
                        long sysDateMls = ExtDateParser.parseDate(rawDateRange[0], dayPosFirst, locale, tz, datePattern, timePattern);
                        startDate = new Date(DateHelper.toUser(sysDateMls, tz));
                        if(rawDateRange.length > 1){
                            sysDateMls = ExtDateParser.parseDate(rawDateRange[1], dayPosFirst, locale, tz, datePattern, timePattern);
                            endDate = new Date(DateHelper.toUser(sysDateMls, tz));
                        }
                    } catch (Exception e) {
                        logger.ERROR("Couldn't create data for startDate field", e);
                    }
                }
                String representation = getDateStringRepresentation(startDate, endDate, datePattern, timePattern, locale);
                data = new DateFieldData(fieldID, startDate, DateHelper.getNowDate(), representation);
                if(endDate != null){
                    ((DateFieldData)data).setEndDate(endDate);
                }
                break;
            }
            case FieldMeta.LISTBOX: {
                if(null != fieldValue) {
                    String[] fields = fieldValue.split("_");
                    long[] selectedItemsIds = new long[fields.length];
                    for(int i = 0; i < selectedItemsIds.length; i++) {
                        selectedItemsIds[i] = Long.parseLong(fields[i]);
                    }
                    data = new ListboxFieldData(fieldID, new SubsetData(selectedItemsIds));
                } else {
                    data = new ListboxFieldData(fieldID, new SubsetData());
                }
                break;
            }
            case FieldMeta.MEMO: {
                data = new MemoFieldData(fieldID, fieldValue, recordId);
                break;
            }
            case FieldMeta.HISTORY: {
                String s = ctx.getHistoryManager().toHTML(fieldText);
                int historyDbId = -1;
                try {
                    historyDbId = Integer.parseInt(fieldValue);
                } catch (Exception e) {
                }
                data = new HistoryFieldData(fieldID, s, fieldValue, hasContent, recordId, historyDbId);
                break;
            }
            case FieldMeta.TEXTAREA: {
                data = new TextareaFieldData(fieldID, fieldValue);
                break;
            }
            case FieldMeta.TEXTBOX: {
                data = new TextboxFieldData(fieldID, fieldValue);
                break;
            }
            case FieldMeta.ENTITYREFERENCE: {
                Long rowID = null;
                if(!StringHelper.isEmpty(fieldValue)) {
                    rowID = Long.parseLong(fieldValue);
                }
                data = new EntityReferenceData(fieldID, fieldText, rowID);
                break;
            }
            default: {
                throw new IllegalControlTypeException("Couldn't fill the field with type [" + fieldMeta.getDataType() +
                        "], because it doesn't supported now. ");
            }
        }
        return data;
    }

    /**
     * Create empty field data for the given type.
     *
     * @param fieldMeta meta for field
     * @param user      user
     * @return empty field data
     * @throws IllegalControlTypeException if there is no such control presented in metadata
     */
    public static FieldData createEmptyFieldData(FieldMeta fieldMeta, User user) throws IllegalControlTypeException {
        FieldData data;
        String fieldID = fieldMeta.getFieldID();
        switch(fieldMeta.getDataType()) {
            case FieldMeta.CHECKBOX: {
                data = new CheckBoxData(fieldID, null);
                break;
            }
            case FieldMeta.DATEFIELD: {
                Locale locale = SecurityHelper.getJavaLocale(user.getCountryID(), user.getLangID());
                String datePattern = user.getDatePattern();
                String timePattern = user.getTimePattern();

                Date date = DateHelper.getNowDate();

                String representation = getDateStringRepresentation(date, null, datePattern, timePattern, locale);
                data = new DateFieldData(fieldID, date, date, representation);
                break;
            }
            case FieldMeta.LISTBOX: {
                data = new ListboxFieldData(fieldID, new SubsetData());
                break;
            }
            case FieldMeta.MEMO: {
                data = new MemoFieldData(fieldID, "", -1);
                break;
            }
            case FieldMeta.HISTORY: {
                data = new HistoryFieldData(fieldID, "", "", false, -1, -1);
                break;
            }
            case FieldMeta.TEXTAREA: {
                data = new TextareaFieldData(fieldID, "");
                break;
            }
            case FieldMeta.TEXTBOX: {
                data = new TextboxFieldData(fieldID, "");
                break;
            }
            case FieldMeta.ENTITYREFERENCE: {
                data = new EntityReferenceData(fieldID, "", null);
                break;
            }
            case FieldMeta.IN_FORM_GRID: {
                data = new InFormGridFieldData(fieldID, new GridData());
                break;
            }
            case FieldMeta.MULTISELECT: {
                data = new MultiselectFieldData(fieldID, new SubsetData());
                break;
            }
            case FieldMeta.ENTITYLINK: {
                data = new EntityLinkFieldData(fieldID, null, new HashSet());
                break;
            }
            default: {
                throw new IllegalControlTypeException("Couldn't create the field with type [" + fieldMeta.getDataType() +
                        "], because it doesn't supported. ");
            }
        }
        return data;
    }

    /**
     * Return string representation of date range.
     *
     * @param startDate   start date
     * @param endDate     end date
     * @param datePattern date pattern
     * @param timePattern time pattern
     * @param locale      locale
     * @return string representation of date range.
     */
    public static String getDateStringRepresentation(Date startDate, Date endDate, String datePattern, String timePattern, Locale locale) {
        String formattedDate = "";
        if(startDate != null) {
            if(endDate == null) {
                formattedDate = DateHelper.formatDate(startDate, datePattern, timePattern, locale);
            } else {
                if(startDate.getTime() == endDate.getTime()) {
                    formattedDate = DateHelper.formatDate(startDate, datePattern, locale);
                } else {
                    formattedDate = DateHelper.formatDate(startDate, datePattern, locale) + DATE_RANGE_DIV +
                            DateHelper.formatDate(endDate, datePattern, locale);
                }
            }
        }
        return formattedDate;
    }

    public static String[] getDatesFromString(String formattedDate){
        if(formattedDate == null) {
            return null;
        }        
        int divIndex = formattedDate.indexOf(DATE_RANGE_DIV);
        if(divIndex == -1) {
            return new String[]{formattedDate};
        }
        String first = formattedDate.substring(0 , divIndex);
        String second = formattedDate.substring(divIndex+2, formattedDate.length());

        String[] tmp = new String[]{first, second};
        return tmp;
    }

    private static String escape(String string) {
        return string.replaceAll(ENTITY_DIV, ENTITY_DIV + ENTITY_DIV).
                replaceAll(FIELDS_DIV, FIELDS_DIV + FIELDS_DIV).
                replaceAll(ID_AND_TEXT_DIV, ID_AND_TEXT_DIV + ID_AND_TEXT_DIV);
    }

    private static String unEscape(String string) {
        return string.replaceAll(ENTITY_DIV + ENTITY_DIV, ENTITY_DIV).
                replaceAll(FIELDS_DIV + FIELDS_DIV, FIELDS_DIV).
                replaceAll(ID_AND_TEXT_DIV + ID_AND_TEXT_DIV, ID_AND_TEXT_DIV);
    }

    /**
     * Split escaped by double escaping chars string.
     * @param string string to be splitted
     * @param singleSplitChar split char
     * @return splitted string
     */
     private static String[] splitEscaped(String string, String singleSplitChar) {
        boolean metChar = false;
        String prevToken = "";
        ArrayList<String> ret = new ArrayList<String>();
        if(!StringHelper.isEmpty(string)) {
            for(StringTokenizer stringTokenizer = new StringTokenizer(string, singleSplitChar, true); stringTokenizer.hasMoreTokens();) {
                String curToken = stringTokenizer.nextToken();
                if(curToken.equalsIgnoreCase(singleSplitChar)) {
                    if(metChar) {
                        metChar = false;
                        prevToken += singleSplitChar + singleSplitChar;//doubled escaped char
                    } else {
                        metChar = true;
                    }
                } else {
                    if(metChar) {
                        ret.add(prevToken);
                        prevToken = curToken;
                    } else {
                        prevToken += curToken;
                    }
                    metChar = false;
                }
            }
            if(!"".equalsIgnoreCase(prevToken)) {
                ret.add(prevToken);
            }
        }
        return ret.toArray(new String[ret.size()]);
    }

    public static String serialize(List<EntityData> data, LogonSession ls, ActionContext ctx) {
        String ret = "";
        for(EntityData entityData : data) {
            ret += serialize(entityData, ls, ctx) + ENTITY_DIV;
        }
        return ret;
    }

    public static String serialize(EntityData data, LogonSession ls, ActionContext ctx) {
        String ret = "";
        Map<String, FieldMeta> meta = EntityViewHelper.getMetaForEntity(data.getEntityID(),
                EntityViewHelper.FieldsModificator.FORM, false, ls, ctx);
        ret += data.getEntityID() + FIELDS_DIV;
        ret += serialize(data.getFields(), meta);
        return ret;
    }
    
    public static String serialize(FieldData[] data, Map<String, FieldMeta> meta) {
        String ret = "";
        for(FieldData fieldData : data) {
            FieldMeta fieldMeta = meta.get(fieldData.getFieldID());
            String valueRepr = getValueStringRepresentation(fieldData, fieldMeta);
            String textRepr = getTextStringRepresentation(fieldData, fieldMeta);
            String includedTextRepr = StringHelper.isEmpty(textRepr) ? "" : (ID_AND_TEXT_DIV + escape(textRepr));
            ret += fieldData.getFieldID() + ID_AND_TEXT_DIV
                    + escape(valueRepr) + includedTextRepr + FIELDS_DIV;
        }
        return ret;
    }

    public static List<EntityData> deSerializeEntities(String serializedEntities, LogonSession ls, ActionContext ctx) {
        List<EntityData> ents = new LinkedList<EntityData>();
        if(!StringHelper.isEmpty(serializedEntities)) {
            String[] entities = splitEscaped(serializedEntities, ENTITY_DIV);
            for(String entity : entities) {
                EntityData data = deSerializeEntity(entity, ls, ctx);
                if(data != null) {
                    ents.add(data);
                }
            }
        }