def render(self):

        login_url = resource_url(self.request.context, self.request, 'login')
        referrer = self.request.url
        # never use the login form itself as came_from
        if referrer == login_url:
            referrer = '/'
        came_from = self.request.params.get('came_from', referrer)
        login = self.request.params.get('user.login', '')
        if 'form.submitted' in self.request.params:
            password = self.request.params.get('user.password', u'')
            if password:
                if User.by_ldap_credentials(
                        self.session, login, password,
                        self.request.registry.settings) is not None:
                    log.info('login %r succeed', login)
                    headers = remember(self.request, login)
                    return HTTPFound(location=came_from,
                                     headers=headers)
 
                if User.by_credentials(
                        self.session, login, password) is not None:
                    log.info('login %r succeed', login)
                    headers = remember(self.request, login)
                    return HTTPFound(location=came_from,
                                     headers=headers)

        return {'came_from': came_from,
                'user': User(login=login),
                }

    def authenticated_userid(self, request):

        auth = request.environ.get('HTTP_AUTHORIZATION')
        try:
            authmeth, auth = auth.split(' ', 1)
        except AttributeError:  # not enough values to unpack
            return None

        if authmeth.lower() != 'basic':
            return None

        try:
            # Python 3's string is already unicode
            auth = base64.b64decode(auth.strip())
        except binascii.Error:  # can't decode
            return None

        if not isinstance(auth, unicode):
            auth = auth.decode('utf-8')

        try:
            login, password = auth.split(':', 1)
        except ValueError:  # not enough values to unpack
            return None

        if User.by_credentials(DBSession(), login, password):
            return login
        
        if User.by_ldap_credentials(DBSession(), login, password,request.registry.settings):
            return login
        
        return None

    def render(self):

        package = Package.by_name(self.session, self.request.matchdict["package_name"])
        if not package:
            raise HTTPNotFound()

        if "form.refresh_package" in self.request.params:
            package.update_at = None
            self.session.add(package)

        owners = dict((usr.login, usr) for usr in package.owners)
        can_edit_role = self.login in owners.keys() and package.local

        if "form.add_role" in self.request.params:

            if not can_edit_role:
                raise HTTPForbidden()

            user = User.by_login(self.session, self.request.params["login"])
            if user and user.has_permission("upload_releasefile"):
                if self.request.params["role"] == "owner":
                    if user.login not in owners:
                        package.owners.append(user)
                else:
                    maintainers = [usr.login for usr in package.owners]
                    if user.login not in maintainers:
                        package.maintainers.append(user)
                self.session.add(package)

        if "form.remove_maintainer" in self.request.params:
            if not can_edit_role:
                raise HTTPForbidden()

            user = User.by_login(self.session, self.request.params["login"])
            if user:
                maintainers = dict((usr.login, usr) for usr in package.maintainers)
                if user.login in maintainers:
                    package.maintainers.remove(maintainers[user.login])
                    self.session.add(package)

        if "form.remove_owner" in self.request.params:
            if not can_edit_role:
                raise HTTPForbidden()

            user = User.by_login(self.session, self.request.params["login"])
            if user:
                if user.login in owners:
                    package.owners.remove(owners[user.login])
                    self.session.add(package)

        if "release_version" in self.request.matchdict:
            release = Release.by_version(self.session, package.name, self.request.matchdict["release_version"])
        else:
            release = package.sorted_releases[0]

        return {u"package": package, u"release": release, u"can_edit_role": can_edit_role}

    def authenticated_userid(self, request):

        auth = request.environ.get('HTTP_AUTHORIZATION')
        try:
            authmeth, auth = auth.split(' ', 1)
        except AttributeError as ValueError:  # not enough values to unpack
            return None

        if authmeth.lower() != 'basic':
            return None

        try:
            # Python 3's string is already unicode
            auth = auth.strip().decode('base64')
            if sys.version_info[0] == 2:
                auth = unicode(auth)
        except binascii.Error:  # can't decode
            return None
        try:
            login, password = auth.split(':', 1)
        except ValueError:  # not enough values to unpack
            return None

        if User.by_credentials(DBSession(), login, password):
            return login

        return None

    def test_update_post_ok(self):
        from pyshop.models import User
        from pyshop.views.user import Edit

        view = Edit(
            self.create_request(
                {
                    "form.submitted": u"1",
                    "user.login": u"root",
                    "user.firstname": u"Admin",
                    "user.lastname": u"Istrator",
                }
            )
        )()
        self.assertIsRedirect(view)
        self.session.flush()
        admin = User.by_credentials(self.session, u"root", u"changeme")
        self.assertIsInstance(admin, User)
        self.assertEqual(admin.login, u"root")
        self.assertEqual(admin.firstname, u"Admin")
        self.assertEqual(admin.lastname, u"Istrator")
        admin.login = u"admin"
        admin.password = u"changeme"
        admin.firstname = None
        admin.lastname = None
        self.session.add(admin)

    def _create_release(self, package, data):

        release = Release(package=package,
                          summary=data.get('summary'),
                          version=data.get('version'),
                          stable_version=data.get('stable_version'),
                          home_page=data.get('home_page'),
                          license=data.get('license'),
                          description=data.get('description'),
                          keywords=data.get('keywords'),
                          platform=data.get('platform'),
                          download_url=data.get('download_url'),
                          bugtrack_url=data.get('bugtrack_url'),
                          docs_url=data.get('docs_url'),
                          )
        if data.get('author'):
            author = User.by_login(self.session, data['author'], local=False)
            if not author:
                author = User(login=data['author'],
                              local=False,
                              email=data.get('author_email'))
                self.session.add(author)
            release.author = author
        self.session.flush()
        if data.get('maintainer'):
            maintainer = User.by_login(self.session, data['maintainer'],
                                       local=False)
            if not maintainer:
                maintainer = User(login=data['maintainer'],
                                  local=False,
                                  email=data.get('maintainer_email'))
                self.session.add(maintainer)
            release.maintainer = maintainer
        self.session.flush()

        for name in data.get('classifiers', []):
            classifier = Classifier.by_name(self.session, name)

            while classifier:
                release.classifiers.append(classifier)
                if classifier not in package.classifiers:
                    package.classifiers.append(classifier)
                classifier = classifier.parent

        self.session.flush()
        return release

 def test_post_delete_ok(self):
     from pyshop.views.account import Delete
     from pyshop.models import User
     view = Delete(self.create_request({'form.submitted': '1',
                                        },
                                       matchdict={'user_id': self.account_id
                                                  },))()
     self.assertIsRedirect(view)
     account = User.by_id(self.session, self.account_id)
     self.assertIsNone(account)
     self.account_todelete = []

 def test_change_password_post_ok(self):
     from pyshop.models import User
     from pyshop.views.user import ChangePassword as ChangePwd
     view = ChangePwd(self.create_request({'form.submitted': u'1',
                                           'current_password': u'changeme',
                                           'user.password': u'newpassw',
                                           'confirm_password': u'newpassw',
                                           }))()
     admin = User.by_credentials(self.session, u'admin', u'newpassw')
     self.assertIsInstance(admin, User)
     admin.password = u'changeme'
     self.session.add(admin)

