コード例 #1
0
ファイル: cloudhandlers.py プロジェクト: StackMonkey/site
	def delete(self, cloud_id = None):
		# lookup user's auth info
		user_info = User.get_by_id(long(self.user_id))
		
		# pull the entry from the db
		cloud = Cloud.get_by_id(long(cloud_id))

		# check the number of instances
		count = Instance.get_count_by_cloud(cloud.key)

		# deny if it has instances
		if count > 0:
			self.add_message('You may not delete a cloud with instances!', 'info')

		# if we found it and own it, delete
		elif cloud and cloud.owner == user_info.key:
			cloud.key.delete()
			self.add_message('Cloud successfully deleted!', 'success')
		else:
			self.add_message('Cloud was not deleted.  Something went horribly wrong somewhere!', 'warning')

		# hangout for a second
		time.sleep(1)

		# use the channel to tell the browser we are done and reload
		channel_token = self.request.get('channel_token')
		channel.send_message(channel_token, 'reload')
		return
コード例 #2
0
ファイル: broadcast.py プロジェクト: ebby/brokentv
def broadcastTwitterAuth(user):
  response = {}
  response['type'] = 'twitter_auth'
  response['success'] = True
  channels = memcache.get('web_channels') or {}
  if user.id in channels.iterkeys():
    webchannel.send_message(user.id, simplejson.dumps(response))
コード例 #3
0
ファイル: broadcast.py プロジェクト: battlehorse/rhizosphere
    def post(self):
        channel_uuid, channel_payload = self.restore_channel()
        if not channel_uuid:
            return

        if channel_payload["channel_state"] != "established":
            logging.error("Publishing on an unestablished channel: %s" % channel_uuid)
            self.respond_error("channel is not established yet")
            return

        received_state = simplejson.loads(self.request.get("payload"))
        channel_payload["viz_state"] = received_state

        if not self.save_channel_payload(channel_uuid, channel_payload):
            return

        # The list of listeners may contain stale entries, if a listener forgot
        # to unregister itself.
        for listener_uuid in channel_payload["listeners"].iterkeys():
            try:
                channel.send_message(listener_uuid, simplejson.dumps(received_state))
            except channel.Error:
                logging.error("Error while sendinng message from %s to %s" % (channel_uuid, listener_uuid))

        self.respond_ok()
コード例 #4
0
def aChan():
    token = channel.create_channel(xID,1440)
    msg = Msg()
    msg.info = 'ho'
    tomsg = json.dumps(msg.__dict__)
    channel.send_message(xID, tomsg)
    return token
コード例 #5
0
    def post(self):
        #retrieve parameters
        new_message = self.request.get('new_message')
        author = self.request.get('author')
        sid = int(self.request.get('sid'))

        # store message
        im_message = IMMessage()
        im_message.im_session_id = sid
        im_message.message = new_message
        im_message.author = author
        im_message.message_id = str(uuid.uuid4())

        im_message.put()

        # update last_activity of sender to prevent automatic logout
        current_user = db.GqlQuery("select * from IMUser where nickname=:1", author)[0]
        current_user.last_activity = datetime.datetime.now()
        current_user.put()

        # get recipient list
        im_sessions = db.GqlQuery("select * from IMSession where im_session_id=:1", sid)[0]
        chatters = im_sessions.users

        # send message to all recipients
        for chatter in chatters:
            imuser = db.GqlQuery("select * from IMUser where nickname=:1", chatter)[0]
            logging.info(__file__ + " " + chatter)
            channel.send_message(imuser.channel_id, simplejson.dumps({
                "message": new_message,
                "author": author,
                "timestamp": datetime.datetime.now().strftime("%A, %B %d, %Y %H:%M:%S"),
            }))
コード例 #6
0
ファイル: cam.py プロジェクト: lithium112/Empathica
def remove_node(map_id, node_id):
    """
    TODO
    """
    map_id = db.Node[node_id].id_map
    if(auth.has_permission('update', db.Map, map_id)):
        db(db.Connection.id_first_node == node_id).delete()
        db(db.Connection.id_second_node == node_id).delete()
        del db.Node[node_id]
        updated_map_info = dict(date_modified = datetime.utcnow(), modified_by = auth.user.email)
        if db(db.Node.id_map == map_id).count() > 0:
            updated_map_info['is_empty'] = False
        else:
            updated_map_info['is_empty'] = True
        db.Map[map_id] = updated_map_info
        if settings.web2py_runtime_gae:
            maplisteners = memcache.get('map_%s_listeners' % map_id)
            if maplisteners is not None:
                message = { 'type': 'noderemove',
                            'nodeid': node_id }
                for to_id in maplisteners:
                    channel.send_message(to_id, gluon.contrib.simplejson.dumps(message))

        return dict(success=True)
    else:
        return dict(success=False)
コード例 #7
0
ファイル: drawing.py プロジェクト: bluehatsJP/my-google-app
	def post(self):
		# request取得を連想配列で取得
		req_data = simplejson.loads(self.request.body)

		# Channelで他のユーザに通知
		#channel.send_message('draw',simplejson.dumps(req_data))
		channel.send_message(req_data["bname"],self.request.body)
コード例 #8
0
ファイル: chat.py プロジェクト: danvk/lmnopuz
  def post(self):
    user = users.get_current_user()
    if not user:
      self.response.set_status(401)
      return

    text = self.request.get("text")
    line = ChatLine(user=user, text=text)
    db.put(line)

    # Send an update to everyone who's listening.
    # TODO(danvk): write a function to do this.
    msg = { 'lines': [ "%s: %s" % (user.nickname(), text) ] }
    active_users=db.GqlQuery("SELECT * FROM ActiveUsers")
    for user in active_users:
      if (datetime.datetime.now() - user.last_update_time
          > datetime.timedelta(hours=1)):
        logging.info("Removing inactive user: "******"Sending message on channel: " + user.user.user_id())
        try:
          channel.send_message(user.user.user_id(), simplejson.dumps(msg))
        except channel.InvalidChannelKeyError:
          # This happens when you restart the server and sever connections.
          pass

    self.response.out.write('ok')
コード例 #9
0
ファイル: cam.py プロジェクト: lithium112/Empathica
def add_node(map_id, token, x, y, width, height, name):
    '''
    By default set valences to 0 for new nodes
    '''
    if(auth.has_permission('update', db.Map, map_id)):
        map = db.Map(map_id)
        node_id = db.Node.insert(id_map=map_id, valence = 0, x = x, y = y, width = width, height = height, name = name)
        db.Map[map_id] = dict(date_modified = datetime.utcnow(), modified_by = auth.user.email, is_empty = False)

        if settings.web2py_runtime_gae:
            maplisteners = memcache.get('map_%s_listeners' % map_id)
            if maplisteners is not None:
                node = {    'id': node_id, 
                            'text': name, 
                            'valence': 0, 
                            'dim': 
                                { 
                                    'x': float(x), 
                                    'y': float(y), 
                                    'width' : float(width), 
                                    'height' : float(height),
                                }, 
                            'selected': False, 
                            'newNode': False,
                        }
                message = { 'type': 'nodeadd',
                            'node': node }
                for to_id in maplisteners:
                    channel.send_message(to_id, gluon.contrib.simplejson.dumps(message))

        return dict(success=True, token=token, node_id=node_id)
    else:
        return dict(success=False, token=token)
