Question

经过多天的努力，我设法从Parse Cloud Query中检索出我想要的结果。

我的问题是我有两个查询与一个查询，因此需要使用diffurent列来显示。

我正在使用Ionic3 / Angular 4和Parse Server。

这是我的Parse Cloud Code

    Parse.Cloud.define('FriendsQuery', function (req, res) {
  const fromUserQ = new Parse.Query("Friends")
    .equalTo("toUser", req.user)
    .include('fromUser')
    .find();

  const toUserQ = new Parse.Query("Friends")
    .equalTo("fromUser", req.user)
    .include('toUser')
    .find();

  Parse.Promise.when(toUserQ, fromUserQ)
    .then((toUsers, fromUsers) =>
      res.success({
        toUsers: toUsers.map(e => e.get('toUser')),
        fromUsers: fromUsers.map(e => e.get('fromUser')),
      }))
    .catch(res.error);
});

meets.ts

import { Data } from './../../services/data';
import { localData } from './../../services/local';
import { Component } from '@angular/core';
import { NavController } from 'ionic-angular';
import { Parse } from 'parse';
import 'rxjs/add/operator/map';
import {User} from '../../models/User';
import 'rxjs/add/operator/debounceTime';
import {FormControl} from '@angular/forms';

@Component({
  selector: 'page-meet',
  templateUrl: 'meet.html'
})
export class MeetPage {

  currentUser = Parse.User.current();
  query = new Parse.Query(Parse.User);
  tmp =[];
  tmp2 =[];
  friends: any=[];

  initializeItems() {
  this.friends = this.localdata.tmpfriends;
  }

  retrieveFriends(){
   if (this.currentUser= Parse.User.current()) {
     console.log(this.currentUser.id)
     Parse.Cloud.run('FriendsQuery',{currentuser: this.currentUser.id}).then(
     res => {       
       console.log(res);
       this.tmp2 = res;
       this.localdata.setFriends(this.tmp2);
       this.friends = this.localdata.tmpfriends;
       console.log(this.friends);
       });            
   }
   }

  constructor(public navCtrl: NavController, private localdata: localData, private dataService: Data) {
    this.searchControl = new FormControl;
}

showFriends: any = false;
searchControl: FormControl;
searchTerm: string = '';
searching: any = false;

filterfriends(searchTerm){ 
       return this.friends.filter((friend) => {
           return friend.fromUser.username.toLowerCase().indexOf(searchTerm.toLowerCase()) > -1;
       });    
    }

ionViewDidLoad() {
  this.retrieveFriends();
  this.setFilteredItems();
  this.searchControl.valueChanges.debounceTime(700).subscribe(search => {
    this.searching = false;
    this.setFilteredItems();
     });
}

onSearchInput(){
  this.searching = true;
  }

setFilteredItems() {
  this.initializeItems();
  this.friends = this.filterfriends(this.searchTerm);
}  

onCancel(ev: any) {
  this.initializeItems();
}
}

meet.html

  <ion-header>
  <ion-navbar>
    <ion-searchbar [(ngModel)]="searchTerm" [formControl]="searchControl" (ionCancel)="onCancel($event)" (ionInput)="onSearchInput()">
  </ion-searchbar>
  </ion-navbar>
</ion-header>

<ion-content padding>
    <div *ngIf="searching" class="spinner-container">
        <ion-spinner></ion-spinner>
    </div>
       <ion-item class="item-avatar item-avatar-left item-button-right common-list" >
            <ion-avatar *ngIf="friend.fromUser.objectId == currentUser.id" item-left><img style="left:0px !important;margin-top:0px !important;" [src]="friend.toUser.avatar  || '/assets/img/no-avatar.png'"/></ion-avatar>
            <ion-label *ngIf="friend.fromUser.objectId == currentUser.id">{{friend.toUser.username}}</ion-label>
            <ion-avatar *ngIf="friend.toUser.objectId == currentUser.id" item-left><img style="left:0px !important;margin-top:0px !important;" [src]="friend.fromUser.avatar  || '/assets/img/no-avatar.png'"/></ion-avatar>
            <ion-label *ngIf="friend.toUser.objectId == currentUser.id">{{friend.fromUser.username}}</ion-label>
            </ion-item>
