コード例 #1
0
ファイル: utils.py プロジェクト: fractastical/mr-ray-open
def construct_wavelet_json_for_http_response(wavelet_data, wave_id, wavelet_id, email, b64Encode=False):
    '''
    Constructs the json that will be sent back through the http request from
    various elements
    @param wavelet_data: the dict with the wavelet and wavelet json
    @param wave_id: the id of the wave
    @param wavelet_id: the id of the wavelet
    @param email: the email of the user waiting for the response
    @param b64Encode=False: set to true if you want the response base64 encoded
    
    @return the json to be sent to the webpage
    '''
    #Fetch the required data from the datastore
    session = sessionTools.get(wave_id, wavelet_id, email)
    settings = settingsTools.get(session)
    waveMeta = waveTools.get(wave_id, wavelet_id)
    if waveMeta:
        participant_profiles = waveMeta.participant_profiles or {}
    else:
        participant_profiles = {}
    
    #Construct the outgoing json
    wavelet_json = {
        'wavelet'       :   wavelet_data.get("json"),
        'readblips'     :   settings.read_blips or [],
        'profiles'      :   participant_profiles,
        'isPublic'      :   sessionTools.isPublic(session),
        'rwPermission'  :   settings.rw_permission   
    }
    if b64Encode:
        return base64.b64encode(simplejson.dumps(wavelet_json))
    else:
        return simplejson.dumps(wavelet_json)
コード例 #2
0
ファイル: butt_bot.py プロジェクト: nickelser/butt-bot
def save_blip_info_full(blip_id, content, annotations="", elements=""):
    saved = SavedBlip()
    saved.blip_id = blip_id
    saved.text = db.Text(content)
    saved.annotations = db.Text(simplejson.dumps(annotations))
    saved.elements = db.Text(simplejson.dumps(elements))
    saved.put()
コード例 #3
0
    def toggle(self, toggle=True):
        pp = model.ParticipantPreferences.get_by_pk(self.participant)
        pwp = model.ParticipantWavePreferences.get_by_pk(self.participant, self.wave_id, create=toggle)
        data = ''

        if pwp:
            if toggle:
                pwp.notify_type = (pwp.notify_type + 1) % model.NOTIFY_TYPE_COUNT
                pwp.put()
            status = pwp.notify_type
            email = pwp.notify_type
            phones = [ 1 ] # TODO count phones
            if len(phones) == 0:
                phone = -1
            if pwp.notify_type != model.NOTIFY_NONE:
                phone = model.NOTIFY_ONCE
            else:
                phone = model.NOTIFY_NONE
            data = simplejson.dumps({ 'status': status,
                                      'email': email,
                                      'phone': phone,
                                      'preferencesWaveId': pp and pp.preferences_wave_id or '' })
        else:
            data = simplejson.dumps({ 'status': 0,
                                      'email': 0,
                                      'phone': 0,
                                      'preferencesWaveId': pp and pp.preferences_wave_id or '' })

        self.response.out.write(data);
コード例 #4
0
ファイル: value.py プロジェクト: KayEss/urquell
def unresolve_part(part):
    if type(part) == str or type(part) == unicode:
        if not len(part):
            return ''
        elif part[0] != '*':
            return urllib.quote(part, '')
        else:
            return urllib.quote(dumps(part), '')
    else:
        return urllib.quote(dumps(part))
コード例 #5
0
def construct_message(participant, phone_token, wave_id, wavelet_id, blip_id,
                      title, message):
    message = (templates.PHONE_MESSAGE % (title, message))

    if phone_token:
        data = {
            'device_tokens': [phone_token.replace(' ', '').upper()],
            'aps': {
                'alert': {
                    'body': message
                }
            },
            'r': '%s:%s:%s:%s' % (participant, wave_id, wavelet_id, blip_id)
        }
    else:
        data = {
            'aps': {
                'alert': {
                    'body': message
                }
            },
            'r': '%s:%s:%s:%s' % (participant, wave_id, wavelet_id, blip_id)
        }

    return simplejson.dumps(data, separators=(',', ':'))