コード例 #10
0
ファイル: event.py プロジェクト: steveymk/advanceddev
    def post(self):

        message = Message()

        eventkey = self.request.get("eventkey")
        message_content = self.request.get("message")
        user = users.get_current_user()
        if not user:
            user = "******"
        time = datetime.datetime.now()

        # preformatting for ease of posting
        message.content = (
            "<span>" + str(user) + ":" + self.request.get("message") + " - " + time.strftime("%H:%M") + "</span>"
        )
        message.event = eventkey
        message.put()

        # pushing through channel
        clientquery = ChatUser.query(ChatUser.event == eventkey)
        clients = clientquery.fetch()
        for client in clients:
            channel.send_message(
                client.uuid,
                "<span>" + str(user) + ":" + self.request.get("message") + " - " + time.strftime("%H:%M") + "</span>",
            )
コード例 #11
0
def game_newPlayer(gameId):
    """
    POST action of the Choose nickname form (presented when a user joins a game, if it's not full already)
    """

    if gameId not in GameInProgress.games:
        return redirect(url_for("index"))

    # fetch game informations
    game = GameInProgress.games[gameId]
    user = game.getCurrentUser()

    if not user or user.playerId is not None:
        return Response(status=400)

    # add the player to the game model
    playerId = game.model.addPlayer(request.form["name"])

    if playerId is False:
        # the game is full, return an error
        return Response(status=400)

    # store the player ID in the user object
    user.playerId = playerId

    # refresh the game for everyone else to show the new player
    for u in game.users.values():
        if u.channelId and u is not user:
            channel.send_message(u.channelId, "reload")

    return redirect(url_for("gameview", gameId=gameId))
コード例 #12
0
    def sendMessageTo(user, call, data):
        msg = {
            "call" : call,
            "data" : data
        }

        channel.send_message(user.uid, json.dumps(msg))
コード例 #13
0
ファイル: main.py プロジェクト: Hammer2900/channel-api-test
    def post(self):
        channel_id = self.request.get('channel_id');
        clientSeq = self.request.get('clientSeq');
        timestamp = self.request.get('timestamp');
        msg = self.request.get('msg');
        logging.info('Received MESSAGE [%s %s]' % (channel_id, clientSeq))
        sequence = memcache.incr("sequence", initial_value=0)
        if sequence is None:
            sequence = 0
        scene_k = ndb.Key('Scene', 'scene1')
        scene = scene_k.get()
        # echo message back to all users
        message = json.dumps({
                    'type' : 'echo',
                    'sequence' : sequence,
                    'timestamp' : timestamp,
                    'clientSeq' : int(clientSeq),
                    'channel_id' : channel_id,
                    'msg' : msg,
                    'server_time' : int(time.time() * 1000)
                });
        tStart = datetime.now()
        channel.send_message(channel_id, message)
        tTotal = datetime.now() - tStart
        logging.info('   responded to sender [%s] (%dms)' % (channel_id, tTotal.microseconds/1000))

        if len(scene.connections)>1:
            logging.info('   broadcasting to %i clients' % (len(scene.connections)-1))
            for c in scene.connections:
                if c.channel_id != channel_id:
                    tStart = datetime.now()
                    channel.send_message(c.channel_id, message)
                    tTotal = datetime.now() - tStart
                    logging.info('     broadcast to [%s] (%dms)' % (c.channel_id, tTotal.microseconds/1000))
コード例 #14
0
ファイル: main.py プロジェクト: SimonThordal/udacityplus
 def post(self):
     # Client MUST ENFORCE correct syntax for commands, and ensure usernames and channelnames exist
     # Perhaps that's a dangerous statement?
     message = urllib.unquote(self.request.get('message'))
     username = urllib.unquote(self.request.get('username'))
     identifier = urllib.unquote(self.request.get('identifier'))
     logging.info("Username: "******" Message: "+message)
     if not (message and username and identifier): 
         return
     user = get_user(username)
     if not user or (user and identifier != user.identifier):
         return
     COMMANDS = {"JOIN": user_join,
                 "LEAVE": user_leave,
                 "PRIVMSG": user_privmsg,
                 "CHANNELMSG": user_channelmsg,
                 "QUIT": user_quit,
                 "PING": user_ping,
                 "PONG": user_pong
                 }
     command = message.split(' ')[0].upper()
     arg = '' if ' ' not in message else message[message.index(' ')+1:]
     if command in COMMANDS:
         COMMANDS[command](username, arg)
     else:
         channel_api.send_message(username, "NOTICE Command not supported by server: "+message) # Echo, for testing
コード例 #15
0
ファイル: main.py プロジェクト: SimonThordal/udacityplus
def user_quit(username, args):
    '''User has quit'''
    # This may take a while to execute
    user = get_user(username)
    username = user.username # Use actual name
    user.connected = False
    for channelname in user.get_channel_names():
        # Remove the user from channel
        channel = get_channel(channelname)
        channel.remove_user(username) # Do this first to prevent infinite loops
        for u in channel.get_user_names():
            # Let the people in the channel know
            channel_api.send_message(u, "QUIT "+username+" "+channelname)
    for contactname in user.get_contact_names():
        # Remove user from their contacts' contact lists
        # Possible double-handling, but that's ok because remove_contact checks for that
        contact = get_user(contactname)
        if contact:
            contact.remove_contact(username)
    try:
        channel_api.send_message(username, "NOTICE You have quit")
    except:
        # POKEMON exception!
        # Not really needed since send_message does not throw exceptions
        pass
    user.store()
コード例 #16
0
  def post(self):
    game_name = self.request.get('game_name')
    game_key = db.Key.from_path('Game', game_name)
    game = db.get(game_key)
    user = users.get_current_user()
    logging.info('Player {0} playing move for game: {1}'.format(game, user.nickname()))

    move_type = self.request.get('move_type')
    selected_cards = self.request.get('selected_cards')

    players = Player.all().ancestor(game).run()
    for player in players:
      if player.user == user:
        this_player = player

    if not this_player:
      raise Exception("Player not found: {0}".format(user.nickname()))

    gamestate = {
      "players": players,
      "current_hand": this_player.cards,
      "player_turn": game.player_turn
    }

    for player in players:
      channel.send_message("{0}:{1}".format(game_name, player.user.user_id()),
        json.dumps(gamestate))
コード例 #17
0
ファイル: status.py プロジェクト: virtualjoker/jankenpony
 def alone_match(self):
   self.balance += 1
   self.match_counter += 1
   self.challenger = None
   
   free_win = {}
   
   free_win['player'] = {
     'id':self.player.id,
     'nickname': self.player.nickname,
     'status': self.id,
     'shots': self.shots,
     'balance': self.balance,
     'match_counter': self.match_counter,
   }
   
   free_win['game'] = {
     'id': self.game.id,
     'name': self.game.name,
     'slug': self.game.slug,
     'players_counter': self.game.players_counter,
     'online_players': self.game.online_players,
     'match_counter': self.game.match_counter,
     'match_round': self.game.match_round,
     'datetime': self.game.last_match.strftime("%d/%m/%y %I:%M:%S %p"),
   }
   
   message = {'free_win': free_win}
   send_message(self.player.id, json.dumps(message))
   # When player do not play, it increments its match counter?
   # match_counter += 1
   self.put()