</ion-content>

local.ts

import { Component } from '@angular/core';

export class localData {

    setFriends (friends){
        window.localStorage.friends_data = JSON.stringify(friends);
    }
    getFriends(){
       return JSON.parse(window.localStorage.friends_data || '[]');
    }

    tmpfriends = this.getFriends();
   }

在我的“朋友”表中，我有两列，“fromUser”和“toUser”，我想显示当前登录用户的朋友。因此，在Angular代码中，我需要 friend.toUser.username 和 friend.fromUser.username ，具体取决于登录用户。

当我使用第一个时，我只得到向登录用户发送好友请求的用户的结果，反之亦然。

我附上图片链接以便更清楚。我不想在屏幕上显示结果，而是我用箭头指向的结果。

使用hmtl代码我设法得到了这个结果，但用这个来过滤它们并不方便：

filterfriends(searchTerm){ 
return this.friends.filter((friend) => {
return friend.fromUser.username.toLowerCase().indexOf(searchTerm.toLowerCase()) > -1;
});    
 }

因为我需要过滤friend.toUser和friend.fromUser

screenshot

谢谢

Answer 1

如果{ "__type": "Pointer", "className": "_User", "objectId": req.params.currentuser }和toUser已经是用户指针，那么您不需要整个fromUser，您可以.equalTo("toUser", request.params.currentUser);。此外，如果您是从已登录的客户端发出此请求，则可以执行.equalTo("toUser", request.user);

还有一个查询方法，.include(<key>);将包含指向的对象。因此，您可以执行friendQuery.include("toUser").include("fromUser");并获取该信息。并且，如果你的用户有一些额外的指针，比如一个ContactInfo类，这适用于点表示法。您可以query.include("toUser.contactInfo");，也可以包含该对象。

除此之外，我并不完全确定你所遇到的问题是什么。你想工作的是什么工作？听起来你得到了你想要的信息。

Answer 2

所以，如果我理解了这个问题，你想要的是：

回到单个朋友阵列，因为你真的不在乎哪个是来自用户，哪个是用户，你只想要所有的朋友。
你希望这个列表“被删除”，因为你可能已经被同一个用户点缀过，并且你不希望它在列表中两次。
您可能也想过滤好友。

在单个云功能中执行此操作非常有意义。

字符串匹配有点棘手。我们可以使用正则表达式和matches query函数，但由于我们在用户表上匹配而不是在friends表上匹配，所以它很棘手。为简单起见，我只是在javascript中过滤结果。

对于重复数据删除，我使用lodash lib。

const fp = require('lodash/fp');

Parse.Cloud.define('FriendsQuery', function (req, res) {
  const fromUserQ = new Parse.Query('Friends')
    .equalTo('toUser', req.user)
    .include('fromUser')
    .find();

  const toUserQ = new Parse.Query('Friends')
    .equalTo('fromUser', req.user)
    .include('toUser')
    .find();

  return Parse.Promise.when(toUserQ, fromUserQ)
    .then((toUsers, fromUsers) => {
     const friendsWithDupes = toUsers.map(e => e.get('toUser'))
        .concat(fromUsers.map(e => e.get('fromUser')));
      // fp.uniquWith(comparator)(arrayToDeDupe);
      const friends = fp.uniqWith((x, y) => x.id === y.id)(friendsWithDupes);

      if (req.params.searchTerm) {
        const lowerSearchTerm = req.params.searchTerm.toLowerCase();
        const filteredFriends = friends.filter(
          friend => friend.get('username').toLowerCase().indexOf(lowerSearchTerm) > -1
        );
        return res.success(filteredFriends);
      }

      return res.success(friends);
    })
    .catch(e => res.error(JSON.stringify(e)));
});

您可以使用或不使用搜索字词来调用此函数：

Parse.Cloud.run('FriendsQuery', { searchTerm: 'bob' })

或

Parse.Cloud.run('FriendsQuery')

解析云代码定义结果

2 个答案: