Example #1
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
Example #2
0
def lookup_user_by_login(login, password):
    """Looks up user by a given login. Returns None on failure.

    login - can be either nick or confirmed email
    password - password associated withe the user
  """
    try:
        current_user = authenticate_user_login(login, password)
        if current_user:
            return current_user
    except exception.ValidationError:
        pass  # let's try the email address next
    # login can be confirmed email address
    actor_ref = api.actor_lookup_email(api.ROOT, login)
    if actor_ref:
        return authenticate_user_login(actor_ref.nick, password)
    return None
Example #3
0
def lookup_user_by_login(login, password):
  """Looks up user by a given login. Returns None on failure.

    login - can be either nick or confirmed email
    password - password associated withe the user
  """
  try:
    current_user = authenticate_user_login(login, password)
    if current_user:
      return current_user
  except exception.ValidationError:
    pass # let's try the email address next
  # login can be confirmed email address
  actor_ref = api.actor_lookup_email(api.ROOT, login)
  if actor_ref:
    return authenticate_user_login(actor_ref.nick, password)
  return None
Example #4
0
def reponse_if_exists(id, service=None):
    if service is None:
        view = api.actor_lookup_email(api.ROOT, id)
    else:
        eprofile = api.get_external_profile(service, id)
        if eprofile is not None:
            nick = clean.nick(eprofile.nick)
            view = api.actor_lookup_nick(api.ROOT, nick)
        else:
            return None

    if view:
        response = http.HttpResponseRedirect(view.url("/overview"))
        response = user.set_user_cookie(response, view)
        return response

    return None
Example #5
0
  def sign_in(self, from_jid):
    jid_ref = api.actor_lookup_im(api.ROOT, from_jid.base())
    if jid_ref:
      raise exception.ValidationError(
          "You are already signed in, please SIGN OUT first")

    user_ref = api.actor_lookup_email(api.ROOT, from_jid.base())

    im_ref = api.im_associate(api.ROOT, user_ref.nick, from_jid.base())

    welcome = '\n'.join([HELP_WELCOME_NICK % user_ref.display_nick(),
                         HELP_POST,
                         HELP_CHANNEL_POST,
                         HELP_COMMENT,
                         HELP_FOLLOW,
                         HELP_STOP,
                         HELP_MORE,
                         HELP_FOOTER])

    self.send_message([from_jid], welcome)    
Example #6
0
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))
Example #7
0
def join_welcome_contacts(request):

  """
  if we have an access token for this user attempt to fetch the contacts
  else if we have a request token attempt to get an access token
  if we have neither
    if we are trying to authorize, grab a request token and redirect to authorize page
    else
      show the page
  """
  redirect_to = request.REQUEST.get('redirect_to', '/')
  next = '/welcome/done'


  # these are for the find more contacts bits
  start_index = int(request.REQUEST.get('index', 1))
  max = 100
  token = request.REQUEST.get('token')
  contacts_more = int(request.REQUEST.get('contacts_more', 0))
  # this won't be seen unless contacts_more is positive,
  # so no worries about the possible negative value
  contacts_so_far = contacts_more - 1


  try:
    if not settings.GOOGLE_CONTACTS_IMPORT_ENABLED:
      raise exception.FeatureDisabledError('Google Contacts import is currently disabled')
    
    if 'lookup_remote_contacts' in request.POST:
      validate.nonce(request, 'lookup_remote_contacts')

      next_url = util.qsa(util.here(request), 
                          {'redirect_to': redirect_to,
                           'upgrade_auth_token': '',
                           '_nonce': util.create_nonce(request.user, 
                                                       'upgrade_auth_token'),
                           }
                          )
      auth_url = google_contacts.auth_sub_url(next_url)
      return http.HttpResponseRedirect(auth_url)
    elif 'actor_add_contacts' in request.POST:
      validate.nonce(request, 'actor_add_contacts')

  
      targets = request.POST.getlist('targets')
      owner = request.POST.get('owner', '')

      rv = api.actor_add_contacts(request.user, owner, targets)

      next_url = util.qsa(util.here(request),
                          {'redirect_to': redirect_to,
                           'contacts_more': contacts_more,
                           'index': start_index,
                           'token': token,
                           }
                          )

      return util.RedirectFlash(next_url, 'Contacts added.')
  
    elif 'upgrade_auth_token' in request.GET:
      validate.nonce(request, 'upgrade_auth_token')
      
      auth_token = google_contacts.auth_sub_token_from_request(request)
      session_token = google_contacts.upgrade_to_session_token(auth_token)
      
      next_url = util.qsa(util.here(request),
                          {'redirect_to': redirect_to,
                           'fetch_contacts': '',
                           'token': session_token.get_token_string(),
                           '_nonce': util.create_nonce(request.user, 
                                                       'fetch_contacts'),
                           }
                          )
      
      return http.HttpResponseRedirect(next_url)

    elif 'fetch_contacts' in request.REQUEST:
      validate.nonce(request, 'fetch_contacts')
      
      # start_index and max are gathered above
      session_token = google_contacts.auth_sub_token_from_request(request)
      
      # check for the "My Contacts" group, otherwise, fetch it
      my_contacts = memcache.client.get('%s/my_contacts' % token)
      if not my_contacts:
        my_contacts = google_contacts.get_system_group(session_token, 
                                                       'Contacts')
        memcache.client.set('%s/my_contacts' % token, my_contacts)


      rv, more = google_contacts.get_contacts_emails(session_token,
                                                     group=my_contacts,
                                                     index=start_index,
                                                     max=max)

      contacts = []

      for name, email in rv:
        logging.info('looking up "%s" %s', name, email)
        contacts.append(api.actor_lookup_email(request.user, email))

      contacts = [x for x in contacts if x]

      # for the template
      contacts_found = True
      contacts_more = more
      contacts_so_far = contacts_more - 1
      token = session_token.get_token_string()
      contacts_emails = rv

      # if no contacts were found and more are available, try some more
      if not contacts and contacts_more:
        next_url = util.qsa(util.here(request),
                            {'fetch_contacts': '',
                             'contacts_more': contacts_more,
                             'index': contacts_more,
                             'token': token,
                             '_nonce': util.create_nonce(request.user,
                                                         'fetch_contacts'),
                             'redirect_to': redirect_to,
                             }
                            )
        # TODO(termie): this can take a really long time, probably not really
        #               viable until we can do it with javascript
        #return util.MetaRefresh(next_url, message='Still working...', second=1)
        #return http.HttpResponseRedirect(next_url)

  except:
    exception.handle_exception(request)


  # set the progress
  welcome_photo = True
  welcome_mobile = True

  view = request.user
  page = 'contacts'

  area = 'welcome'
  c = template.RequestContext(request, locals())
  
  t = loader.get_template('join/templates/welcome_%s.html' % page)
  return http.HttpResponse(t.render(c))
Example #8
0
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))
Example #9
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))
Example #10
0
def join_welcome_contacts(request):
    """
  if we have an access token for this user attempt to fetch the contacts
  else if we have a request token attempt to get an access token
  if we have neither
    if we are trying to authorize, grab a request token and redirect to authorize page
    else
      show the page
  """
    redirect_to = get_clean_redirect(request)
    next = '/welcome/done'

    # these are for the find more contacts bits
    start_index = int(request.REQUEST.get('index', 1))
    max = 100
    token = request.REQUEST.get('token')
    contacts_more = int(request.REQUEST.get('contacts_more', 0))
    # this won't be seen unless contacts_more is positive,
    # so no worries about the possible negative value
    contacts_so_far = contacts_more - 1

    try:
        if not settings.GOOGLE_CONTACTS_IMPORT_ENABLED:
            raise exception.FeatureDisabledError(
                'Google Contacts import is currently disabled')

        if 'lookup_remote_contacts' in request.POST:
            validate.nonce(request, 'lookup_remote_contacts')

            next_url = util.qsa(
                util.here(request), {
                    'redirect_to':
                    redirect_to,
                    'upgrade_auth_token':
                    '',
                    '_nonce':
                    util.create_nonce(request.user, 'upgrade_auth_token'),
                })
            auth_url = google_contacts.auth_sub_url(next_url)
            return http.HttpResponseRedirect(auth_url)
        elif 'actor_add_contacts' in request.POST:
            validate.nonce(request, 'actor_add_contacts')

            targets = request.POST.getlist('targets')
            owner = request.POST.get('owner', '')

            rv = api.actor_add_contacts(request.user, owner, targets)

            next_url = util.qsa(
                util.here(request), {
                    'redirect_to': redirect_to,
                    'contacts_more': contacts_more,
                    'index': start_index,
                    'token': token,
                })

            return util.RedirectFlash(next_url, 'Contacts added.')

        elif 'upgrade_auth_token' in request.GET:
            validate.nonce(request, 'upgrade_auth_token')

            auth_token = google_contacts.auth_sub_token_from_request(request)
            session_token = google_contacts.upgrade_to_session_token(
                auth_token)

            next_url = util.qsa(
                util.here(request), {
                    'redirect_to': redirect_to,
                    'fetch_contacts': '',
                    'token': session_token.get_token_string(),
                    '_nonce': util.create_nonce(request.user,
                                                'fetch_contacts'),
                })

            return http.HttpResponseRedirect(next_url)

        elif 'fetch_contacts' in request.REQUEST:
            validate.nonce(request, 'fetch_contacts')

            # start_index and max are gathered above
            session_token = google_contacts.auth_sub_token_from_request(
                request)

            # check for the "My Contacts" group, otherwise, fetch it
            my_contacts = memcache.client.get('%s/my_contacts' % token)
            if not my_contacts:
                my_contacts = google_contacts.get_system_group(
                    session_token, 'Contacts')
                memcache.client.set('%s/my_contacts' % token, my_contacts)

            rv, more = google_contacts.get_contacts_emails(session_token,
                                                           group=my_contacts,
                                                           index=start_index,
                                                           max=max)

            contacts = []

            for name, email in rv:
                logging.info('looking up "%s" %s', name, email)
                contacts.append(api.actor_lookup_email(request.user, email))

            contacts = [x for x in contacts if x]

            # for the template
            contacts_found = True
            contacts_more = more
            contacts_so_far = contacts_more - 1
            token = session_token.get_token_string()
            contacts_emails = rv

            # if no contacts were found and more are available, try some more
            if not contacts and contacts_more:
                next_url = util.qsa(
                    util.here(request), {
                        'fetch_contacts': '',
                        'contacts_more': contacts_more,
                        'index': contacts_more,
                        'token': token,
                        '_nonce': util.create_nonce(request.user,
                                                    'fetch_contacts'),
                        'redirect_to': redirect_to,
                    })
                # TODO(termie): this can take a really long time, probably not really
                #               viable until we can do it with javascript
                #return util.MetaRefresh(next_url, message='Still working...', second=1)
                #return http.HttpResponseRedirect(next_url)

    except:
        exception.handle_exception(request)

    # set the progress
    welcome_photo = True
    welcome_mobile = True

    view = request.user
    page = 'contacts'

    area = 'welcome'
    c = template.RequestContext(request, locals())

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