コード例 #18
0
 def send_update(self):
     message = self.get_game_message()
     channel.send_message(
         self.game.userX.user_id() + self.game.key().id_or_name(), message)
     if self.game.userO:
         channel.send_message(self.game.userO.user_id() +
                              self.game.key().id_or_name(), message)
コード例 #19
0
  def get(self):
    req =self.request.get('id')
    if(req != ''):

      qry = chatRoom.query(chatRoom.roomID == req)

      if(qry):
        clientID = randomString(5)
        token = channel.create_channel(clientID)
        msg = clientID + " has joined the chat"

        res = qry.get()
        res.participants.append(clientID)
        res.participantTokens.append(token)
        res.histChat+="\n"+msg
        for participantToken in res.participantTokens:
          channel.send_message(participantToken, msg)
        template_values = {'token': token,
                      'appid': clientID,
                      'message': res.histChat,
                      'roomID': req}
        res.put()

        path = os.path.join(os.path.dirname(__file__), 'mychat.html')
        self.response.out.write(template.render(path, template_values))
コード例 #20
0
    def post(self):
      #get the client_key from client
      client_key = self.request.get('client_key')

      if not client_key:
        client_key = users.get_current_user().email()

      #save Channel
      new_key = ChannelKey(ch_key=str(client_key))
      new_key.put()

      #retrieve 7 days of messages from datastore
      date1 = datetime.datetime.now() - datetime.timedelta(days=7)
      m_history = MessageNDB.query(MessageNDB.date > date1)
      m_history2 = m_history.order(MessageNDB.date)
      result = m_history2.fetch(1000)

      #send data to client
      #Store log messages in one string
      marray = "&log"
      for m in result:
        marray = marray+"&"+str(m.message)

      #send via the channel
      channel.send_message(str(client_key), marray)
コード例 #21
0
ファイル: notifier.py プロジェクト: Yonnick/userinfuser
def user_points(user_ref, points, title, acc):
  if not user_ref or not acc:
    return None
  try:
    image = acc.pointsImage
  except:
    acc.pointsImage = constants.IMAGE_PARAMS.POINTS_IMAGE
    accounts_dao.save(acc)
  diction = {'event':'notify_points',
             'user':user_ref.userid,
             'account':acc.key().name(),
             'points':points,
             'widget':'notifier',
             'is_api':'no',
             'details':"title: "+title,
             'success':'true'}
              
  message = {'note':"+" + str(points) + " Points", 'image': image, 'title': title}
  message = json.dumps(message)
  try:
    channel.send_message(user_ref.key().name(), message)
    logs.create(diction)  
  except channel.InvalidChannelClientIdError:
    diction['success'] = "false"
    logging.error("Bad Channel ID for acc %s and user %s"%(acc.key().name(), user_ref.key().name()))
    logs.create(diction)
    return  
コード例 #22
0
ファイル: objects.py プロジェクト: kabramova/school-tagging
 def sendFeedbackToStudents(self):
     for studentName in self.students:
         student = getStudent(studentName, self.lesson)
         exerciseAnswers = [
             a.content for a in student.answers
             if a.exercise == self.key.id()
         ]
         if exerciseAnswers and exerciseAnswers[0] != "MISSING":
             answer = exerciseAnswers[0]
             message = {
                 "type": "validAnswer",
                 "message": {
                     "validAnswer": self.validatedAnswer,
                     "myAnswer": answer,
                     "dict": getAnswersProposed(self.type)
                 }
             }
         else:
             message = {
                 "type": "exerciseExpired",
                 "message": {
                     "validAnswer": self.validatedAnswer,
                     "dict": getAnswersProposed(self.type)
                 }
             }
         message = json.dumps(message)
         channel.send_message(student.token, message)
コード例 #23
0
ファイル: main.py プロジェクト: oomta/Hawk-Eye
 def post(self):
   ids = ('1', '2')
   key = self.request.get('key')
   is_pressed = self.request.get('pressed')
   time = self.request.get('time')
   id = [id for id in ids if id != self.request.get('id')][0]
   channel.send_message(id, json.dumps({'key': key, 'pressed': is_pressed, 'time': time}))
コード例 #24
0
 def _update_clients(self, canvas, sender_channel_id, segments):
     clients = CanvasClient.query(ancestor=canvas.key)
     segments_msg = json.dumps(segments)
     for client in clients:
         if client.channel_id == sender_channel_id:
             continue
         channel.send_message(client.channel_id, segments_msg)
コード例 #25
0
ファイル: rest.py プロジェクト: guillemborrell/cloudchat
    def post(self):
        data = json.loads(self.request.body)
        user = users.get_current_user()
        client_id = data['id']
        chat = ndb.Key(urlsafe=client_id[:-8]).get()

        if user:
            Activity(
                user = user,
                chat = chat.key).put()
        
        for client in chat.clients:
            channel.send_message(
                client,
                json.dumps(
                    {"clients":len(chat.clients)+1,
                     "name": chat.name,
                     "cursor": False,
                     "message": []
                 }
                )
            )


        last_message_when = Message.query_time_from_chat(chat.key)
        if last_message_when < (
                datetime.datetime.now()-datetime.timedelta(hours=4)):
            logging.info('Reset clients in chat {}'.format(chat.key.urlsafe()))
            chat.reset_clients()
        
        chat.add_client(client_id)
コード例 #26
0
ファイル: main.py プロジェクト: gilisagreen/Project4
 def get(self):
     user = users.get_current_user()
     game_id = self.request.get('game')
     token = ''
     other_player = ''
     user = users.get_current_user()
     #logout_url = users.create_logout_url("/")
     game_hand = ''
     if game_id:
         game = Game.get_by_id(int(game_id))
         if game:
             game_hand = game.hand
             if game.may_join(user):
                 token = create_channel(str(game.key().id()) + user.user_id())
                 other_player = game.player1
                 key = get_other_player_channel_key(game, user.user_id())
                 channel.send_message(key, simplejson.dumps({'type':'join', 'user':get_user_dump(user, format='dict')}))
             else:
                 self.redirect('/netplay')
         else:
             self.redirect('/netplay')
     context = {
         'token': token,
         'game_id': game_id,
         'game_hand': game_hand,
         'other_player': other_player,
         'user':      user,
         'user_id': user.user_id(),
         'login':     users.create_login_url(self.request.uri),
         'logout':    users.create_logout_url(self.request.uri),
     }
     tmpl = path.join(path.dirname(__file__), 'netplay.html')
     self.response.write(render(tmpl, context))
コード例 #27
0
ファイル: channel.py プロジェクト: pulilab/gaelord
def push(record, channel_id=None):
    """Send a log record via channel API.
    
    record -- log record to push
    channel_id

    If channel_id is supplied, the message will only be sent to the
    corresponding channel.
    """

    template_values = {
        'message': cgi.escape(record.message),
        'filename': cgi.escape(record.filename),
        'funcname': cgi.escape(record.funcName),
        'levelname': cgi.escape(record.levelname),
        'lineno': str(record.lineno),
        }

    data = {
        'html' : render_to_string('log_record_li.html',
                                  template_values)
        }

    if channel_id:
        channel.send_message(channel_id, simplejson.dumps(data))
    else:
        [channel.send_message(channel_id, simplejson.dumps(data))
         for channel_id in _get_channels()]