コード例 #6
0
ファイル: __init__.py プロジェクト: KayEss/urquell
def throw(message, *args, **kwargs):
    """
        <p>Raises an exception with the first argument as the main exception text also giving it a JSON representation of the arguments and kwargs</p>
    """
    try:
        json = dumps({'args':args, 'kwargs':kwargs})
    except Exception, e:
        raise Exception('%s\nError generating JSON: %s' % (message, e))
コード例 #7
0
ファイル: utils.py プロジェクト: channywang/pushy
def _add_googlecode_message(wavelet, myJson):
	payload = json.loads(myJson)
	for commit in payload['revisions']:
		reply = wavelet.reply()
		reply.append("[googlecode: "+payload['repository_path']+"]\n\n")
		commit['timestamp'] = _format_for_commit(commit['timestamp'])
		commit['id'] = str(commit['revision'])
		reply.append(element.Gadget(ROBOT_URL + "/gadgets/github.xml", 
			{'commit': urllib.quote(json.dumps(commit))}))
コード例 #8
0
 def _dumps(self, obj):
     '''
     Writes an object to a string so it can be stored in the gadget state
     @param obj: the object to write to string
     @return a b64/json string representing the object
     '''
     if not obj:
         return ""
     return base64.b64encode(simplejson.dumps(obj))
コード例 #9
0
 def features(self):
     features = {}
     blips = self._wavelet.blips
     for blip_id in blips:
         blip = blips[blip_id]
         match = self.FEATURE.match(blip.text)
         if match:
             features[blip.blip_id] = {'name' : match.group(1), 'version' : str(blip.version), 'content' : blip.text}
     return json.dumps({'features' : features})    
コード例 #10
0
    def fetch(self):
        participant = self.request.get('participant')
        wave_id = self.request.get('wave_id')
        wavelet_id = self.request.get('wavelet_id')
        blip_id = self.request.get('blip_id')

        wavelet = util.fetch_wavelet(wave_id, wavelet_id, participant)
        if blip_id in wavelet.blips:
            blip = wavelet.blips[blip_id]
            data = { 'blipId': blip.blip_id,
                     'waveId': blip.wave_id,
                     'waveletId': blip.wavelet_id,
                     'creator': blip.creator,
                     'content': blip.text }
            logging.debug('RESPONSE: %s' % simplejson.dumps(data));
            self.response.out.write(simplejson.dumps(data))
            return False
        else:
            return 'Blip not found'
コード例 #11
0
ファイル: utils.py プロジェクト: channywang/pushy
def _add_github_message(wavelet, myJson):
	payload = json.loads(urllib.unquote(myJson))
	for commit in payload['commits']:
		reply = wavelet.reply()
		reply.append("[github: "+payload['repository']['url']+"]\n\n")
		commit['timestamp'] = _convert_time(commit['timestamp'])
		commit['image'] = _gravatar_url_from(commit['author']['email'])
		commit['author'] = commit['author']['name']
		reply.append(element.Gadget(ROBOT_URL + "/gadgets/github.xml", 
			{'commit': urllib.quote(json.dumps(commit))}))
コード例 #12
0
    def reset(self):
        domain = self.participant.split('@')[1]
        robot = create_robot(run=False, domain=domain)

        preferences.create_preferences_wave(robot, self.participant)

        #wavelet = robot.fetch_wavelet(self.wave_id, '%s!root+conv' % domain)
        #general.participant_init(wavelet, self.participant)
        #general.participant_wavelet_init(wavelet, self.participant, self.participant)

        self.response.out.write(simplejson.dumps({ 'status': 0 }))
コード例 #13
0
    def fetch(self):
        participant = self.request.get('participant')
        wave_id = self.request.get('wave_id')
        wavelet_id = self.request.get('wavelet_id')
        blip_id = self.request.get('blip_id')

        wavelet = util.fetch_wavelet(wave_id, wavelet_id, participant)
        if blip_id in wavelet.blips:
            blip = wavelet.blips[blip_id]
            data = {
                'blipId': blip.blip_id,
                'waveId': blip.wave_id,
                'waveletId': blip.wavelet_id,
                'creator': blip.creator,
                'content': blip.text
            }
            logging.debug('RESPONSE: %s' % simplejson.dumps(data))
            self.response.out.write(simplejson.dumps(data))
            return False
        else:
            return 'Blip not found'
