无法更新用户信息＆amp; ParseCloud.callFunction（）缺少用户信息

Question

每当我调用这些查询时，我都无法更新用户信息＆amp; ParseCloud.callFunctionInBackground（）缺少用户信息（云函数中的request.user为null）！

查询＃1

((User) ParseUser.getCurrentUser())
        .getChats()
        .getQuery()
        .include(CHAT_TEACHER1)
        .include(CHAT_STUDENT1)
        .findInBackground();

查询＃2

ParseQuery.getQuery(Rate.class)
        .include(RATE_RATER)
        .include(RATE_RATETO)
        .include(RATE_LESSON)
        .whereEqualTo(RATE_RATER, ParseUser.getCurrentUser())
        .whereEqualTo(RATE_RATED, false)
        .findInBackground();

查询＃3

ParseQuery.getQuery(Message.class)
        .include(MESSAGE_FROM)
        .include(MESSAGE_LESSON)
        .whereEqualTo(MESSAGE_CHAT, ParseObject.createWithoutData(Chat.class, chatId))
        .orderByDescending(MESSAGE_ORDER)
        .setLimit(MESSAGE_PER_PAGE)
        .setSkip(MESSAGE_PER_PAGE * page)
        .findInBackground();

这三个查询的常见内容是所有这些查询都包含currentUser（）。这意味着所有此查询都返回与user和currentUser有关系的每个对象的列表，这些查询可以包含在这些查询中。

这是我的模型设置。 用户

@ParseClassName("_User")
public class User extends ParseUser {

    public String getFullname() {
        return getString(USER_FULLNAME);
    }

    public void setFullname(@NonNull String string) {
        put(USER_FULLNAME, string);
        EventBus.getInstance().post(new RedrawSettingsViewEvent());
    }

    public Date getBirthDay() {
        return getDate(USER_BIRTHDAY);
    }

    public void setBirthDay(@NonNull Date date) {
        put(USER_BIRTHDAY, date);
        EventBus.getInstance().post(new RedrawSettingsViewEvent());
    }

    public Gender getGender() {
        return Gender.fromString(getString(USER_GENDER));
    }

    public void setGender(@NonNull Gender gender) {
        put(USER_GENDER, gender.toString());
    }

    public MemberType getMemberType() {
        return MemberType.fromString(getString(USER_MEMBER_TYPE));
    }

    public void setMemberType(@NonNull MemberType memberType) {
        put(USER_MEMBER_TYPE, memberType.toString());
    }

    public Number getPriceMin() {
        return getNumber(USER_PRICE_MIN);
    }

    public void setPriceMin(int integer) {
        if (integer < 0 || integer > 200)
            throw new RuntimeException("Price validation error");

        put(USER_PRICE_MIN, integer);
    }

    public List<Language> getLanguages() {
        return (List<Language>) get(USER_LANGUAGES);
    }

    public void setLanguages(List<Language> languages) {
        put(USER_LANGUAGES, languages);
    }

    public Language getLanguageOf(LanguageLevel languageLevel) {
        List<Language> all = getLanguages();
        if (languageLevel == null || all == null)
            return null;

        for (Language language : all)
            if (languageLevel == language.getLanguageLevel())
                return language;

        return null;
    }

    public List<Language> getSpeakings() {
        List<Language> others = new ArrayList<>();
        List<Language> all = getLanguages();
        if (all == null)
            return others;

        for (Language language : all)
            if (language.getLanguageLevel().getLanguageType() == LanguageLevel.LanguageType.speaking)
                others.add(language);

        return others;
    }

    public ParseRelation<Chat> getChats() {
        return getRelation(USER_CHATS);
    }

    public ParseRelation<Rate> getRates() {
        return getRelation(USER_RATES);
    }

    public void savePinEventually() {
        saveEventually();
        pinInBackground();
    }

    public void savePinEventually(@NonNull SaveCallback saveCallback) {
        saveEventually();
        pinInBackground(saveCallback);
    }

    public void savePinInBackground() {
        saveInBackground();
        pinInBackground();
    }

    public void savePinInBackground(@NonNull final SaveCallback saveCallback) {
        saveInBackground();
        pinInBackground(new SaveCallback() {
            @Override
            public void done(ParseException e) {
                if (e == null) {
                    saveInBackground(saveCallback);
                } else {
                    saveCallback.done(e);
                }
            }
        });
    }
}

率

@ParseClassName("Rate")
public class Rate extends ParseObject {

    public Number getRate() {
        return getNumber(RATE_RATE);
    }

    public void setRate(float rate) {
        put(RATE_RATE, rate);
    }

    public User getRater() {
        return (User) getParseUser(RATE_RATER);
    }

    public void setRater(User rater) {
        put(RATE_RATER, rater);
    }

    public User getRateTo() {
        return (User) getParseUser(RATE_RATETO);
    }

    public void setRateTo(User rateTo) {
        put(RATE_RATETO, rateTo);
    }

    public Lesson getLesson() {
        return (Lesson) getParseObject(RATE_LESSON);
    }

    public void setLesson(Lesson lesson) {
        put(RATE_LESSON, lesson);
    }