コード例 #28
0
ファイル: main.py プロジェクト: zmyaro/screentxt
	def post(self, setting, val):
		user = users.get_current_user()
		if user:
			if (Settings.gql('WHERE user = :1', user).count() > 0):
				settings = Settings.gql('WHERE user = :1', user).get()
				if not settings.msg:
					settings.msg = ''
				if not settings.font:
					settings.font = 'sans-serif'
				if not settings.disps:
					settings.disps = ''
			else:
				settings = Settings()
				settings.user = user
				settings.msg = ''
				settings.font = 'sans-serif'
				settings.color = 'black'
				settings.disps = ''
				
			setattr(settings, setting, val)#urllib.unquote(val))
			settings.put()
			
			userDisps = settings.disps.split(',') # -------------------------------- get the list of displays
			for disp in userDisps: # ----------------------------------------------- and for each one...
				if disp != '': # --------------------------------------------------- ...assuming it exists
					channel.send_message(user.user_id() + disp, setting[:3] + val) # send the new value prefixed with the first three letters of the setting
			
			self.response.out.write('')
		else:
			self.error(403)
コード例 #29
0
ファイル: mirror_api.py プロジェクト: jefffohl/mirror-api
    def timeline_insert(self, card):
        """Insert a card for the current user."""

        if card.id is not None:
            raise endpoints.BadRequestException("ID is not allowed in request body.")

        if card.menuItems is not None:
            for menuItem in card.menuItems:
                if menuItem.action == MenuAction.CUSTOM:
                    if menuItem.id is None:
                        raise endpoints.BadRequestException("For custom actions id needs to be provided.")
                    if menuItem.values is None or len(menuItem.values) == 0:
                        raise endpoints.BadRequestException("For custom actions at least one value needs to be provided.")
                    for value in menuItem.values:
                        if value.displayName is None or value.iconUrl is None:
                            raise endpoints.BadRequestException("Each value needs to contain displayName and iconUrl.")

        if card.htmlPages is not None and len(card.htmlPages) > 0 and card.bundleId is not None:
            raise endpoints.BadRequestException("Can't mix HTML and Card bundle.")

        card.isDeleted = False

        card.put()

        channel.send_message(card.user.email(), json.dumps({"id": card.id}))

        return card
コード例 #30
0
ファイル: matcher.py プロジェクト: a37912/gaeaib
  def post(self):

    post = matcher.get_document(self.request.form)
    send = post.data

    for sub_id in self.request.form.getlist('id'):
      logging.info("send post to %s" % sub_id)

      if send.get('evt') == 'online' and '@' in sub_id:
        continue

      if '@' in sub_id:
        jid = sub_id.split('/')[0]
        whoami = '%(board)[email protected]' % send
        MSG = """Posted http://42ch.org/%(board)s/%(thread)d/#p%(last)d\n\n%(text)s""" % send
        xmpp.send_message(jid, MSG, from_jid=whoami)
        continue

      try:
        channel.send_message(sub_id, dumps(send))
      except channel.InvalidChannelClientIdError:
        logging.error("inval client id %r" % sub_id)
      except channel.InvalidMessageError:
        logging.error("inval msg: %r" % dumps(send))

    return Response("ok")
コード例 #31
0
ファイル: main.py プロジェクト: amandajliu/Quarto
	def send_update(self):
		message = self.get_game_message()
		channel.send_message(self.game.player1.user_id() + self.game.key().id_or_name(), message)
		if self.game.player2:
			channel.send_message(self.game.player2.user_id() + self.game.key().id_or_name(), message)
コード例 #32
0
ファイル: rest.py プロジェクト: guillemborrell/cloudchat
 def run(self):
     channel.send_message(self.client,self.message)        
コード例 #33
0
ファイル: rest.py プロジェクト: guillemborrell/cloudchat
    def post(self):
        body = json.loads(self.request.body)
        client_id = body['from']
        chat = ndb.Key(urlsafe=client_id[:-8]).get()

        if body['to'] in chat.clients:
            newchat = ChatManager()
            newchat.name = 'Private'
            newchat.active = True
            newchat.private = True
            newchat.owner = users.User("*****@*****.**")
            newchat.save = False
            newchat.options = {"save": False,
                               "conversations": False,
                               "persistent": False}
            newchat_key = newchat.put()

            channel.send_message(
                body['from'],
                json.dumps(
                    {"clients":len(chat.clients),
                     "name": chat.name,
                     "cursor": False,
                     "message": [
                         {"author": 'ADMIN',
                          "id": '0',
                          "when": self.print_time(),
                          "text": 'You have sent a private <a target="_blank" href="/chat?key={}">room</a>'.format(newchat_key.urlsafe())
                      }
                     ]
                 }
                )
            )

            channel.send_message(
                body['to'],
                json.dumps(
                    {"clients":len(chat.clients),
                     "name": chat.name,
                     "cursor": False,
                     "message": [
                         {"author": 'ADMIN',
                          "id": '0',
                          "when": self.print_time(),
                          "text": 'You have been invited to a private <a target="_blank" href="/chat?key={}">room</a> by {}'.format(newchat_key.urlsafe(),body['author'])
                      }
                     ]
                 }
                )
            )


        else:
            channel.send_message(
                body['from'],
                json.dumps(
                    {"clients":len(chat.clients),
                     "name": chat.name,
                     "cursor": False,
                     "message": [{"author": 'ADMIN',
                                  "id": '0',
                                  "when": self.print_time(),
                                  "text": 'This user is no longer connected'
                              }]
                 }
                )
            )
コード例 #34
0
	def call(self, instance, callbacks):
		channel.send_message(instance.channel, jsondumps(callbacks))
コード例 #35
0
 def notifyUser(self, user_id, notification_type, notification):
     try:
         notification['type'] = notification_type
         channel.send_message(user_id, self.asJson(notification))
     except Exception:
         pass
コード例 #36
0
ファイル: mirror_api.py プロジェクト: bwnyasse/mirror-api
    def action_insert(self, action):
        """Perform an action on a timeline card for the current user.

        This isn't part of the actual Mirror API but necessary for the emulator
        to send actions to the subscribed services.

        Returns just a simple success message
        """

        current_user = endpoints.get_current_user()
        if current_user is None:
            raise endpoints.UnauthorizedException("Authentication required.")

        card = ndb.Key("TimelineItem", action.itemId).get()
        if card is None or card.user != current_user:
            raise endpoints.NotFoundException("Card not found.")

        data = None
        operation = None

        if action.action == MenuAction.SHARE:
            operation = Operation.UPDATE
            data = {}
            data["collection"] = "timeline"
            data["itemId"] = action.itemId
            data["operation"] = operation.name
            data["userActions"] = [{"type": MenuAction.SHARE.name}]

        if action.action == MenuAction.REPLY or action.action == MenuAction.REPLY_ALL:
            operation = Operation.INSERT
            data = {}
            data["collection"] = "timeline"
            data["itemId"] = action.itemId
            data["operation"] = operation.name
            data["userActions"] = [{"type": MenuAction.REPLY.name}]

        if action.action == MenuAction.DELETE:
            operation = Operation.DELETE
            data = {}
            data["collection"] = "timeline"
            data["itemId"] = action.itemId
            data["operation"] = operation.name
            data["userActions"] = [{"type": MenuAction.DELETE.name}]

        if action.action == MenuAction.CUSTOM:
            operation = Operation.UPDATE
            data = {}
            data["collection"] = "timeline"
            data["itemId"] = action.itemId
            data["operation"] = operation.name
            data["userActions"] = [{"type": MenuAction.CUSTOM.name, "payload": action.value}]

        if data is not None and operation is not None:
            header = {"Content-type": "application/json"}

            query = Subscription.query().filter(Subscription.user == current_user)
            query = query.filter(Subscription.collection == "timeline")
            query = query.filter(Subscription.operation == operation)
            for subscription in query.fetch():
                data["userToken"] = subscription.userToken
                data["verifyToken"] = subscription.verifyToken

                req = urllib2.Request(subscription.callbackUrl, json.dumps(data), header)
                try:
                    urllib2.urlopen(req)
                except:
                    logging.error(sys.exc_info()[0])

        # Report back to Glass emulator
        channel.send_message(current_user.email(), json.dumps({"id": action.itemId}))

        return ActionResponse(success=True)
