示例#1
0
  def test_notify_on_post(self):
    actor_ref = api.actor_get(api.ROOT, 'popular')
    api.post(actor_ref, nick='popular', message='la la la')
    self.exhaust_queue('popular')

    # should notify popular and unpopular
    self.assertEqual(len(xmpp.outbox), 2)
示例#2
0
    def test_notify_on_post(self):
        actor_ref = api.actor_get(api.ROOT, 'popular')
        api.post(actor_ref, nick='popular', message='la la la')
        self.exhaust_queue('popular')

        # should notify popular and unpopular
        self.assertEqual(len(xmpp.outbox), 2)
示例#3
0
  def test_task_post_process_any(self):
    """ test that api.post creates a task and additional calls resume
    """
    nick = '*****@*****.**'
    uuid = 'HOWNOW'
    message = 'BROWNCOW'

    actor_ref = api.actor_get(api.ROOT, nick)

    # DROP
    old_max = api.MAX_FOLLOWERS_PER_INBOX
    api.MAX_FOLLOWERS_PER_INBOX = 1

    try:
      entry_ref = api.post(actor_ref, nick=nick, uuid=uuid, message=message)
      self.assertEqual(entry_ref.extra['title'], message)
    
      # make sure we can repeat
      two_entry_ref = api.post(actor_ref, nick=nick, uuid=uuid, message=message)
      self.assertEqual(entry_ref.uuid, two_entry_ref.uuid)
    
      # and that task_process_any works
      # and run out the queue
      for i in range(5):
        api.task_process_any(api.ROOT, nick)
      
      self.assertRaises(exception.ApiNoTasks,
                        lambda: api.task_process_actor(api.ROOT, nick))
    finally:
      api.MAX_FOLLOWERS_PER_INBOX = old_max  
示例#4
0
 def create_djangouser_for_user(cls, user):
   from common import api
   actor_ref = api.actor_lookup_email(api.ROOT, user.email()) 
   if actor_ref:
     return actor_ref
   params = {'nick': user.nickname(), 'password': "******", 'first_name': user.nickname(),  'last_name': user.nickname()}
   actor_ref = api.user_create(api.ROOT, **params)
   actor_ref.access_level = "delete"
   relation_ref = api.email_associate(api.ROOT, actor_ref.nick, user.email())
   api.post(actor_ref, 
            nick=actor_ref.nick, 
            message='Joined %s!' % (settings.SITE_NAME),
            icon='jaiku-new-user')
   return actor_ref
示例#5
0
  def test_task_post_process_any(self):
    """ test that api.post creates a task and additional calls resume
    """
    nick = '*****@*****.**'
    uuid = 'HOWNOW'
    message = 'BROWNCOW'

    actor_ref = api.actor_get(api.ROOT, nick)

    # DROP
    old_max = api.MAX_FOLLOWERS_PER_INBOX
    api.MAX_FOLLOWERS_PER_INBOX = 1

    entry_ref = api.post(actor_ref, nick=nick, uuid=uuid, message=message)
    self.assertEqual(entry_ref.extra['title'], message)
    
    # make sure we can repeat
    two_entry_ref = api.post(actor_ref, nick=nick, uuid=uuid, message=message)
    self.assertEqual(entry_ref.uuid, two_entry_ref.uuid)
    
    # and that task_process_actor works
    task_more = api.task_process_any(api.ROOT)
    self.assert_(task_more)

    # and run out the queue
    task_more = api.task_process_any(api.ROOT)
    self.assert_(task_more)
    task_more = api.task_process_any(api.ROOT)
    self.assert_(task_more)
    task_more = api.task_process_any(api.ROOT)
    self.assert_(task_more)
    task_more = api.task_process_any(api.ROOT)
    self.assert_(not task_more)

    def _nope():
      task_more = api.task_process_any(api.ROOT)
    
    self.assertRaises(exception.ApiNoTasks, _nope)

    api.MAX_FOLLOWERS_PER_INBOX = old_max  

    pass
示例#6
0
文件: util.py 项目: CollabQ/CollabQ
def user_create(service, params, username="", id="", remote_url=""):
    logging.info("user_create")
    actor_ref = api.user_create(api.ROOT, **params)
    actor_ref.access_level = "delete"

    api.post(actor_ref, nick=actor_ref.nick, message="Joined %s!" % (util.get_metadata("SITE_NAME")))

    email = params.get("email", None)
    if email is not None:
        api.email_associate(api.ROOT, actor_ref.nick, email)
    else:
        key = "emailneeded_%s" % util.display_nick(actor_ref.nick)
        memcache.client.set(key, True, 360)

    key = "firsttime_%s" % util.display_nick(actor_ref.nick)
    memcache.client.set(key, True, 360)

    external_profile_ref = api.create_external_profile(actor_ref.nick, service, username, id, remote_url)

    return actor_ref
