तो, मैं, किसी एप्लिकेशन (आईओएस, स्विफ्ट) में एक 'retweet' की तरह कार्यक्षमता को लागू करने Parse उपयोग करने के साथ काम सौंपा गया है।parse.com 'रीट्वीट' पैटर्न भी वर्बोज़ है
यह here से पहले पूछा गया है, लेकिन यह एक है) बहुत उच्च स्तर और बी) मुझे यह काम मिल रहा है - मैं वास्तुशिल्प निर्णयों पर मदद मांगना नहीं चाहता हूं, हालांकि ऐसा लगता है कि मैं स्पष्ट रूप से गायब हूं कुछ, मुझे फीडबैक स्वीकार करने में खुशी है।
मेरे ऐप में CAUSES हैं जो प्रत्येक उपयोगकर्ता द्वारा बनाए गए हैं। एक TO और उपयोगकर्ता से एक FOLLOW तालिका भी है। तो शुरू करने के लिए, मैं बस सीएयूएसईएस तालिका से पूछताछ करता हूं कि जिस उपयोगकर्ता ने पोस्ट किया है, उसे उस तालिका से उपयोगकर्ता से मिलान करना चाहिए (जहां वर्तमान उपयोगकर्ता उपयोगकर्ता से है)। अधिक संक्षेप में:
let getFollowedUsersQuery = PFQuery(className: Constants.kParseClassFollowers)
getFollowedUsersQuery.whereKey(Constants.kParseFieldFromUser, equalTo: PFUser.currentUser()!)
let causesQuery = PFQuery(className: Constants.kParseClassCauses)
causesQuery.whereKey(Constants.kParseFieldFromUser, matchesKey: Constants.kParseFieldToUser, inQuery: getFollowedUsersQuery)
causesQuery.findObjectsInBackgroundWithBlock({ (objects, error) -> Void in
if let causes = objects {
for cause in causes {
// populate the tableview cells, etc.
}
}
})
अब मेरे पास उन उपयोगकर्ताओं के सभी कारण हैं जिनका मैं पालन करता हूं ... यह सब कुछ मानक है।
यहां यह मुश्किल हो जाता है।
प्रत्येक कारण में एक सहयोगी भी है जिसे समर्थक कहा जाता है। अब मुझे उन लोगों से सभी केस प्राप्त करने के लिए एक तरीका बनाने की आवश्यकता है, जिनका मैं पालन नहीं करता हूं, लेकिन जिनके पास मैं समर्थन करने वाले उपयोगकर्ता की सूची में हूं।
मैं, एक सुरुचिपूर्ण समाधान खोजने के लिए अभी तक है, हालांकि मैं एक 'जानवर बल' एक के करीब पहुंच रहा हूँ, और यह इतना बोझिल और वर्बोज़ कि मेरी प्रोग्रामर के मस्तिष्क का बेहतर आधा screaming at me like Susan Powter है ...
यहाँ एक है नमूना:
let retweetQuery = PFQuery(className: Constants.kParseClassCauses)
retweetQuery.orderByDescending(Constants.kParseFieldCreatedAt)
retweetQuery.whereKey(Constants.kParseFieldFromUser, notEqualTo: PFUser.currentUser()!)
retweetQuery.whereKey(Constants.kParseFieldFromUser, doesNotMatchKey: Constants.kParseFieldToUser, inQuery: getFollowedUsersQuery)
retweetQuery.findObjectsInBackgroundWithBlock({ (objects, error) -> Void in
if let causes = objects {
for cause in causes {
let supporterRelations = cause.relationForKey(Constants.kParseClassSupporters)
let supporterQuery = supporterRelations.query()
supporterQuery.findObjectsInBackgroundWithBlock { (supporters, error) in
if(error == nil && supporters?.count > 0) {
for supporter in supporters! {
let user:PFUser = supporter as! PFUser
getFollowedUsersQuery.whereKey(Constants.kParseFieldToUser, equalTo: user)
getFollowedUsersQuery.whereKey(Constants.kParseFieldFromUser, equalTo: PFUser.currentUser()!)
getFollowedUsersQuery.findObjectsInBackgroundWithBlock({ (results, error) -> Void in
if(error == nil && results?.count > 0) {
for result in results! {
// do stuff
}
}
})
}
}
}
}
}
})
अब, यह शुद्ध पागलपन, और अविश्वसनीय रूप से बेकार है (विशेष रूप से विचार कर रहा है कि कैसे पार्स मुक्त स्तरीय गणना करता है - मुझे लगता है यह वास्तव में मेरे एपीआई सीमित करने के लिए भारी योगदान कर सकता है, तो उत्पादन करने के लिए धक्का दिया)।
पहले से ही दो प्रश्नों किया, मैं फिर से करना एक पूरी तरह से है, तो समर्थक संबंधों पर प्रत्येक कारण के लिए किसी अन्य क्वेरी करते हैं, तो उस संबंध में प्रत्येक उपयोगकर्ता पर किसी अन्य क्वेरी कर अगर मैं उन्हें का पालन करें देखने के लिए ... और एक बार मेरे पास यह जानकारी हो जाने के बाद, मुझे उस उपयोगकर्ता के समर्थित कारणों के माध्यम से लूप करना होगा (पार्स प्रश्नों की असीमित वापसी की वजह से, मुझे नहीं लगता कि मैं केवल माता-पिता के लूप में वापस पहुंच सकता हूं) ... जो मैं अभी तक लागू नहीं किया है, क्योंकि मैं तौलिया में फेंकने वाला हूं - एक बेहतर तरीका होना चाहिए!
मुझे आशा है कि मैं एक रणनीति यहाँ याद कर रहा हूँ ...
मुझे लगता है कि आप एक की जरूरत है समर्थकों से कारणों के लिए बैकलिंक, नहीं? इस मामले में, मैं उन उपयोगकर्ताओं के लिए एक लिंकिंग टेबल की अनुशंसा करता हूं जिनके वे सपोर्टर्स सूची में हैं।फिर यह केवल दो प्रश्न हैं - मेरे सभी अनुसरणकर्ताओं को प्राप्त करें, और उसके बाद उन कारणों को प्राप्त करें जिन पर प्रत्येक उपयोगकर्ता एक सहायक है, और फिर डुप्लिकेट कारणों को कम कर देता है। – tbondwilkinson
हाँ, यह समझ में आता है ... मैं इसे एक विकल्प के रूप में एक्सप्लोर करूंगा। –
मैं इस ढांचे से परिचित नहीं हूं, लेकिन अर्थशास्त्र को बदलने के बिना, आप सिंटैक्स को थोड़ा सरल बना सकते हैं। मैं आमतौर पर लिखता हूं 'अगर x = y {के लिए मैं x में ... {'' के रूप में मैं y में ?? [] {... '। मैं 'अगर त्रुटि == शून्य ... '' गार्ड त्रुटि के साथ बदलना चाहूंगा! = शून्य और {वापसी} '। वे दो आपको लाइनों को नहीं बचाएंगे, लेकिन वे आपको कॉलम सहेजते हैं: इससे इंडेंटेशन के 9 स्तरों से 6 तक आपके भीतर की '// डू स्टफ' कम हो जाएगी, जो * पागल नहीं है। –