コード例 #37
0
ファイル: mirror_api.py プロジェクト: bwnyasse/mirror-api
    def timeline_delete(self, card):
        """Remove an existing card for the current user.

        This will set all properties except the ID to None and set isDeleted to true
        """

        if not card.from_datastore or card.user != endpoints.get_current_user():
            raise endpoints.NotFoundException("Contact not found.")

        if card.isDeleted:
            raise endpoints.NotFoundException("Card has been deleted")

        # Delete attachments
        keys = []
        if card.attachments is not None:
            for att in card.attachments:
                keys.append(blobstore.BlobKey(att.id))
        blobstore.delete_async(keys)

        card.attachments = []
        card.bundleId = None
        card.canonicalUrl = None
        card.created = None
        card.creator = None
        card.displayTime = None
        card.html = None
        card.htmlPages = []
        card.inReplyTo = None
        card.isBundleCover = None
        card.isPinned = None
        card.menuItems = []
        card.notification = None
        card.recipients = []
        card.sourceItemId = None
        card.speakableText = None
        card.text = None
        card.title = None
        card.updated = None
        card.isDeleted = True
        card.put()

        # Notify Glass emulator
        channel.send_message(card.user.email(), json.dumps({"id": card.id}))

        # Notify timeline DELETE subscriptions
        data = {}
        data["collection"] = "timeline"
        data["itemId"] = card.id
        operation = Operation.DELETE
        data["operation"] = operation.name

        header = {"Content-type": "application/json"}

        query = Subscription.query().filter(Subscription.user == endpoints.get_current_user())
        query = query.filter(Subscription.collection == "timeline")
        query = query.filter(Subscription.operation == operation)
        for subscription in query.fetch():
            data["userToken"] = subscription.userToken
            data["verifyToken"] = subscription.verifyToken

            req = urllib2.Request(subscription.callbackUrl, json.dumps(data), header)
            try:
                urllib2.urlopen(req)
            except:
                logging.error(sys.exc_info()[0])

        return card
コード例 #38
0
def log_channel_send(action, orig=None, dest=None):
    msg = {'action': action, 'orig': orig, 'dest': dest}
    channel.send_message(log_channel_client, json.dumps(msg))
コード例 #39
0
def send_saved_messages(client_id):
    messages = get_saved_messages(client_id)
    for message in messages:
        channel.send_message(client_id, message.msg)
        logging.info('Delivered saved message to ' + client_id)
        message.delete()
コード例 #40
0
	def get(self):
		self.sess = session.Session('enginesession')
		if self.sess.load():
			template_values = {}
			users=UserDB()
			user = users.getUserByKey(self.sess.user)
			template_values['user'] = user
			
			#Si el usuario le da al boton de salir, eliminamos su asociacion con la sala
			if self.request.get('e', default_value='0')!='0':
				#Le decimos al resto de jugadores que se ha ido
				game_key = user.idSala
				if game_key:
					sala = SalasDB().getSalaById(game_key)
					if sala:
						user = None
						self.sess = session.Session('enginesession')
						if self.sess.load():
							user = UserDB().getUserByKey(self.sess.user)
						
							users = UserDB()
							user_list = users.getUsersBySala(sala.idSala)
							if UserDB().userExistsInSala(sala.idSala, user.nick):
									messageRaw = {
										"type": "salaExit", 
										"content": {
											"userKey": str(user.key()),
											"userNick": user.nick							
											}
										}				
									message = json.dumps(messageRaw)
									
									for r in user_list:	
										channel.send_message(str(r.key()), message);
				#Eliminamos al usuario de la sala
				user2 = UserDB().getUserByNick(user.nick)
				UsersInGameDB().deleteUserInGame(user2)
				numUsers = UserDB().getUsersBySala(user.idSala)
				res = numUsers.count()
				#Si no queda nadie en la sala la eliminamos ademas del juego
				if res == 1:
					SalasDB().deleteSala(user.idSala)
					GameDB().deleteGame(user.idSala)
				#Asignamos none a la sala del usuario
				user.idSala="None"
				user.put()			
				
				#Redirigimos al inicio
				self.redirect('/')
			
			
			#Comprobamos si la sala existe
			sala = SalasDB().getSalaById(self.request.get('id'))
			if sala:
				#Actualizamos la vista del resto de usuarios
				game_key = sala.idSala
				if game_key:
					sala = SalasDB().getSalaById(game_key)
					if sala:
						user = None
						self.sess = session.Session('enginesession')
						if self.sess.load():
							user = UserDB().getUserByKey(self.sess.user)
						
							users = UserDB()
							user_list = users.getUsersBySala(sala.idSala)
							if not UserDB().userExistsInSala(sala.idSala, user.nick):
									if user.avatar:
										messageRaw = {
											"type": "sala", 
											"content": {
												"userKey": str(user.key()),
												"userNick": user.nick,
												"userAvatar": 1
												}
											}
									else:
										messageRaw = {
											"type": "sala", 
											"content": {
												"userKey": str(user.key()),
												"userNick": user.nick,
												"userAvatar": 0
												}
											}										
									message = json.dumps(messageRaw)
									
									for r in user_list:	
										channel.send_message(str(r.key()), message);
							
				#Si el usuario aun no esta asociado a las sala lo asociamos
				if user and user.idSala=="None" and UsersInGameDB().UserExist(user)==False:
					user.idSala=self.request.get('id')
					user.put()
					idSala = self.request.get('id')
					game = GameDB().getGameBySala(idSala)
					inGame = UsersInGameDB()
					inGame.AddUserInGame(user, game)
				
				#Guardamos la partida en la lista de partidas
				miSala = SalasDB().getSalaById(self.request.get('id'))
				misPuntos = UsersInGameDB().getPuntos(user)
				PartidasJugadasDB().setPartida(user, miSala.nombre, misPuntos, False)
				#Cambiamos el estado del usuario
				UsersInGameDB().changeState(user, "sala")
				#Obtenemos el id del juego asociado a la sala
				game = GameDB().getGameBySala(self.request.get('id'))
				template_values['gamekey']=game.key()
				#Ponemos la puntuacion parcial del usuario a 0
				UsersInGameDB().scoreReset(user)
				#Listamos los usuarios en la sala
				user_list=users.getUsersBySala(self.request.get('id'))
				template_values['user_list']=user_list


				# Si el usuario identificado esta asignado al juego
				token = channel.create_channel(str(user.key()))
				template_values['token'] = token
				template_values['game_key'] = sala.idSala
					
			else:
				self.redirect('/')


			path = os.path.join(os.path.dirname(__file__), 'salajuego.html')
			self.response.out.write(template.render(path, template_values))
		else:
			self.redirect("/salas?p=1")