示例#7
0
    def test_task_post_process_any(self):
        """ test that api.post creates a task and additional calls resume
    """
        nick = '*****@*****.**'
        uuid = 'HOWNOW'
        message = 'BROWNCOW'

        actor_ref = api.actor_get(api.ROOT, nick)

        # DROP
        old_max = api.MAX_FOLLOWERS_PER_INBOX
        api.MAX_FOLLOWERS_PER_INBOX = 1

        try:
            entry_ref = api.post(actor_ref,
                                 nick=nick,
                                 uuid=uuid,
                                 message=message)
            self.assertEqual(entry_ref.extra['title'], message)

            # make sure we can repeat
            two_entry_ref = api.post(actor_ref,
                                     nick=nick,
                                     uuid=uuid,
                                     message=message)
            self.assertEqual(entry_ref.uuid, two_entry_ref.uuid)

            # and that task_process_any works
            # and run out the queue
            for i in range(5):
                api.task_process_any(api.ROOT, nick)

            self.assertRaises(exception.ApiNoTasks,
                              lambda: api.task_process_actor(api.ROOT, nick))
        finally:
            api.MAX_FOLLOWERS_PER_INBOX = old_max
示例#8
0
文件: views.py 项目: webatat/webatat
def join_join(request):
  if request.user:
    raise exception.AlreadyLoggedInException()

  redirect_to = request.REQUEST.get('redirect_to', '/')

  # get the submitted vars
  nick = request.REQUEST.get('nick', '')
  first_name = request.REQUEST.get('first_name', '')
  last_name = request.REQUEST.get('last_name', '')
  email = request.REQUEST.get('email', '')
  password = request.REQUEST.get('password', '')
  confirm = request.REQUEST.get('confirm', '')
  homepage = request.REQUEST.get('homepage', '')
  hide = request.REQUEST.get('hide', '')

  if request.POST:
    try:
      # TODO validate
      params = util.query_dict_to_keywords(request.POST)

      if hide:
        params['privacy'] = 2
 
      validate.email(email)
      if not mail.is_allowed_to_send_email_to(email):
        raise exception.ValidationError("Cannot send email to that address")

      # TODO start transaction
      if api.actor_lookup_email(api.ROOT, email):
        raise exception.ValidationError(
            'That email address is already associated with a member.')
    
      actor_ref = api.user_create(api.ROOT, **params)
      actor_ref.access_level = "delete"

      api.post(actor_ref, 
               nick=actor_ref.nick, 
               message='Joined %s!' % (settings.SITE_NAME),
               icon='jaiku-new-user')

      # send off email confirmation
      api.activation_request_email(actor_ref, actor_ref.nick, email)
      
      # TODO end transaction
  
      welcome_url = util.qsa('/welcome', {'redirect_to': redirect_to})

      # NOTE: does not provide a flash message
      response = http.HttpResponseRedirect(welcome_url)
      user.set_user_cookie(response, actor_ref)
      return response
    except:
      exception.handle_exception(request)

  # for legal section
  legal_component = component.include('legal', 'dummy_legal')
  legal_html = legal_component.embed_join()

  # for sidebar
  sidebar_green_top = True

  area = "join"
  c = template.RequestContext(request, locals())

  t = loader.get_template('join/templates/join.html')
  return http.HttpResponse(t.render(c))
示例#9
0
 def post(self, from_jid, message):
   jid_ref = api.actor_lookup_im(api.ROOT, from_jid.base())
   if not jid_ref:
     raise exception.ValidationError(
         "You must be signed in to post, please SIGN IN")
   entry_ref = api.post(jid_ref, nick=jid_ref.nick, message=message)
示例#10
0
 def post(self, from_jid, message):
     jid_ref = api.actor_lookup_im(api.ROOT, from_jid.base())
     if not jid_ref:
         raise exception.ValidationError(
             "You must be signed in to post, please SIGN IN")
     entry_ref = api.post(jid_ref, nick=jid_ref.nick, message=message)
示例#11
0
 def post(self, actor_ref):
   entry_ref = api.post(actor_ref, nick=actor_ref.nick, message='test_message')
   self.exhaust_queue_any()
   return entry_ref