コード例 #14
0
def construct_message(participant, phone_token, wave_id, wavelet_id, blip_id, title, message):
    message = (templates.PHONE_MESSAGE % (title, message))

    if phone_token:
        data = { 'device_tokens': [ phone_token.replace(' ', '').upper() ],
                 'aps': { 'alert': { 'body': message } },
                 'r': '%s:%s:%s:%s' % (participant, wave_id, wavelet_id, blip_id) }
    else:
        data = { 'aps': { 'alert': { 'body': message } },
                 'r': '%s:%s:%s:%s' % (participant, wave_id, wavelet_id, blip_id) }

    return simplejson.dumps(data, separators=(',', ':'))
コード例 #15
0
    def online(self, online=True):
        pwp = model.ParticipantWavePreferences.get_by_pk(self.participant, self.wave_id)

        if pwp:
            pwp.last_visited = datetime.datetime.now()
            pwp.put()
            if not online:
                visited(pwp.participant, self.wave_id, pwp)
            else:
                deferred.defer(visited, pwp.participant, pwp.wave_id,
                               pwp.last_visited, _queue='visited', _countdown=150)

        self.response.out.write(simplejson.dumps({ 'status': 0 }))
コード例 #16
0
ファイル: invocation.py プロジェクト: KayEss/urquell
def invoke(responder, module, fn, *path, **kwargs):
    from urquell.value import resolve_part
    ihash = store_invocation(responder.request.url)
    responder.object['hash'] = u'*%s' % unicode(ihash)
    responder.object['name'] = '%s/%s' % (module.path(), fn.func_name)
    call_trace = [resolve_part(str(i)) for i in path]
    args = [x for u, x in call_trace]
    responder.object['args'] = [u for u, x in call_trace]
    responder.object['value'] = fn(*args, **kwargs)
    json = dumps(responder.object)
    if responder.object.has_key('value'):
        memcache.add(ihash, json, 300)
    return json, responder.object
コード例 #17
0
    def _update_account(self):
        '''Update account or create one if it does not exist yet'''

        if not self.receipt_data: return

        if self.receipt_data == FREE_TRIAL:
            if self.account.subscription_type:
                return 'Cannot activate the free trial, a subscription already exists.'

            purchase_date = datetime.datetime.now()
            transaction_id = FREE_TRIAL
            subscription_type = FREE_TRIAL
        else:
            type = model.ApplicationSettings.get('apn-type')
            receipt_url = model.ApplicationSettings.get('apn-receipt-url-%s' %
                                                        type)
            data = simplejson.dumps({'receipt-data': self.receipt_data})
            json = simplejson.loads(urllib2.urlopen(receipt_url, data).read())

            if json['status'] != 0:
                return 'Invalid receipt'

            subscription_type = json['receipt']['product_id']
            transaction_id = json['receipt']['transaction_id']

            query = model.Account.all()
            query.filter('transaction_id =', transaction_id)
            if query.get():
                return 'Cannot use receipt, account already activated with this receipt.'

            if self.account.transaction_id and self.account.transaction_id != transaction_id:
                purchase_date = self.account.expiration_date
            else:
                purchase_date = json['receipt']['purchase_date'].split(" ")[0]
                purchase_date = datetime.datetime.strptime(
                    purchase_date, "%Y-%m-%d")

        if subscription_type in PRODUCT_IDS:
            self._save_history()
            self.account.expiration_date = PRODUCT_IDS[subscription_type](
                purchase_date)
            self.account.subscription_type = subscription_type
            self.account.transaction_id = transaction_id
            self.account.receipt_data = self.receipt_data
            self.account.put()
        else:
            return "Invalid Product ID %s" % subscription_type