コード例 #41
0
 def send_update(self):
   message = self.get_game_message()
   channel.send_message(self.game.userX.user_id() + self.game.key().id_or_name(), message)
   if self.game.userO:
     channel.send_message(self.game.userO.user_id() + self.game.key().id_or_name(), message)
コード例 #42
0
    def post(self, session):
	data = {"img": self.request.get("img"), "url": self.request.get("url")}
	logging.info(session)
	logging.info(json.dumps(data))
        channel.send_message(session, json.dumps(data))
コード例 #43
0
 def announce_call(cls, call):
     msg = call.to_operator_json()
     operators = cls.query(cls.is_on_call == True).fetch()
     for operator in operators:
         channel.send_message(operator.on_call_channel_token, msg)
コード例 #44
0
 def get(self):
     channels = json.loads(memcache.get('channels') or '{}')
     for channel_id in channels.iterkeys():
         channel.send_message(channel_id, json.dumps({'function':
                                                      'reload'}))
コード例 #45
0
ファイル: main.py プロジェクト: jeremi/log2bq
def message(root_pipeline_id, template, *args, **kwargs):
    message = jinja2.Template(template).render(
        root_pipeline_id=root_pipeline_id, **kwargs)
    logging.debug(message)
    client_id = memcache.get('client_id')
    channel.send_message(client_id, "%s,%s" % (root_pipeline_id, message))
コード例 #46
0
 def refresh_calls(self, last_call_datetime):
     for c in ChatCall.calls_since(last_call_datetime):
         msg = c.to_operator_json(is_historic=True)
         channel.send_message(self.on_call_channel_token, msg)
コード例 #47
0
 def send_start(self):
   message = "start"
   channel.send_message(self.game.user1 + self.game.key.id(), message)
   if self.game.user2:
     channel.send_message(self.game.user2 + self.game.key.id(), message)
コード例 #48
0
ファイル: main.py プロジェクト: peachpie/upluschat
def user_ping(username, args):
    user = get_user(username)
    username = user.username  # Use actual name
    channel_api.send_message(username, "PONG " + args)
コード例 #49
0
    def get(self):
        if (self.request.get('get') == 'livecode'):
            # token = channel.create_channel('crowdbot')
            # print out a mini-page about the current program, which refreshes every few minutes by default or by Channel API
            livesketch = CrowdBotProgram().gql(
                "WHERE hasRun = 'True' ORDER BY uploaded DESC").get()
            sketchtitle = ""
            if (livesketch is not None):
                sketchtitle = cgi.escape(livesketch.programname)
            self.response.out.write('''<!DOCTYPE html>
<html>
	<head>
		<meta http-equiv="refresh" content="60"/>
		<title>Current CrowdBot Program</title>
		<script type="text/javascript" src="/shCore.js"></script>
		<script type="text/javascript" src="/shBrushCpp.js"></script>
		<link rel='stylesheet' type='text/css' href='/shCore.css'/>
		<link rel='stylesheet' type='text/css' href='/shThemeDefault.css'/>
	</head>
	<body>
		<span id="codetitle" style="font-family:courier;">''' + sketchtitle +
                                    '''</span>
		<input type="button" value="Refresh" onclick="window.location.reload()"/>
		<hr/>
		<pre class="brush: cpp">\n''')
            # find the last sketch to be downloaded to the board - print program name and source code
            if (livesketch is not None):
                #self.response.out.write(cgi.escape(livesketch.programname) + '<hr/>')
                #self.response.out.write(cgi.escape(livesketch.programtext.replace('\n','<br/>')).replace('&lt;br/&gt;','<br/>').replace(' ','&nbsp;'))
                self.response.out.write(cgi.escape(livesketch.programtext))
            else:
                self.response.out.write('No program loaded\n')
            self.response.out.write('''		</pre>
		<script type="text/javascript">
			SyntaxHighlighter.all()
		</script>
	</body>
</html>''')
        elif (self.request.get('get') == 'livedata'):
            # display any data relayed by the CrowdBot host
            try:
                token = channel.create_channel('crowdbot_data')
                self.response.out.write('''<!DOCTYPE html>
<html>
	<head>
		<title>CrowdBot Data Stream</title>
		<script type="text/javascript" src="/_ah/channel/jsapi"></script>
		<script type="text/javascript">
function init(){
	channel = new goog.appengine.Channel("''' + token + '''");
	socket = channel.open();
	socket.onmessage = function(msg){
		if(msg.data == "CLEAR-DATA"){
			while($("datadiv").childNodes.length >= 1){
				$("datadiv").removeChild($("datadiv").firstChild);       
			}
			var dataline = document.createElement('p');
			dataline.innerHTML = "Awaiting data...";
			$("datadiv").appendChild(dataline);
		}
		else{
			var dataline = document.createElement('p');
			dataline.innerHTML = msg.data;
			$("datadiv").appendChild(dataline);
			window.scrollBy(0,50);
		}
	};
}
function $(id){
	return document.getElementById(id);
}
		</script>
		<style type="text/css">
html, body{
	font-family: courier;
}
		</style>
	</head>
	<body onload="init()">
		<div id="datadiv">
			<p>Awaiting data...</p>
		</div>
	</body>
</html>''')
            except:
                # over channel connection limit (100 connections in 24 hours)
                # show feed of last program to send data
                lastread = CrowdBotProgram().gql(
                    "WHERE hasRun = 'Complete' ORDER BY uploaded DESC")
                found = 0
                for program in lastread:
                    if (program.feed is not None):
                        if (len(str(program.feed)) > 3):
                            found = 1
                            self.redirect('/crowdbot/out?get=feed&id=' +
                                          str(program.key().id()))
                            break
                if (found == 0):
                    self.response.out.write(
                        'Over channel limit and no archived data')

        elif (self.request.get('get') == 'current'):
            # send the current program to the function given by jsonp
            self.response.out.write(
                cgi.escape(self.request.get('jsonp')) + '("')
            livesketch = CrowdBotProgram().gql(
                "WHERE hasRun = 'True' ORDER BY uploaded DESC").get()
            if (livesketch is not None):
                self.response.out.write(
                    livesketch.programtext.replace('"', '\\"').replace(
                        '\r', '|~|').replace('\n', '|~|'))
            self.response.out.write('")')
        elif (self.request.get('get') == 'feed'):
            sketch = CrowdBotProgram.get_by_id(long(self.request.get('id')))
            self.response.out.write(
                cgi.escape(sketch.feed.replace('\n', '<br/>')).replace(
                    '&lt;br/&gt;', '<br/>').replace(' ', '&nbsp;'))
        else:
            # output the earliest-submitted pending sketch ( will be updated to include more information about user, sketch name )
            sketch = CrowdBotProgram().gql(
                "WHERE hasRun = 'False' ORDER BY uploaded ASC").get()
            livesketch = CrowdBotProgram().gql(
                "WHERE hasRun = 'True' ORDER BY uploaded DESC").get()
            if (sketch is not None):
                # write metadata about sketch
                self.response.out.write(str(sketch.key().id()) + "|")
                self.response.out.write(
                    sketch.username.replace('|', '-') + "|")
                if (sketch.dosend == 'on'):
                    self.response.out.write("TRUE|")
                else:
                    self.response.out.write("FALSE|")
                if (sketch.dostream == 'on'):
                    self.response.out.write("TRUE|")
                else:
                    self.response.out.write("FALSE|")
                # write sketch
                self.response.out.write(sketch.programtext)

                # move pending sketch to live
                sketch.hasRun = 'True'
                sketch.put()
                if (livesketch is not None):
                    # move live sketch to 'Complete'
                    livesketch.hasRun = 'Complete'
                    livesketch.put()

                # use Channel API to update live code and data views
                #channel.send_message('crowdbot', cgi.escape(sketch.programname) + '<hr/>' + cgi.escape(sketch.programtext))
                channel.send_message('crowdbot_data', 'CLEAR-DATA')

                # send Tweets to authors of latest and next sketch, if Twitter was provided
                # based on Anil Shanbhag's Twitter Bot: http://anilattech.wordpress.com/2011/10/29/making-a-twitter-bot-using-appengine/
                if (sketch.username.find('@') == 0):

                    starting_format = "%s: your sketch '%s' will run on #CrowdBot for the next 2+ minutes"

                    # oauth client released by Mike Knapp (see twitteroauth.py for more information)
                    client = twitteroauth.TwitterClient(
                        crowdbotconfig.consumer_key,
                        crowdbotconfig.consumer_secret,
                        crowdbotconfig.callback_url)

                    additional_params = {
                        "status":
                        starting_format %
                        (sketch.username, sketch.programname.replace(
                            '@', '').replace('#', '').replace('/', ''))
                    }
                    result = client.make_request(
                        "http://twitter.com/statuses/update.json",
                        token=crowdbotconfig.access_token,
                        secret=crowdbotconfig.access_token_secret,
                        additional_params=additional_params,
                        method=POST)
                    logging.info(result.content)
            else:
                # there are no pending programs
                self.response.out.write('no new program')
