cn.leancloud.ops.Utils Maven / Gradle / Ivy

Go to download
package cn.leancloud.ops;

import java.util.*;

import cn.leancloud.*;
import cn.leancloud.gson.ObjectDeserializer;
import cn.leancloud.types.LCGeoPoint;
import cn.leancloud.utils.StringUtil;

import cn.leancloud.codec.Base64;
import cn.leancloud.json.JSONObject;

public class Utils {
  private static final String typeTag = "__type";

  public static Map createPointerArrayOpMap(String key, String op,
                                                            Collection objects) {
    Map map = new HashMap();
    map.put("__op", op);
    List> list = new ArrayList>();
    for (LCObject obj : objects) {
      list.add(mapFromPointerObject(obj));
    }
    map.put("objects", list);
    Map result = new HashMap();
    result.put(key, map);
    return result;
  }

  public static Map mapFromPointerObject(LCObject object) {
    return mapFromAVObject(object, false);
  }

  public static Map mapFromGeoPoint(LCGeoPoint point) {
    Map result = new HashMap();
    result.put(typeTag, "GeoPoint");
    result.put("latitude", point.getLatitude());
    result.put("longitude", point.getLongitude());
    return result;
  }

  public static LCGeoPoint geoPointFromMap(Map map) {
    double la = ((Number) map.get("latitude")).doubleValue();
    double lo = ((Number) map.get("longitude")).doubleValue();
    LCGeoPoint point = new LCGeoPoint(la, lo);
    return point;
  }

  public static LCObject parseObjectFromMap(Map map) {
    LCObject LCObject = Transformer.objectFromClassName((String) map.get("className"));
    map.remove("__type");
    LCObject.resetServerData(map);
    return LCObject;
  }

  public static byte[] dataFromMap(Map map) {
    String value = (String) map.get("base64");
    return Base64.decode(value, Base64.NO_WRAP);
  }
  public static Date dateFromMap(Map map) {
    String value = (String) map.get("iso");
    return StringUtil.dateFromString(value);
  }


  public static Map mapFromDate(Date date) {
    Map result = new HashMap();
    result.put(typeTag, "Date");
    result.put("iso", StringUtil.stringFromDate(date));
    return result;
  }

  public static Map mapFromByteArray(byte[] data) {
    Map result = new HashMap();
    result.put(typeTag, "Bytes");
    result.put("base64", Base64.encodeToString(data, Base64.NO_WRAP));
    return result;
  }

  public static Map mapFromFile(LCFile file) {
    Map result = new HashMap();
    result.put("__type", "_File");
    result.put("metaData", file.getMetaData());
    result.put("id", file.getName());
    return result;
  }

  public static Map mapFromAVObject(LCObject object, boolean topObject) {
    Map result = new HashMap();
    result.put("className", object.internalClassName());

    if (!StringUtil.isEmpty(object.getObjectId())) {
      result.put("objectId", object.getObjectId());
    }
    if (!topObject) {
      result.put("__type", "Pointer");
    } else {
      result.put("__type", "Object");

      Map serverData = getParsedMap(object.getServerData(), false);
      if (serverData != null && !serverData.isEmpty()) {
        result.putAll(serverData);
      }
    }
    return result;
  }

  public static Map getParsedMap(Map map) {
    return getParsedMap(map, false);
  }

  public static Map getParsedMap(Map object, boolean topObject) {
    Map newMap = new HashMap(object.size());

    for (Map.Entry entry : object.entrySet()) {
      final String key = entry.getKey();
      Object o = entry.getValue();
      newMap.put(key, getParsedObject(o, topObject));
    }

    return newMap;
  }

  public static List getParsedList(Collection list) {
    List newList = new ArrayList(list.size());

    for (Object o : list) {
      newList.add(getParsedObject(o));
    }

    return newList;
  }

  public static List getParsedList(Collection object, boolean topObject) {
    if (!topObject) {
      return getParsedList(object);
    } else {
      List newList = new ArrayList(object.size());

      for (Object o : object) {
        newList.add(getParsedObject(o, true));
      }

      return newList;
    }
  }

  public static Object getParsedObject(Object object) {
    return getParsedObject(object, false);
  }

  public static Object getParsedObject(Object object, boolean topObject) {
    if (object == null) {
      return null;
    } else if (object instanceof Map) {
      return getParsedMap((Map) object, topObject);
    } else if (object instanceof Collection) {
      return getParsedList((Collection) object, topObject);
    } else if (object instanceof LCObject) {
      if (!topObject) {
        return mapFromPointerObject((LCObject) object);
      } else {
        return mapFromAVObject((LCObject) object, true);
      }
    } else if (object instanceof LCGeoPoint) {
      return mapFromGeoPoint((LCGeoPoint) object);
    } else if (object instanceof Date) {
      return mapFromDate((Date) object);
    } else if (object instanceof byte[]) {
      return mapFromByteArray((byte[]) object);
    } else if (object instanceof LCFile) {
      return mapFromFile((LCFile) object);
    } else {
      return object;
    }
  }

  public static Map createArrayOpMap(String key, String op, Collection objects) {
    Map map = new HashMap();
    map.put("__op", op);
    List