def authbasic(request):
    """
    Authentification basic, Upload pyshop repository access
    """
    if len(request.environ.get('HTTP_AUTHORIZATION','')) > 0:
        auth = request.environ.get('HTTP_AUTHORIZATION')
        scheme, data = auth.split(None, 1)
        assert scheme.lower() == 'basic'
        data = base64.b64decode(data)
        if not isinstance(data, unicode):
            data = data.decode('utf-8')
        username, password = data.split(':', 1)
        if User.by_ldap_credentials(DBSession(), username, password, request.registry.settings):
            return HTTPFound(location=request.url)
        if User.by_credentials(DBSession(), username, password):
            return HTTPFound(location=request.url)
    return Response(status=401,
                    headerlist=[(b'WWW-Authenticate',
                                 b'Basic realm="pyshop repository access"'
                                 )],
                    )

 def test_change_password_post_ko_unchanged(self):
     from pyshop.models import User
     from pyshop.views.user import ChangePassword as ChangePwd
     view = ChangePwd(self.create_request({'form.submitted': u'1',
                                           'current_password': u'changeme',
                                           'user.password': u'changeme',
                                           'confirm_password': u'changeme',
                                           }))()
     self.assertEqual(view['errors'],
                      [u'password is inchanged'])
     admin = User.by_credentials(self.session, u'admin', u'changeme')
     self.assertIsInstance(admin, User)

 def test_change_password_post_ko_not_matched(self):
     from pyshop.models import User
     from pyshop.views.user import ChangePassword as ChangePwd
     view = ChangePwd(self.create_request({'form.submitted': u'1',
                                           'current_password': u'CHANGEME',
                                           'user.password': u'newpassw',
                                           'confirm_password': u'NEWPASSW',
                                           }))()
     self.assertEqual(view['errors'],
                      [u'current password is not correct',
                       u'passwords do not match'])
     admin = User.by_credentials(self.session, u'admin', u'changeme')
     self.assertIsInstance(admin, User)

    def validate(self, model, errors):
        r = self.request

        if not User.by_credentials(self.session, model.login,
                                   r.params['current_password']):
            errors.append(_(u'current password is not correct'))
        elif r.params['user.password'] == r.params['current_password']:
            errors.append(_(u'password is inchanged'))

        if r.params['user.password'] != r.params['confirm_password']:
            errors.append(_(u'passwords do not match'))

        return len(errors) == 0

 def test_post_create_ok(self):
     from pyshop.views.account import Create
     from pyshop.models import User, Group
     view = Create(self.create_request({'form.submitted': u'1',
                                        'user.login': u'dummy_new',
                                        'user.password': u'secret',
                                        'user.firstname': u'',
                                        'user.lastname': u'',
                                        'user.email': u'[email protected]',
                                        'confirm_password': u'secret',
                                        'groups': [u'1', u'2']
                                        }))()
     self.assertIsRedirect(view)
     self.account_todelete.append(User.by_login(self.session,
                                                u'dummy_new').id)