コード例 #50
0
ファイル: __init__.py プロジェクト: zhongzhang/tailbone
 def send(event):
     for l in event.listeners:
         channel.send_message(str(l), msg)
     return event.listeners
コード例 #51
0
ファイル: main.py プロジェクト: minichate/ChrisAmyWeddingVote
    def get(self):
        increment()

        channels = get_registered_channels()
        for channel_id in channels.iterkeys():
            channel.send_message(channel_id, str(get_count()))
コード例 #52
0
ファイル: main.py プロジェクト: DebrahR/FinalProject
def sendmessage(user, roomid):
    """sends a message that is useless"""
    message = request.form['message']
    channel.send_message(user + roomid, message)
コード例 #53
0
ファイル: channel.py プロジェクト: dillongrove/TheHackers
def broadcast(msg, key):
    channel.send_message(key, msg)
コード例 #54
0
    def post(self):
        if (self.request.get('livedata') != ''):
            # update live data
            channel.send_message('crowdbot_data',
                                 cgi.escape(self.request.get('livedata')))
        elif (self.request.get('mail') != ''):
            # send saved data
            logging.info(self.request.get('mail'))
            sketch = CrowdBotProgram.get_by_id(long(self.request.get('id')))
            sketch.feed = db.Text(self.request.get('data'))
            sketch.put()

            if (self.request.get('mail').find('@') == 0):
                # Twitter name
                if (self.request.get('data').replace('\n', '').replace(
                        ' ', '').replace('	', '') == ''):
                    # no data recorded
                    finished_format = "%s: #CrowdBot ran your sketch, '%s'. No data was returned."
                else:
                    # send data record
                    finished_format = "%s: #CrowdBot ran your sketch, '%s'. Data stored at http://mapmeld.com/crowdbot/out?get=feed&id=" + self.request.get(
                        'id')

                # oauth client released by Mike Knapp (see twitteroauth.py for more information)
                client = twitteroauth.TwitterClient(
                    crowdbotconfig.consumer_key,
                    crowdbotconfig.consumer_secret,
                    crowdbotconfig.callback_url)
                additional_params = {
                    "status":
                    finished_format % (sketch.username.replace(
                        ' ', ''), sketch.programname.replace('@', '').replace(
                            '#', '').replace('/', ''))
                }
                result = client.make_request(
                    "http://twitter.com/statuses/update.json",
                    token=crowdbotconfig.access_token,
                    secret=crowdbotconfig.access_token_secret,
                    additional_params=additional_params,
                    method=POST)
                #logging.info(result.content)
            elif (self.request.get('mail').find('@') > -1):
                # e-mail
                if (self.request.get('data').replace('\n', '').replace(
                        ' ', '').replace('	', '') == ''):
                    # no data recorded
                    finished_text = "CrowdBot ran your sketch, '" + cgi.escape(
                        sketch.programname).replace('@', '').replace(
                            '#', '').replace('/', '') + """'.

No data was returned by your sketch. Use the Serial functions to report data from CrowdBot's Arduino."""
                else:
                    # send data record
                    finished_text = "CrowdBot ran your sketch, '" + cgi.escape(
                        sketch.programname).replace('@', '').replace(
                            '#', '').replace('/', '') + """'.

Data returned by your sketch is stored at http://mapmeld.com/crowdbot/out?get=feed&id=""" + self.request.get(
                                'id')
                mail.send_mail(sender=crowdbotconfig.mail,
                               to=self.request.get('mail'),
                               subject="CrowdBot ran your sketch",
                               body=finished_text)

        else:
            # accept a new sketch from the form
            sketch = CrowdBotProgram()
            sketch.programname = self.request.get('sketchname')
            sketch.username = self.request.get('identify')
            sketch.programtext = db.Text(self.request.get('mysketch'))
            sketch.dostream = self.request.get('dostream')
            sketch.dosend = self.request.get('dosend')
            sketch.hasRun = 'False'
            sketch.put()
            # live data stream visible if user's program includes data streaming
            if ((self.request.get('dostream') == 'on') and
                (self.request.get('mysketch').find('Serial.begin') > -1)):
                self.redirect('/crowdbot?screen=watch&data=show')
            else:
                self.redirect('/crowdbot?screen=watch')
コード例 #55
0
def sendmessage(user, gameid):
    """sends a message that is useless"""
    message = request.form['message']
    channel.send_message(user + gameid, message)
    return "message sent"
コード例 #56
0
 def post(self):
   remote_id = self.request.get('remoteClientId')
   data = self.request.body
   channel.send_message(remote_id, data)