示例#12
0
文件: views.py 项目: CollabQ/CollabQ
def join_join(request):
  if request.user:
    raise exception.AlreadyLoggedInException()

  redirect_to = request.REQUEST.get('redirect_to', '/')

  account_types = api.get_config_values(api.ROOT, 'account_type')

  # get the submitted vars
  nick = request.REQUEST.get('nick', '');
  first_name = request.REQUEST.get('first_name', '');
  last_name = request.REQUEST.get('last_name', '');
  email = request.REQUEST.get('email', '');
  password = request.REQUEST.get('password', '');
  confirm = request.REQUEST.get('confirm', '');
  hide = request.REQUEST.get('hide', '');
  country_tag = request.REQUEST.get('country_tag', '')

  if request.POST:
    try:
      # TODO validate
      params = util.query_dict_to_keywords(request.POST)

      if hide:
        params['privacy'] = 2

      # XXX: Check if the data come from a openid account
      # @author: [email protected]
      fromopenid = request.POST.get('fromopenid', False) and True
      if fromopenid:
        try:
          person = openidgae.get_current_person(request, http.HttpResponse())
        except:
          raise exception.ServiceError
        
        email = person.get_email()
        if email == params['email']:
          params['password'] = util.generate_password()
        else:
          raise exception.ServiceError

      # ENDXXX

      validate.email(email)
      if not mail.is_allowed_to_send_email_to(email):
        raise exception.ValidationError("Cannot send email to that address")

      # TODO start transaction
      if api.actor_lookup_email(api.ROOT, email):
        raise exception.ValidationError(
            'That email address is already associated with a member.')
      
      actor_ref = api.user_create(api.ROOT, **params)
      actor_ref.access_level = "delete"

      api.post(actor_ref, 
               nick=actor_ref.nick, 
               message='Joined %s!' % (util.get_metadata('SITE_NAME')))
      if fromopenid:
        api.email_associate(api.ROOT, actor_ref.nick, email)
      else:
        # send off email confirmation
        api.activation_request_email(actor_ref, actor_ref.nick, email)

      logging.info('setting firsttime_%s from register page' % actor_ref.nick)
      memcache.client.set('firsttime_%s' % nick, True)
      # TODO end transaction
      welcome_url = util.qsa('/', {'redirect_to': redirect_to})

      # NOTE: does not provide a flash message
      response = http.HttpResponseRedirect(welcome_url)
      user.set_user_cookie(response, actor_ref)
      return response
    except:
      exception.handle_exception(request)

  # for legal section
  legal_component = component.include('legal', 'dummy_legal')
  legal_html = legal_component.embed_join()
  
  # for sidebar
  sidebar_green_top = True

  area = "join"
  c = template.RequestContext(request, locals())

  t = loader.get_template('join/templates/join.html')
  return http.HttpResponse(t.render(c))
示例#13
0
 def post(self, sender, message):
   sender_ref = api.actor_lookup_mobile(api.ROOT, sender)
   if not sender_ref:
     raise exception.ValidationError(HELP_SIGN_IN)
   entry_ref = api.post(sender_ref, nick=sender_ref.nick, message=message)
示例#14
0
 def post(self, actor_ref):
     entry_ref = api.post(actor_ref,
                          nick=actor_ref.nick,
                          message='test_message')
     self.exhaust_queue_any()
     return entry_ref
示例#15
0
 def post(self, sender, message):
     sender_ref = api.actor_lookup_mobile(api.ROOT, sender)
     if not sender_ref:
         raise exception.ValidationError(HELP_SIGN_IN)
     entry_ref = api.post(sender_ref, nick=sender_ref.nick, message=message)
示例#16
0
def join_join(request):
    if request.user:
        raise exception.AlreadyLoggedInException()

    redirect_to = get_clean_redirect(request)

    # get the submitted vars
    nick = request.REQUEST.get('nick', '')
    first_name = request.REQUEST.get('first_name', '')
    last_name = request.REQUEST.get('last_name', '')
    email = request.REQUEST.get('email', '')
    password = request.REQUEST.get('password', '')
    confirm = request.REQUEST.get('confirm', '')
    homepage = request.REQUEST.get('homepage', '')
    hide = request.REQUEST.get('hide', '')

    if request.POST:
        try:
            # TODO validate
            params = util.query_dict_to_keywords(request.POST)

            if hide:
                params['privacy'] = 2

            validate.email(email)
            if not mail.is_allowed_to_send_email_to(email):
                raise exception.ValidationError(
                    "Cannot send email to that address")

            # TODO start transaction
            if api.actor_lookup_email(api.ROOT, email):
                raise exception.ValidationError(
                    'That email address is already associated with a member.')

            actor_ref = api.user_create(api.ROOT, **params)
            actor_ref.access_level = "delete"

            api.post(actor_ref,
                     nick=actor_ref.nick,
                     message='Joined %s!' % (settings.SITE_NAME),
                     icon='jaiku-new-user')

            # send off email confirmation
            api.activation_request_email(actor_ref, actor_ref.nick, email)

            # TODO end transaction

            welcome_url = util.qsa('/welcome', {'redirect_to': redirect_to})

            # NOTE: does not provide a flash message
            response = http.HttpResponseRedirect(welcome_url)
            user.set_user_cookie(response, actor_ref)
            return response
        except:
            exception.handle_exception(request)

    # for legal section
    legal_component = component.include('legal', 'dummy_legal')
    legal_html = legal_component.embed_join()

    # for sidebar
    sidebar_green_top = True

    area = "join"
    c = template.RequestContext(request, locals())

    t = loader.get_template('join/templates/join.html')
    return http.HttpResponse(t.render(c))