    public boolean getRated() {
        return getBoolean(RATE_RATED);
    }

    public void setRated(boolean rated) {
        put(RATE_RATED, rated);
    }
}

@ParseClassName("Chat")
public class Chat extends ParseObject {

    public int getNumberOfChatter() {
        Number counter = getNumber(CHAT_NUMBER_OF_CHATTER);
        return counter == null ? 0 : counter.intValue();
    }

    public void setNumberOfChatter(int number) {
        put(CHAT_NUMBER_OF_CHATTER, number);
    }

    public User getTeacher1() {
        return (User) getParseUser(CHAT_TEACHER1);
    }

    public void setTeacher1(User user) {
        put(CHAT_TEACHER1, user);
    }

    public User getStudent1() {
        return (User) getParseUser(CHAT_STUDENT1);
    }

    public void setStudent1(User user) {
        put(CHAT_STUDENT1, user);
    }

    public Date getOrder() {
        Date order = getDate(CHAT_ORDER);
        if (order != null)
            return order;
        else
            return getCreatedAt();
    }

    public void updateOrder() {
        put(CHAT_ORDER, new Date());
    }
}

消息

@ParseClassName("Message")
public class Message extends ParseObject {

    public Chat getChat() {
        return (Chat) getParseObject(MESSAGE_CHAT);
    }

    public void setChat(Chat chat) {
        put(MESSAGE_CHAT, chat);
    }

    public MessageType getType() {
        return MessageType.fromString(getString(MESSAGE_TYPE));
    }

    public void setType(@NonNull MessageType messageType) {
        put(MESSAGE_TYPE, messageType.toString());
    }

    public User getFrom() {
        return (User) getParseObject(MESSAGE_FROM);
    }

    public void setFrom(User user) {
        put(MESSAGE_FROM, user);
    }

    public String getText() {
        return getString(MESSAGE_TEXT);
    }

    public void setText(String text) {
        put(MESSAGE_TEXT, text);
    }

    public Lesson getLesson() {
        return (Lesson) getParseObject(MESSAGE_LESSON);
    }

    public void setLesson(Lesson lesson) {
        put(MESSAGE_LESSON, lesson);
    }

    public Date getOrder() {
        Date order = getDate(MESSAGE_ORDER);
        if (order != null)
            return order;
        else if (getCreatedAt() != null)
            return getCreatedAt();
        else
            return new Date();
    }

    public void setOrder(Date order) {
        put(MESSAGE_ORDER, order);
    }
}

这是我的应用程序设置

public class BaseApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();

        Parse.setLogLevel(Parse.LOG_LEVEL_VERBOSE);

        ParseObject.registerSubclass(User.class);
        ParseObject.registerSubclass(Language.class);
        ParseObject.registerSubclass(Chat.class);
        ParseObject.registerSubclass(Message.class);
        ParseObject.registerSubclass(Lesson.class);
        ParseObject.registerSubclass(Payment.class);
        ParseObject.registerSubclass(Payout.class);
        ParseObject.registerSubclass(Rate.class);

        Parse.enableLocalDatastore(this);
        Parse.initialize(this, "XXXX", "XXXX");

        ParseACL defaultACL = new ParseACL();
        defaultACL.setPublicReadAccess(true);
        defaultACL.setPublicWriteAccess(true);
        ParseACL.setDefaultACL(defaultACL, false);

        ParseFacebookUtils.initialize(this);
        ParseInstallation.getCurrentInstallation().saveInBackground();
    }
}

Cloud Code

Parse.Cloud.define('globeeFeed', function(request, response) {

   // Check whether user is logged in
   var user = request.user;
   if (!user)
      return errors.alert(response, null, 'Globee Feed', 'User is not yet logged in.');

   // request.params
   // request.params.languageCode
   // request.params.male
   // request.params.female
   // request.params.priceMin
   // request.params.priceMax
   // request.params.distance
   // request.params.latitude
   // request.params.longitude
   // request.params.seed
   // request.params.page
   // request.params.itemPerPage

   // Check whether parameters are valid
   if (!request.params
      || !request.params.languageCode
      || typeof request.params.male === typeof undefined
      || typeof request.params.female === typeof undefined
      || !request.params.priceMin === typeof undefined
      || !request.params.priceMax === typeof undefined
      || !request.params.distance === typeof undefined
      || !request.params.seed === typeof undefined
      || !request.params.page === typeof undefined)
      return errors.log(response, null, 'Globee Feed', 'Not enough parameters.');
}

request.user为null！

这不是唯一的问题，我也发现了哪个代码正在解决这个问题。如果我包含_User类，那么用户就会被搞砸（使用localdatastore）并且用户信息会丢失。

这才是真正发生的事情  1.打开应用程序
 2.应用程序调用包含_User类的查询  3.关闭应用程序并重新打开它  4.用户信息丢失，云代码表示request.user为空，我甚至无法编辑当前用户（saveInBackground表示错误为空，但未保存在解析服务器中）

Parse-1.9.2也存在问题。数据不会丢失，但查询本身太慢，有些手机在某些时候给我ANR。

我正在使用Parse-1.9.4，Bolt-1.2.0。