コード例 #18
0
def onAddParticipantsChangedV1(event, wavelet, add_gadget):
    '''
    Deals with the add participants gadget changing, subscribes wave users etc
    @param event: the event that triggered the gadget state change
    @param wavelet: the wavelet the gadget lives in
    @param add_gadget: the add participants gadget retrieved from the wave
    '''

    #Fetch the values from the gadget
    participants_json = add_gadget.get("EMAIL-PARTICIPANTS", None)
    if participants_json:
        participants_json = base64.b64decode(participants_json)
    else:
        participants_json = "[]"
    participants = simplejson.loads(participants_json)
    new_participant = add_gadget.get("ADD-PARTICIPANT", None)

    if new_participant:
        logging.info("Subscribing new e-mail user: "******" not subscribed. E-mail address not valid")
            return

        #Only update if the user is new
        if not new_participant in participants:
            deferred.defer(
                    emailInterface.sendFirstNotificationEmail,
                    sessionCreation.generateNewUser(wavelet.wave_id,
                                                    wavelet.wavelet_id,
                                                    new_participant,
                                                    pt_raw.RW['READ_WRITE']),
                    wavelet.wave_id,
                    wavelet.wavelet_id,
                    new_participant,
                    event.modified_by,
                    wavelet.title)

            participants.append(new_participant)
            wavelet.add_proxying_participant(utils.getProxyForFromEmail(new_participant))

        #Update the gadget
        participants_json = simplejson.dumps(participants)
        add_gadget.update_element({ "ADD-PARTICIPANT": None,
                                    "EMAIL-PARTICIPANTS": base64.b64encode(participants_json)})
コード例 #19
0
    def _update_account(self):
        '''Update account or create one if it does not exist yet'''

        if not self.receipt_data: return

        if self.receipt_data == FREE_TRIAL:
            if self.account.subscription_type:
                return 'Cannot activate the free trial, a subscription already exists.'

            purchase_date = datetime.datetime.now()
            transaction_id = FREE_TRIAL
            subscription_type = FREE_TRIAL
        else:
            type = model.ApplicationSettings.get('apn-type')
            receipt_url = model.ApplicationSettings.get('apn-receipt-url-%s' % type)
            data = simplejson.dumps({ 'receipt-data': self.receipt_data })
            json = simplejson.loads(urllib2.urlopen(receipt_url, data).read())

            if json['status'] != 0:
                return 'Invalid receipt'

            subscription_type = json['receipt']['product_id']
            transaction_id = json['receipt']['transaction_id']

            query = model.Account.all()
            query.filter('transaction_id =', transaction_id)
            if query.get():
                return 'Cannot use receipt, account already activated with this receipt.'

            if self.account.transaction_id and self.account.transaction_id != transaction_id:
                purchase_date = self.account.expiration_date
            else:
                purchase_date = json['receipt']['purchase_date'].split(" ")[0]
                purchase_date = datetime.datetime.strptime(purchase_date, "%Y-%m-%d")

        if subscription_type in PRODUCT_IDS:
            self._save_history()
            self.account.expiration_date = PRODUCT_IDS[subscription_type](purchase_date)
            self.account.subscription_type = subscription_type
            self.account.transaction_id = transaction_id
            self.account.receipt_data = self.receipt_data
            self.account.put()
        else:
            return "Invalid Product ID %s" % subscription_type
コード例 #20
0
def constructInitialState(wavelet):
    '''
    Constructs the initial gadget state. This is used purely for migration from
    the v1 gadget to v2 gadget. So it returns a list of email users in the 
    correct format for the gadget
    @param wavelet: the wavelet where the gadget will live
    @return a dictionary containing the key values of the initial state
    '''
    sessions = sessionTools.fetch(wavelet.wave_id, wavelet.wavelet_id)
    #Form the email list
    email_list = []
    public_session = None
    for session in sessions:
        if sessionTools.isPublic(session):
            public_session = session
        else:
            email_list.append(session.email)
            
    #Form public settings
    public = {}
    isPublic = False
    isReadOnly = True
    
    try:
        public_settings = settingsTools.get(public_session)
        rw_permission = public_settings.rw_permission
        
        if rw_permission == pt_raw.RW['READ']:
            isPublic = True
            isReadOnly = True
        elif rw_permission == pt_raw.RW['READ_WRITE']:
            isPublic = True
            isReadOnly = False
    except:
        #Just means public settings could not be found. Defaults will be used
        pass
    public.update({'isPublic' : isPublic, 'isReadOnly' : isReadOnly});
    
    output = base64.b64encode(simplejson.dumps({'emailParticipants' : email_list,
                                                'public'            : public}))
    return {'state' : output, 'participantDetailsState' : 'fetch'}
