def get_extended_fb_token(access_token):
    # print access_token
    payload = {'client_id': FB_CLIENT_ID, 'client_secret': FB_CLIENT_SECRET, 'grant_type': 'fb_exchange_token', 'fb_exchange_token': access_token}
    r = requests.get("https://graph.facebook.com/oauth/access_token", params=payload)
    try:
        access_token = url_decode(r.text).get('access_token')
    except Exception as e:
        print '(WARNING) Failed to parse retrieve long-lived access token', r.text
    print 'EXPIRES: ' + url_decode(r.text).get('expires')
    return access_token

def test_url_decoding():
    """Test the URL decoding"""
    x = url_decode('foo=42&bar=23&uni=H%C3%A4nsel')
    assert x['foo'] == '42'
    assert x['bar'] == '23'
    assert x['uni'] == u'Hänsel'

    x = url_decode('foo=42;bar=23;uni=H%C3%A4nsel', separator=';')
    assert x['foo'] == '42'
    assert x['bar'] == '23'
    assert x['uni'] == u'Hänsel'

    x = url_decode('%C3%9Ch=H%C3%A4nsel', decode_keys=True)
    assert x[u'Üh'] == u'Hänsel'

def cse_demande():
    def mk_float(s):
        s = s.strip()
        return float(s) if s else 0

    data = url_decode(request.data)

    data['logement_gracieux'] = data['logement_gracieux'] == 'Oui'
    data['logement_montant'] = mk_float(data['logement_montant'])

    data['financement_famille'] = data['financement_famille'] == 'Oui'
    data['financement_famille_montant'] = mk_float(data['financement_famille_montant'])

    data['financement_autre'] = data['financement_autre'] == 'Oui'
    data['financement_autre_montant'] = mk_float(data['financement_autre_montant'])

    data['apl'] = data['apl'] == 'Oui'
    data['apl_montant'] = mk_float(data['apl_montant'])

    # data['boursier'] = data['boursier'] == 'Oui'
    data['boursier_montant'] = mk_float(data['boursier_montant'])

    print data.to_dict()
    demande = DossierCSE(**data.to_dict())
    demande.save()

    return jsonify(result='saved')

def parse_response(resp, content, strict=False, content_type=None):
    """
    Parse the response returned by :meth:`OAuthRemoteApp.http_request`.
    """
    ct = resp.headers.get('content-type')
    if not ct and content.lower().strip().startswith('callback('):
        ct = 'application/json'
    if not ct:
        ct = content_type
    if not ct:
        ct = 'application/json'
    ct, options = parse_options_header(ct)

    if ct in ('application/json', 'text/javascript'):
        if content.lower().strip().startswith('callback('):
            content = content.strip().replace('callback(', '', 1).strip("); ")
        return json.loads(content)

    if ct in ('application/xml', 'text/xml'):
        return get_etree().fromstring(content)

    if ct != 'application/x-www-form-urlencoded' and strict:
        return content
    charset = options.get('charset', 'utf-8')
    return url_decode(content, charset=charset).to_dict()

    def __call__(self, environ, start_response):
        if '_method' in environ.get('QUERY_STRING', ''):
            args = url_decode(environ['QUERY_STRING'])
            method = args.get('_method')
            if method:
                method = method.encode('ascii', 'replace')
                environ['REQUEST_METHOD'] = method
        return self.app(environ, start_response)

# class MethodRewriteMiddleware(object):
#     """Legacy Browser and HTTP REST Methods Support
#     For HTML form use:
#     <input type="hidden" name="_method" value="OPTIONS" />
#     """
#     HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE',
#                     'HEAD', 'OPTIONS',
#                     'TRACE', 'CONNECT']

#     def __init__(self, app, input_name='_method'):
#         self.app = app
#         self.input_name = input_name

#     def __call__(self, environ, start_response):
#         request = Request(environ)

        if self.input_name in request.form:
            method = request.form[self.input_name].upper()

            if method in self.HTTP_METHODS:
                environ['REQUEST_METHOD'] = method

        return self.app(environ, start_response)

def url_add(url=None, **kwargs):
    scheme, netloc, path, query, fragments = urlsplit(url or request.url)
    params = url_decode(query)
    for key, value in kwargs.items():
        if not value in params.getlist(key):
            params.add(key, value)
    return Markup(urlunsplit((scheme, netloc, path, url_encode(params), fragments)))

 def url_equals(to_check):
     if to_check[:4] != check_parts[:4]:
         return False
     args = url_decode(to_check[4])
     for key, value in args.iteritems():
         if check_query.get(key) != value:
             return False
     return True

 def __call__(self, environ, start_response):
     if "METHOD_OVERRIDE" in environ.get("QUERY_STRING", ""):
         args = url_decode(environ["QUERY_STRING"])
         method = args.get("__METHOD_OVERRIDE__")
         if method:
             method = method.encode("ascii", "replace")
             environ["REQUEST_METHOD"] = method
     return self.app(environ, start_response)

def in_url(*args, **kwargs):
    scheme, netloc, path, query, fragments = urlsplit(request.url)
    params = url_decode(query)
    return (
        all(arg in params for arg in args) and
        all(key in params and params[key] == value
            for key, value in kwargs.items())
    )

def url_rewrite(url=None, **kwargs):
    scheme, netloc, path, query, fragments = urlsplit(url or request.url)
    params = url_decode(query)
    for key, value in kwargs.items():
        params.setlist(key,
                       value if isinstance(value, (list, tuple)) else [value])
    return Markup(urlunsplit((scheme, netloc, path, url_encode(params),
                  fragments)))

 def __call__(self, environ, start_response):
     if 'METHOD_OVERRIDE' in environ.get('QUERY_STRING', ''):
         args = url_decode(environ['QUERY_STRING'])
         method = args.get('__METHOD_OVERRIDE__')
         if method:
             method = method.encode('ascii', 'replace')
             environ['REQUEST_METHOD'] = method
     return self.app(environ, start_response)

 def __call__(self, environ, start_response):
     if '__METHOD__' in environ.get('QUERY_STRING', ''):
         args = url_decode(environ['QUERY_STRING'])
         method = args.get('__METHOD__').upper()
         if method in ['GET', 'POST', 'PUT', 'DELETE']:
             method = method.encode('ascii', 'replace')
             environ['REQUEST_METHOD'] = method
     return self.app(environ, start_response)

    def get_redirect_target(self, invalid_targets=()):
        """Check the request and get the redirect target if possible.
        If not this function returns just `None`.  The return value of this
        function is suitable to be passed to `redirect`.
        """
        check_target = self.values.get('_redirect_target') or \
                       self.values.get('next') or \
                       self.referrer

        # if there is no information in either the form data
        # or the wsgi environment about a jump target we have
        # to use the target url
        if not check_target:
            return

        # otherwise drop the leading slash
        check_target = check_target.lstrip('/')

        root_url = self.url_root
        root_parts = urlparse(root_url)

        check_parts = urlparse(urljoin(root_url, check_target))
        check_query = url_decode(check_parts[4])

        def url_equals(to_check):
            if to_check[:4] != check_parts[:4]:
                return False
            args = url_decode(to_check[4])
            for key, value in args.iteritems():
                if check_query.get(key) != value:
                    return False
            return True

        # if the jump target is on a different server we probably have
        # a security problem and better try to use the target url.
        # except the host is whitelisted in the config
        if root_parts[:2] != check_parts[:2]:
            host = check_parts[1].split(':', 1)[0]
            for rule in settings.ALLOWED_REDIRECTS:
                if fnmatch(host, rule):
                    break
            else:
                return

        # if the jump url is the same url as the current url we've had
        # a bad redirect before and use the target url to not create a
        # infinite redirect.
        if url_equals(urlparse(self.url)):
            return

        # if the `check_target` is one of the invalid targets we also
        # fall back.
        for invalid in invalid_targets:
            if url_equals(urlparse(urljoin(root_url, invalid))):
                return

        return check_target

def create_engine(uri, relative_to=None, debug=False):
    """Create a new engine.  This works a bit like SQLAlchemy's
    `create_engine` with the difference that it automaticaly set's MySQL
    engines to 'utf-8', and paths for SQLite are relative to the path
    provided as `relative_to`. Also hooks in LookLively to catch MySQL's
    weird way of connection termination without termination.

    Furthermore the engine is created with `convert_unicode` by default.
    """

    # This is a good idea in any case
    options = {'convert_unicode': True}

    # special case sqlite.  We want nicer urls for that one.
    if uri.startswith('sqlite:'):
        match = _sqlite_re.match(uri)
        if match is None:
            raise ArgumentError('Could not parse rfc1738 URL')
        database, query = match.groups()
        if database is None:
            database = ':memory:'
        elif relative_to is not None:
            database = path.join(relative_to, database)
        if query:
            query = url_decode(query).to_dict()
        else:
            query = {}
        info = URL('sqlite', database=database, query=query)

    else:
        info = make_url(uri)

        # if mysql is the database engine and no connection encoding is
        # provided we set it to utf-8
        if info.drivername == 'mysql':
            info.query.setdefault('charset', 'utf8')
            options['listeners'] = [LookLively()]


    # alternative pool sizes / recycle settings and more.  These are
    # interpreter wide and not from the config for the following reasons:
    #
    # - system administrators can set it independently from the webserver
    #   configuration via SetEnv and friends.
    # - this setting is deployment dependent should not affect a development
    #   server for the same instance or a development shell
    for key in 'pool_size', 'pool_recycle', 'pool_timeout':
        value = os.environ.get("PYCLANSPHERE_" + key.upper())
        if value is not None:
            options[key] = int(value)

    # if debugging is enabled, hook the ConnectionDebugProxy in
    if debug:
        options['proxy'] = ConnectionDebugProxy()

    return sqlalchemy.create_engine(info, **options)

