def post(self): logging.info("chat form: %r" % self.request.form) frm = self.request.form.get('from') to = self.request.form.get("to") txt = self.request.form.get("body") jid,res = frm.split('/', 1) board = to.split('@')[0] if txt == 'SUB': sub(jid, board) return Response("ya") headline = txt[:txt.find('\n')] th = re.search('^>>(\d+)', headline) if th: th = thread_lookup(th.group(1), board) else: th = re.search('^>>/(\w+)/(\d+)', headline) if th: board,th = th.groups() th = thread_lookup(th, board) else: th = 'new' if not th: xmpp.send_message(frm, "WINRY WINRY WINRY", from_jid=to) return Response("ya") person = {} if not antiwipe.check(person, ip=jid, board=board, thread=th): xmpp.send_message(frm, "Posted. not really. Keep trying", from_jid=to) return Response("ya") logging.info('post: %r %r %s' % (board, th, txt)) #board = 'test' args = { "text": txt, "subject": "", "name": "Anonymous", } post, thread = save_post(self.request, args, board, th, jid) MSG = "Posted http://42ch.org/%s/%d/#p%d" %(board, thread, post) # query = 'board:%s thread:%d' %(board, thread) sub_id = '%s/%s/%d' % (jid, board, thread) matcher.subscribe(MatchPost, query, sub_id, topic='post') xmpp.send_message(frm, MSG, from_jid=to,) return Response("ya")
def post(self): event = self.request.POST['event'] datapoint = self.request.POST['datapoint'] subscription_id = models.StatsSubscription(event=event, datapoint=datapoint).put() prospective_search.subscribe(stats.StatsRecord, 'event:%s' % event, subscription_id) self.response.out.write("Subscribed the datapoint %s to %s events." % (datapoint, event))
def get(self): when = int(time.time() + (3600 * 2)) sub_list = matcher.list_subscriptions(Ep, expires_before=when) for sub_id, query, expiration_time, state, error in sub_list: matcher.subscribe(Ep, query, sub_id) return Response("ok")
def post(self): sub = model.Subscription( client_id=self.request.POST['client_id']) sub.put() prospective_search.subscribe( model.RequestRecord, self.request.POST['query'], str(sub.key()), lease_duration_sec=config.SUBSCRIPTION_TIMEOUT.seconds) self.response.out.write(str(sub.key()))
def post(self, board, thread): # FIXME: move subscribe crap somewhere out rb = rainbow.make_rainbow(self.request.remote_addr, board, thread) person_cookie = self.get_secure_cookie("person", True, max_age=MONTH*12) person = person_cookie.get("update", str(uuid())) person_cookie['update'] = person subid = "%s/%s/%s/%d" %(rb, person, board, thread, ) token = memcache.get(subid) if not token: token = channel.create_channel(subid) memcache.set(subid, token) try: query = 'thread:%d board:%s' %(thread, board) matcher.subscribe(util.Post, query, subid, topic='post', lease_duration_sec=self.WATCH_TIME) except OverQuotaError: logging.error("subscribe failed") token = None post_level = util.post_level(self.request.remote_addr) """ if self.NEWFAG and \ not person_cookie.get("postcount") > self.OLDFAG and \ (board, thread) not in self.NEWFAG: post_level = "err" """ return json_response( { "token" : token, "post_quota" : post_level, "watcher_time" : self.WATCH_TIME, } )
def create_query_and_subscribe(topic, query, channel_id): saved_query = RssSearchSubscription(query=query, topic=topic) yield saved_query.put_async() raise ndb.Return( prospective_search.subscribe(RssItem, saved_query.query, saved_query.urlsafe(), topic=topic, lease_duration_sec=0))
def subscribe_user_for_nearby_questions(prospective_user_id): """Create new subscriptions for the provided question and user.""" active_subscriptions = ProspectiveSubscription.get_for(prospective_user_id) sub = active_subscriptions.get() if sub is None: sub = ProspectiveSubscription( prospective_user_id=prospective_user_id ) sub.put() prospective_user = ProspectiveUser.get_by_id(prospective_user_id) # nearby_question = NearbyQuestion.get_by_id(nearby_question_id) # query = 'origin_latitude = {:f} AND origin_longitude = {:f} AND origin_distance_in_km < {:d}'\ # .format(prospective_user.origin_location.lat, prospective_user.origin_location.lon, prospective_user.notification_radius_in_km) query = 'origin_distance_in_km < {:d}'.format(prospective_user.notification_radius_in_km) # "Topics are not defined as a separate step; instead, topics are created as a side effect of the subscribe() call." prospective_search.subscribe( NearbyQuestion, query, str(sub.key.id()), lease_duration_sec=300 )
def subscribe(document_class, query, sub_id, schema=None, topic=None, lease_duration_sec=DEFAULT_LEASE_DURATION_SEC): """Subscribe a query.""" assert schema is None topic = _get_document_topic(document_class, topic) schema = _model_to_entity_schema(document_class) return prospective_search.subscribe(datastore.Entity, query, sub_id, schema=schema, topic=topic, lease_duration_sec=lease_duration_sec)
def subscribe(document_class, query, sub_id, schema=None, topic=None, lease_duration_sec=DEFAULT_LEASE_DURATION_SEC): """Subscribe a query.""" assert schema is None topic = _get_document_topic(document_class, topic) schema = _model_to_entity_schema(document_class) return prospective_search.subscribe( datastore.Entity, query, sub_id, schema=schema, topic=topic, lease_duration_sec=lease_duration_sec)
def get(self, title): user = get_current_user() sub_id = "%s/%s" % (user.email(), title) matcher.subscribe(Ep, "title:"+title, sub_id) return redirect_to("title", title=title)
def sub(jid, board): subid = '%s/%s' % (jid, board) query = 'board:%s thread_flag:new' % (board,) matcher.subscribe(MatchPost, query, subid, topic='post')
def post(self): event = self.request.POST["event"] datapoint = self.request.POST["datapoint"] subscription_id = models.StatsSubscription(event=event, datapoint=datapoint).put() prospective_search.subscribe(stats.StatsRecord, "event:%s" % event, subscription_id) self.response.out.write("Subscribed the datapoint %s to %s events." % (datapoint, event))
def create_query_and_subscribe(topic, query, channel_id): saved_query = RssSearchSubscription(query=query, topic=topic) yield saved_query.put_async() raise ndb.Return(prospective_search.subscribe(RssItem, saved_query.query, saved_query.urlsafe(), topic=topic, lease_duration_sec=0))