コード例 #21
0
ファイル: labnotebot.py プロジェクト: cameronneylon/LabbyBot
#!python
コード例 #22
0
class PhoneProcess(webapp.RequestHandler):
    def post(self, *args):
        self.get()

    def get(self, *args):
        self.response.contentType = 'application/json'

        path = [urllib.unquote(a) for a in self.request.path.split('/')[2:]]
        req_type = path[0]

        self.participant = self.request.get('participant')
        if self.participant:
            self.participant = self.participant.lower()
        self.activation = self.request.get('activation')

        self.receipt_data = self.request.get('receipt_data')

        self.phone_uid = self.request.get('phone_uid')
        self.phone_type = self.request.get('phone_type')
        self.phone_token = self.request.get('phone_token')
        if self.phone_token:
            self.phone_token = self.phone_token.replace('+', ' ')

        logging.debug(LOG, req_type, self.participant, self.activation,
                      self.phone_uid, self.phone_token, self.receipt_data)

        self.account = None

        try:
            if req_type.startswith('_'): return
            error = getattr(self, req_type)()
            if error == False: return
        except Exception, e:
            logging.exception('Error while processing phone process %s', e)
            error = str(e)

        data = None
        if not error and self.account:
            query = model.Phone.all()
            query.filter('account_id =', self.account.account_id)
            phones = [phone1.phone_uid for phone1 in query]

            query = model.ParticipantPreferences.all()
            query.filter('account_id =', self.account.account_id)
            participants = [pa.participant for pa in query]

            data = {
                'phones': phones,
                'participants': participants,
                'subscription_type': self.account.subscription_type,
                'expiration_date': str(self.account.expiration_date),
                'response': "OK"
            }
        else:
            data = {
                'response': "ERROR",
                'message': error or 'Invalid Google Wave account'
            }

        logging.debug('RESPONSE: %s' % simplejson.dumps(data))
        self.response.out.write(simplejson.dumps(data))
コード例 #23
0
ファイル: http.py プロジェクト: KayEss/urquell
                'message': e.message,
                'trace': e.trace
            }
        except Exception, e:
            import traceback
            self.status = 500
            self.object['error'] = {
                'message': unicode(e),
                'python': {
                    'call_trace': traceback.format_exc(),
                },
            }
        self.response.set_status(self.status)
        if self.request.headers.get('X-Requested-With', '').find('XMLHttpRequest') >= 0 or self.request.GET.has_key('__'):
            self.response.headers['Content-Type'] = 'text/plain'
            text = dumps(self.object)
            if self.request.GET.get('__', None):
                self.response.out.write("%s(%s);" % (self.request.GET['__'], text))
            else:
                self.response.out.write(text)
        else:
            self.context['result'] = self.object
            self.context['status'] = self.status
            if self.object.has_key('value'):
                self.context['value'] = dumps(self.object['value'])
            self.context['error'] = self.object.get('error', None)
            self.response.out.write(template.render(self.template, self.context))


class EndPoint(object):
    """
コード例 #24
0
ファイル: models.py プロジェクト: fractastical/mr-ray-open
 def _deflate(self, value):
     return db.Text(simplejson.dumps(value))
コード例 #25
0
ファイル: session.py プロジェクト: KayEss/urquell
	def save(self):
		self.data.frames = dumps(self.frames)
		db.put(self.data)
コード例 #26
0
ファイル: butt_bot.py プロジェクト: nickelser/butt-bot
def save_blip(blip, delta):
    del_saved_blip(blip.blipId)
    saved = SavedBlipDelta()
    saved.blip_id = blip.blipId
    saved.delta = simplejson.dumps(delta)
    saved.put()