ios - sincronizar - de google drive a icloud whatsapp

¿Cómo evitar que Parse guarde los archivos secundarios de PFObject?

Question

Estoy enfrentando un problema muy común con Parse y iOS.

Tengo un POST de clase con la siguiente estructura:

• text(String)
• Image (PFFile)
• LikesUsers (Array of String)
• LikesCount (Int)
• From (Pointer to User who posted it)

y si al usuario (que ya inició sesión) le gusta una publicación. Solo estoy incrementando los Me gusta y agrego Objectid del usuario a la matriz

Por ejemplo: al Usuario-2 le gusta la Publicación del Usuario-1.

PostObject.incrementKey("Likes")
PostObject.addObject((PFUser.currentUser()?.objectId)!, forKey: "LikesUsers")
PostObject.saveEventually()

El problema está aquí. No puedo guardar un PostObjeto siempre que tenga un puntero a otro usuario (que el que está conectado) Obtengo el error:

El usuario no puede guardarse a menos que haya sido autenticado mediante logIn o signUp

Entonces, ¿cómo evitar que se guarde ParseObject Children ("De")

No quiero usar un CloudCode, quiero que sea sencillo y usar SaveEventually para una mejor experiencia de usuario.

Answer 1

De los foros de parse.com:

Cuando guarda un objeto con un puntero, Parse observa la totalidad del objeto y guarda los campos que están "sucios" (modificados desde la última vez que guardó). También inspecciona todos los objetos apuntados por punteros. Si su objeto tiene un puntero a PFUser y la instancia del PFUser está "sucia", Parse guardará el objeto y luego intentará guardar la instancia del PFUser también. Mi hipótesis es que en algún lugar de tu código estás estableciendo un valor para un usuario y luego no lo guardas. Esto, sospecho, es la fuente de su error. Revise su código y busque donde quiera que configure una instancia de PFUser y asegúrese de que haya un guardado correspondiente. Si no puede encontrarlo a primera vista, asegúrese de verificar todos los bloques y asegúrese de no ensuciar asincrónicamente a un usuario y tratar de salvarlo posteriormente.

¿Estás intentando hacer algún cambio al usuario por el que se creó la publicación?

Answer 2

Respuesta corta:

Intenta establecer from campo como:

let author = PostObject["from"] as! PFObject
PostObject["from"] = PFObject(withoutDataWithClassName: "_User",
objectId: author.objectId)

Esto no está probado.

Pero te sugiero que cambies la arquitectura

Estaba enfrentando el mismo problema y finalmente decidí mover el campo "me likes a User clase de User y convertirlo en el tipo de Relation<Post> . La documentación de Parse dice que el tipo de Relation es mejor para mantener muchos objetos. Dado que LikesUsers es una matriz de objetos, el rendimiento puede disminuir significativamente si una publicación obtiene muchos "me gusta": la aplicación descargará a todos los usuarios que les gustó esta publicación. Consulte esto para obtener más información: https://parse.com/docs/ios/guide#objects-relational-data

Así es como se ve mi estructura de clase (simplificada):

Usuario :

• postLikes (Relación)

Mensaje :

• autor (PFObject)
• likesCount (Int)

También moví la lógica like / dislike a la función CloudCode:

/// The user liked or disliked the post.
Parse.Cloud.define("likeDislikePost", function(request, response) {
var userProfileId = request.params.userProfileId
var postId = request.params.postId
// Shows whether the user liked or disliked the post. Bool value
var like = request.params.like
var query = new Parse.Query("_User");
query.equalTo("objectId", userProfileId);
query.first({
success: function(userProfile) {
if (userProfile) {
var postQuery = new Parse.Query("Post");
postQuery.equalTo("objectId", postId);
postQuery.first({
success: function(post) {
if (post) {
var relation = userProfile.relation("postLikes");
if (like) {
relation.add(post);
post.increment("likesCount");
}
else {
relation.remove(post)
post.increment("likesCount", -1);
}
post.save();
userProfile.save();
console.log("The user with user profile id " + userProfileId + " " + (like ? "liked" : "disliked") + " the post with id " + postId);
response.success();
}
else {
response.error("Unable to find a post with such ID");
}
},
error: function() {
response.error("Unable to like the post");
}
});
}
else {
response.error("Unable to find a user profile with such ID");
}
},
error: function() {
response.error("Unable to like the post");
}
});
});

Funciona bien

Answer 3

Creé un proyecto desde cero para ti. Creo que te pierdes algo cuando creas tu PFClass. No lo sé. Lo que sea que mire mis códigos,

Este es ViewController y contiene como Acción de botón;

 import UIKit
class ViewController: UIViewController {
private let test = Test() // PFObject SubClass
private let post = Post() // PFObject SubClass
@IBAction func likeButton() {
self.test.fromUser = PFUser.currentUser() // Current User
self.test.likedUsers.append(Post().user // In there your post should be a Subclass of PFObject too like your this Test class and it should be contains Owner property. So you can grab the Post owner PFUser or User Object ID.)
self.test.saveEventually() {
(let success, error) in
if error == nil {
// Success
} else {
print(error?.localizedDescription)
}
}
}
}

En su AppDelegate inicie su ParseSDK y registre sus nuevas subclases Parse.

 func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
// Override point for customization after application launch.
Parse.setApplicationId("YOUR_API_KEY", clientKey: "YOUR_CLIENT_KEY")
Test.registerSubclass()
Post.registerSubclass()
return true
}

Subclase de prueba;

import Foundation
import Parse
class Test: PFObject, PFSubclassing {
// Your Properties
@NSManaged var likedUsers: [PFUser]
@NSManaged var fromUser: PFUser
static func parseClassName() -> String {
return "Test" // Your Class Name
}
}

Subclase de publicación;

 class Post: PFObject, PFSubclassing {
// Your Properties
@NSManaged var owner: PFUser
@NSManaged var likeCount: NSNumber
static func parseClassName() -> String {
return "Post" // Your Class Name
}
}

En mi caso, funciona bien. Si obtiene un error, infórmeme.

Que tengas una buena codificación.