def insert_param_url_query_str(url_query_string, param_name, param_val):
    """
    Given an url query string this function:
    appends a new instance of param_name containing param_val (it doesn't remove existing ones)
    """
    if not param_name or not param_val:
        return url_query_string
    query_params = url_decode(url_query_string)
    query_params.update({param_name:param_val})
    return url_encode(query_params)

    def __call__(self, environ, start_response):
        if self.query_param in environ.get('QUERY_STRING', ''):
            args = url_decode(environ['QUERY_STRING'])
            method = args.get(self.query_param)

            if method and method in self.VALID_METHODS:
                method = method.encode('ascii', 'replace')
                environ['REQUEST_METHOD'] = method

        return self.app(environ, start_response)

def keep_query(*args, **kw):
    if not args and not kw:
        args = ('*',)
    params = kw.copy()
    query_params = frozenset(werkzeug.url_decode(request.httprequest.query_string).keys())
    for keep_param in args:
        for param in fnmatch.filter(query_params, keep_param):
            if param not in params and param in request.params:
                params[param] = request.params[param]
    return werkzeug.urls.url_encode(params)

    def report_download(self, data, token):
        """This function is used by 'qwebactionmanager.js' in order to trigger the download of
        a pdf/controller report.

        :param data: a javascript array JSON.stringified containg report internal url ([0]) and
        type [1]
        :returns: Response with a filetoken cookie and an attachment header
        """
        requestcontent = simplejson.loads(data)
        url, type = requestcontent[0], requestcontent[1]
        try:
            if type == 'qweb-pdf':
                reportname = url.split('/report/pdf/')[1].split('?')[0]

                docids = None
                if '/' in reportname:
                    reportname, docids = reportname.split('/')

                if docids:
                    # Generic report:
                    response = super(Extension, self).report_routes(reportname, docids=docids, converter='pdf')
                    # response = self.report_routes(reportname, docids=docids, converter='pdf')
                    ##### FIX START: switch reportname with the evaluated attachment attribute of the action if available
                    docids = [int(i) for i in docids.split(',')]
                    report_obj = request.registry['report']
                    cr, uid, context = request.cr, request.uid, request.context
                    report = report_obj._get_report_from_name(cr, uid, reportname)
                    obj = report_obj.pool[report.model].browse(cr, uid, docids[0])
                    if hasattr(obj, 'name') and obj.name:
                        reportname = obj.name
                    ##### FIX END
                else:
                    # Particular report:
                    data = url_decode(url.split('?')[1]).items()  # decoding the args represented in JSON
                    response = super(Extension, self).report_routes(reportname, converter='pdf', **dict(data))
                    # response = self.report_routes(reportname, converter='pdf', **dict(data))

                response.headers.add('Content-Disposition', 'attachment; filename=%s.pdf;' % reportname)
                response.set_cookie('fileToken', token)
                return response
            elif type =='controller':
                reqheaders = Headers(request.httprequest.headers)
                response = Client(request.httprequest.app, BaseResponse).get(url, headers=reqheaders, follow_redirects=True)
                response.set_cookie('fileToken', token)
                return response
            else:
                return
        except Exception, e:
            se = _serialize_exception(e)
            error = {
                'code': 200,
                'message': "Odoo Server Error",
                'data': se
            }
            return request.make_response(html_escape(simplejson.dumps(error)))

def parse_response(resp, content, strict=False):
    ct, options = parse_options_header(resp['content-type'])
    if ct in ('application/json', 'text/javascript'):
        return json.loads(content)
    elif ct in ('application/xml', 'text/xml'):
        return get_etree().fromstring(content)
    elif ct != 'application/x-www-form-urlencoded':
        if strict:
            return content
    charset = options.get('charset', 'utf-8')
    return url_decode(content, charset=charset).to_dict()

def url_del(url=None, *args, **kwargs):
    scheme, netloc, path, query, fragments = urlsplit(url or request.url)
    params = url_decode(query)
    for key in args:
        params.poplist(key)
    for key, value in kwargs.items():
        lst = params.poplist(key)
        if unicode(value) in lst:
            lst.remove(unicode(value))
        params.setlist(key, lst)
    return Markup(urlunsplit((scheme, netloc, path, url_encode(params), fragments)))