def authbasic(request):
    """
    Authentification basic, Upload pyshop repository access
    """
    if len(request.environ.get('HTTP_AUTHORIZATION','')) > 0:
        auth = request.environ.get('HTTP_AUTHORIZATION')
        scheme, data = auth.split(None, 1)
        assert scheme.lower() == 'basic'
        username, password = data.decode('base64').split(':', 1)
        if User.by_credentials(DBSession(), username, password):
            return HTTPFound(location=request.url)
    return Response(status=401,
                    headerlist=[('WWW-Authenticate',
                                 ('Basic realm="%s"' %
                                 _('pyshop repository access')).encode('utf-8')
                                 )],
                    )

    def test_change_password_post_ko_unchanged(self):
        from pyshop.models import User
        from pyshop.views.user import ChangePassword as ChangePwd

        view = ChangePwd(
            self.create_request(
                {
                    "form.submitted": u"1",
                    "current_password": u"changeme",
                    "user.password": u"changeme",
                    "confirm_password": u"changeme",
                }
            )
        )()
        self.assertEqual(view["errors"], [u"password is inchanged"])
        admin = User.by_credentials(self.session, u"admin", u"changeme")
        self.assertIsInstance(admin, User)

    def test_change_password_post_ko_not_matched(self):
        from pyshop.models import User
        from pyshop.views.user import ChangePassword as ChangePwd

        view = ChangePwd(
            self.create_request(
                {
                    "form.submitted": u"1",
                    "current_password": u"CHANGEME",
                    "user.password": u"newpassw",
                    "confirm_password": u"NEWPASSW",
                }
            )
        )()
        self.assertEqual(view["errors"], [u"current password is not correct", u"passwords do not match"])
        admin = User.by_credentials(self.session, u"admin", u"changeme")
        self.assertIsInstance(admin, User)

 def test_post_edit_ok(self):
     from pyshop.views.account import Edit
     from pyshop.models import User, Group
     view = Edit(self.create_request({'form.submitted': '1',
                                      'user.login': u'dummy_edited',
                                      'user.firstname': u'',
                                      'user.lastname': u'',
                                      'user.email': u'[email protected]',
                                      'groups': [u'1']
                                      },
                                     matchdict={'user_id': self.account_id
                                                }))()
     self.assertIsRedirect(view)
     self.session.flush()
     user = User.by_id(self.session, self.account_id)
     self.assertEqual(user.login, u'dummy_edited')
     self.assertEqual([g.id for g in user.groups], [1])

    def test_change_password_post_ok(self):
        from pyshop.models import User
        from pyshop.views.user import ChangePassword as ChangePwd

        view = ChangePwd(
            self.create_request(
                {
                    "form.submitted": u"1",
                    "current_password": u"changeme",
                    "user.password": u"newpassw",
                    "confirm_password": u"newpassw",
                }
            )
        )()
        admin = User.by_credentials(self.session, u"admin", u"newpassw")
        self.assertIsInstance(admin, User)
        admin.password = u"changeme"
        self.session.add(admin)

 def test_update_post_ok(self):
     from pyshop.models import User
     from pyshop.views.user import Edit
     view = Edit(self.create_request({'form.submitted': u'1',
                                      'user.login': u'root',
                                      'user.firstname': u'Admin',
                                      'user.lastname': u'Istrator',
                                      }))()
     self.assertIsRedirect(view)
     self.session.flush()
     admin = User.by_credentials(self.session, u'root', u'changeme')
     self.assertIsInstance(admin, User)
     self.assertEqual(admin.login, u'root')
     self.assertEqual(admin.firstname, u'Admin')
     self.assertEqual(admin.lastname, u'Istrator')
     admin.login = u'admin'
     admin.password = u'changeme'
     admin.firstname = None
     admin.lastname = None
     self.session.add(admin)

    def render(self):

        api = pypi.proxy
        settings = self.request.registry.settings
        sanitize = asbool(settings['pyshop.mirror.sanitize'])

        package_name = self.request.matchdict['package_name']
        pkg = Package.by_name(self.session, package_name)
        refresh = True

        if pkg:
            if pkg.local:
                refresh = False
            else:
                if pkg.update_at:
                    td = datetime.now() - pkg.update_at
                    # refresh if the package has not been update today
                    # XXX should be configurable
                    refresh = td.days > 0

        if refresh:
            pypi_versions = api.package_releases(package_name, True)
            # XXX package_releases is case sensitive
            # but dependancies declaration not...
            if not pypi_versions:
                search_result = api.search({'name': package_name}, True)
                search_count = len(search_result)
                search_result = [p for p in search_result
                                 if p['name'].lower() == package_name
                                 or p['name'].lower().replace('-', '_') == package_name]
                log.debug('Found {sc}, matched {mc}'.format(sc=search_count, mc=len(search_result)))

                if search_result:
                    package_name = search_result[0]['name']
                    pypi_versions = api.package_releases(package_name, True)
        else:
            pypi_versions = []

        if not pkg:
            if not pypi_versions:
                log.info('package %s has no versions' % package_name)
                return {'package': None,
                        'package_name': package_name}

            if sanitize:
                re_sanitize = re.compile(settings['pyshop.mirror.'
                                                  'sanitize.regex'])
                pypi_versions = [v for v in pypi_versions
                                 if re_sanitize.match(v)]

            # mirror the package now
            log.info('mirror package %s now' % package_name)
            pkg = Package(name=package_name, local=False)
            roles = api.package_roles(package_name)
            for role, login in roles:
                login = login.decode('utf-8')  # XMLRPC should return utf-8
                user = User.by_login(self.session, login, local=False)
                if not user:
                    user = User(login=login, local=False)
                    self.session.add(user)
                if role == 'Owner':
                    pkg.owners.append(user)
                elif role == 'Maintainer':
                    pkg.maintainers.append(user)

        self.session.flush()

        refresh = True
        if not pkg.local and refresh:
            pkg_versions = pkg.versions
            for version in pypi_versions:
                if version not in pkg_versions:
                    release_data = api.release_data(package_name, version)
                    release = self._create_release(pkg, release_data)

                    release_files = api.release_urls(package_name, version)

                    for data in release_files:
                        filename = data['filename'].decode('utf-8')
                        rf = ReleaseFile.by_filename(self.session, release,
                                                     filename)
                        if not rf:
                            rf = self._create_release_file(release, data)

        pkg.update_at = func.now()
        self.session.add(pkg)
        log.info('package %s mirrored' % package_name)
        return {'package': pkg}