コード例 #57
0
ファイル: crossie_app.py プロジェクト: jagatsastry/crossie
    def post(self):
        self.response.headers['Content-Type'] = 'application/json'

        user = users.get_current_user()
        crossienum = self.request.get('crossienum')
        if crossienum is None or len(crossienum) == 0:
            # Cannot proceed
            self.response.out.write(
                simplejson.dumps({'error': 'Crossienum should specified.'}))
            return

        crossienum = int(crossienum)
        crossiedata = None
        q = UserCrossie.all()
        q.filter('user', user)
        q.filter('crossienum', crossienum)
        usercrossie = q.get()

        if usercrossie is None:
            # FIXME: No transaction model used here.
            crossiedata = CrossieData(crossienum=crossienum, acl=[user])
            crossiedata.put()
            usercrossie = UserCrossie(crossienum=crossienum,
                                      user=user,
                                      crossiedata=crossiedata)
            usercrossie.put()

        crossieid = usercrossie.crossiedata.key().id()

        updates = self.request.get('updates')
        if updates is None or len(updates) == 0:
            updates = []
        else:
            updates = simplejson.loads(updates)

        try:
            crossiedata = db.run_in_transaction(
                CrossieData.getAndUpdateCrossie, crossieid, user, updates)
        except NoSuchCrossieException:
            self.response.out.write(
                simplejson.dumps({'error': 'Crossie data not found.'}))
            return
        except PermissionDeniedException:
            self.response.out.write(
                simplejson.dumps({'error': 'Permission denied.'}))
            return
        except db.TransactionFailedError:
            self.response.out.write(
                simplejson.dumps({'error': 'DB error. Try again.'}))

        if crossiedata is not None:
            self.response.out.write(crossiedata.getJSON())
            for usr in crossiedata.acl:
                if usr != user:
                    try:
                        channel.send_message(
                            usr.email().lower(),
                            simplejson.dumps({
                                'crossieupdate': {
                                    'updates': updates,
                                    'crossienum': crossienum
                                }
                            }))
                    except:
                        # Does not matter if all collabs don't get the message
                        pass
コード例 #58
0
def send_message(stream, data):
    try:
        # logging.info('send_message %r %r'%(stream.clientId, data))
        channel.send_message(stream.clientId, data)
    except channel.InvalidChannelClientIdError:
        pass
コード例 #59
0
ファイル: crossie_app.py プロジェクト: jagatsastry/crossie
    def post(self):
        self.response.headers['Content-Type'] = 'application/json'

        user = users.get_current_user()
        crossienum = self.request.get('crossienum')
        if crossienum is None or len(crossienum) == 0:
            # Cannot proceed
            self.response.out.write(
                simplejson.dumps({'error': 'Crossienum should specified.'}))
            return

        sharee = self.request.get('sharedWith')
        if sharee is None or len(sharee) == 0:
            # Cannot proceed
            self.response.out.write(
                simplejson.dumps({'error': 'SharedWith should specified.'}))
            return

        crossienum = int(crossienum)
        q = UserCrossie.all()
        q.filter('user', user)
        q.filter('crossienum', crossienum)
        usercrossie = q.get()

        if usercrossie is None:
            # Cannot proceed
            self.response.out.write(
                simplejson.dumps({'error': 'This crossie does not exist.'}))
            return

        sharee = sharee.lower()
        # Check if already shared with this user.
        q = ShareCrossie.all()
        q.filter('sharer', user)
        q.filter('sharee', sharee)
        q.filter('crossienum', crossienum)
        previousshares = q.get()
        if previousshares is not None:
            # Cannot proceed
            self.response.out.write(
                simplejson.dumps({'error': 'Pending invite exists.'}))
            return

        for usr in usercrossie.crossiedata.acl:
            if usr.email().lower() == sharee:
                # Cannot proceed
                self.response.out.write(
                    simplejson.dumps({'error': 'User already in ACL list.'}))
                return

        sharecrossie = ShareCrossie(sharer=user,
                                    sharee=sharee,
                                    crossienum=crossienum)
        sharecrossie.put()
        try:
            channel.send_message(
                sharee,
                simplejson.dumps({
                    'sharedcrossie': {
                        'shareId': sharecrossie.key().id(),
                        'sharer': user.email(),
                        'crossienum': crossienum
                    }
                }))
        except:
            # Does not matter if sharee gets the message right away.
            pass
        self.response.out.write(
            simplejson.dumps({'shareId': sharecrossie.key().id()}))
コード例 #60
0
	def post(self):
	
		obj = json.loads(self.request.body)
		if(obj["msgType"] == "chat"):
			#do chat fanout
			room = Room.get_by_id(obj["destination"])
			jmsg = { 
				'msgType':'chat',
				'destination':obj["destination"],
				'user':obj["userdisplayname"],
				'msg': obj["content"],
				'timestamp': int(time.mktime(datetime.datetime.utcnow().timetuple())) * 1000
				}
			for puser in room.users:
				channel.send_message(puser.userID+puser.channelID+'0',json.dumps(jmsg))
			#add to logs here
			room.messages.append(Message(author=obj["userdisplayname"],content=obj["content"]))
			room.put()
			pass
		elif (obj["msgType"] == "joinRoom"):
			#create and/or join room
			#get list of rooms
			room=Room.get_by_id(obj["destination"])
			if(room and obj["userid"]):
				#room exists
				#get existing users
				presentUsers = list(room.users)
				#add the current user to the room
				room.users.append(User(
					displayName = obj["userdisplayname"],
					userID=obj["userid"],
					channelID=obj["channelguid"]
					))
				rpop = len(room.users)
				#send a joined message to all the other users
				jmsg = { 
				'msgType':'joinedRoom',
				'destination':obj["destination"],
				'username':obj["userdisplayname"],
				'population': str(rpop)
				}
				for puser in presentUsers:
					channel.send_message(puser.userID+puser.channelID+'0',json.dumps(jmsg))
				
				#send last 5 messages in the room to the new user
				todisplay =5
				if len(room.messages) < 5:
					todisplay=len(room.messages)

				for msg in room.messages[(0-todisplay):]:
					jmsg = { 
					'msgType':'chat',
					'destination':room.name,
					'user':msg.author,
					'msg': msg.content,
					'timestamp':  int(time.mktime(msg.timestamp.timetuple())) * 1000
					}
					channel.send_message(obj["userid"]+obj["channelguid"]+'0',json.dumps(jmsg))

				#send a successful join response to the original user
				jmsg2 = {
				'msgType':'joinRoom',
				'destination':obj["destination"],
				'username':obj["userdisplayname"],
				'population': str(rpop)
				}
				channel.send_message(obj["userid"]+obj["channelguid"]+'0',json.dumps(jmsg2))
				obj["population"] = rpop
				room.put()
			else:
				#room doesn't exist - let's create it with one member
				room = Room(id=obj["destination"],
					name=obj["destination"],
					users=[User(
					displayName = obj["userdisplayname"],
					userID = obj["userid"],
					channelID=obj["channelguid"]
					)],
					messages=[])
				rpop = len(room.users)
				jmsg2 = {
				'msgType':'joinRoom',
				'destination':obj["destination"],
				'username':obj["userdisplayname"],
				'population': str(rpop)
				}
				channel.send_message(obj["userid"]+obj["channelguid"]+'0',json.dumps(jmsg2))
				obj["population"] =str(rpop)
				room.put()
			pass
		elif (obj("msgType") == "leaveRoom"):
			#leave room
			pass




		return self.response.out.write(json.dumps(obj))