def item_create(form):
    record = db(db.geo_item.f_name == request.vars.f_name).select().first()
    if record.f_qrcode == None:
        arg = str(record.id)
        path = 'http://siri.pythonanywhere.com/byui_art/default/item_details?itemId=' + arg + '&qr=True'
        tiny = ""
        shortSuccess = False
        try:
            shortener = Shortener('Tinyurl')
            tiny = "{}".format(shortener.short(path))
            session.tinyCreateException = tiny
            shortSuccess = True
        except:
            session.tinyCreateException = "There was a problem with the url shortener. Please try again."

        if shortSuccess:
            code = qrcode.make(tiny)
        else:
            code = qrcode.make(path)
        qrName='geo_item.f_qrcode.%s.jpg' % (uuid.uuid4())
        code.save(request.folder + 'uploads/qrcodes/' + qrName, 'JPEG')
        record.update_record(f_qrcode=qrName)
        qr_text(qrName, record.f_name, record.f_alt5, tiny)
    try:
        imgPath = request.folder + 'uploads/' + record.f_image
        thumbName = 'geo_item.f_thumb.%s.%s.jpg' % (uuid.uuid4(), record.id)
        thumb = Image.open(request.folder + 'uploads/' + record.f_image)
        thumb.thumbnail((350, 10000), Image.ANTIALIAS)
        thumb.save(request.folder + 'uploads/thumbs/' + thumbName, 'JPEG')
        record.update_record(f_thumb=thumbName)
    except:
        session.itemCreateException = "there was a problem updating the image in item_create: " + record.f_name
    return dict()

def make_qr(src_text):
  img = None
  if len(src_text) < 1024:
    img = qrcode.make( src_text )
  else:
    img = qrcode.make("too long keyword")
  return img

def get_state(**kwargs):
    eppn = mock_auth.authenticate(kwargs)
    current_app.logger.debug('Getting state for user with eppn {}.'.format(eppn))
    proofing_state = current_app.proofing_statedb.get_state_by_eppn(eppn, raise_on_missing=False)
    if not proofing_state:
        current_app.logger.debug('No proofing state found, initializing new proofing flow.'.format(eppn))
        state = get_unique_hash()
        nonce = get_unique_hash()
        token = get_unique_hash()
        proofing_state = OidcProofingState({'eduPersonPrincipalName': eppn, 'state': state, 'nonce': nonce,
                                            'token': token})
        claims_request = ClaimsRequest(userinfo=Claims(identity=None, vetting_time=None, metadata=None))
        # Initiate proofing
        response = do_authentication_request(state, nonce, token, claims_request)
        if response.status_code != 200:
            payload = {'error': response.reason, 'message': response.content}
            raise ApiException(status_code=response.status_code, payload=payload)
        # If authentication request went well save user state
        current_app.proofing_statedb.save(proofing_state)
        current_app.logger.debug('Proofing state {} for user {} saved'.format(proofing_state.state, eppn))
    # Return nonce and nonce as qr code
    current_app.logger.debug('Returning nonce for user {}'.format(eppn))
    buf = BytesIO()
    qr_code = '1' + json.dumps({'nonce': proofing_state.nonce, 'token': proofing_state.token})
    qrcode.make(qr_code).save(buf)
    qr_b64 = base64.b64encode(buf.getvalue()).decode()
    ret = {
        'qr_code': qr_code,
        'qr_img': '<img src="data:image/png;base64, {}"/>'.format(qr_b64),
    }
    return ret

def generate_QRcodes():
    for i in range(1, len(checkpoints) + 1):
        img = qrcode.make('%s/item/%s' %(config['base_url'],
            uuid_str(i)))
        img.save('checkpoint_%d.png' %(i))
    img = qrcode.make('%s/start' % (config['base_url']))
    img.save('start.png')

def generate(data):
    md5sum = md5(data).hexdigest()
    filename = '%s.png' % md5sum
    filepath = os.path.join(files_path, filename)
    if not os.path.exists(filepath):
        qrcode.make(data).save(open(filepath, 'wb'))
    return (filename, md5sum)

def main():

    if common.debug:
        print "BEGIN offline_sign_tx"

    qrcode_tx_to_sign = Popen(["zbarimg", "--quiet", "images/raw_tx_to_sign.png"], stdout=PIPE).stdout.read()
    tx_to_sign = common.get_qrcode_val_from_str(qrcode_tx_to_sign).split(",")

    unspent_tx_output_details = [{"txid": str(tx_to_sign[1]),
                                  "vout": int(tx_to_sign[2]),
                                  "scriptPubKey": str(tx_to_sign[3])}]

    if common.debug:
        print "raw tx data read from qrcode"

    offline_sign_raw_tx = common.request(common_offline.off_url,
                                         {'method': 'signrawtransaction',
                                        'params': [tx_to_sign[0], unspent_tx_output_details]})

    if not offline_sign_raw_tx["result"]["complete"]:
        print "ERROR! tx signing incomplete!"
        print offline_sign_raw_tx
        sys.exit(1)

    if common.debug:
        print "signed tx offline: " + str(offline_sign_raw_tx)

    qrcode.make(offline_sign_raw_tx["result"]["hex"]).save('images/offline_signed_tx.png')

    if common.debug:
        print "signed offline transaction and saved qrcode: offline_signed_tx.png"
        print "END offline_sign_tx"

 def _genBarcode(self, content):
     md5 = hashlib.md5(bytes(content, 'utf-8')).hexdigest()
     path = os.path.join(PKG_DIR, 'images', 'qrcodes', '{}.png'.format(md5))
     # 是否存在这个md5文件，如果有直接返回结果，如果没有则生成
     if os.path.isfile(path):
         return path
     qrcode.make(content).save(path)
     return path

def vote_qr_code(vote):
    if vote not in votes_config:
        return None
    out = StringIO.StringIO()
    qrcode.make('bitcoin:%s?amount=%s&label=%s' % (votes_config[vote]['address'], votes_config[vote]['ammount'], votes_config[vote]['label'])).save(out)
    resp = make_response(out.getvalue())
    resp.content_type = 'image/png'
    return resp

def qr(uid, task, filetype, tempfile=False):
    endpoint = ".download_temp" if tempfile else ".download"
    url = url_for(endpoint, uid=uid, taskname=task, filetype=filetype, _external=True)

    img = StringIO()
    qrcode.make(url, box_size=3).save(img)
    img.seek(0)

    return send_file(img, mimetype="image/png")

def make_qrcode_base64(text):
    # Create a temporary placeholder to the image
    with BytesIO() as stream:
        # Generate the qrcode and save to the stream
        qrcode.make(text).save(stream)

        # Get the image bytes, then encode to base64
        image_data = b64encode(stream.getvalue())

    return image_data

def qrc(data):
    import cStringIO
    import qrcode
    import qrcode.image.svg

    out = cStringIO.StringIO()
    qrcode.make(data, image_factory=qrcode.image.svg.SvgPathImage).save(out)
    qrsvg = out.getvalue()

    return re.search('d="(.*?)"', qrsvg).group(1)

def main():
    if common.debug:
        print "BEGIN offline_create_address"

    offline_address1 = common.request(common_offline.off_url, {'method': 'getnewaddress'})["result"]
    qrcode.make(offline_address1).save("images/offline_address1.png")
    offline_address2 = common.request(common_offline.off_url, {'method': 'getnewaddress'})["result"]
    qrcode.make(offline_address2).save("images/offline_address2.png")

    if common.debug:
        print "offline address1: " + offline_address1
        print "offline address2: " + offline_address2
        print "offline addresses saved to qrcode"
        print "END offline_create_address"

def get_state(**kwargs):
    # TODO: Authenticate user authn response:
    # TODO: Look up user in central db
    eppn = mock_auth.authenticate(kwargs)
    current_app.logger.debug('Getting state for user with eppn {!s}.'.format(eppn))
    proofing_state = current_app.proofing_statedb.get_state_by_eppn(eppn, raise_on_missing=False)
    if not proofing_state:
        current_app.logger.debug('No proofing state found, initializing new proofing flow.'.format(eppn))
        state = get_unique_hash()
        nonce = get_unique_hash()
        proofing_state = OidcProofingState({'eduPersonPrincipalName': eppn, 'state': state, 'nonce': nonce})
        # Initiate proofing
        args = {
            'client_id': current_app.oidc_client.client_id,
            'response_type': 'code id_token token',
            'response_mode': 'query',
            'scope': ['openid'],
            'redirect_uri': url_for('oidc_proofing.authorization_response', _external=True),
            'state': state,
            'nonce': nonce,
            'claims': ClaimsRequest(userinfo=Claims(identity=None)).to_json()
        }
        current_app.logger.debug('AuthenticationRequest args:')
        current_app.logger.debug(args)
        try:
            response = requests.post(current_app.oidc_client.authorization_endpoint, data=args)
        except requests.exceptions.ConnectionError as e:
            msg = 'No connection to authorization endpoint: {!s}'.format(e)
            current_app.logger.error(msg)
            raise ApiException(payload={'error': msg})
        # If authentication request went well save user state
        if response.status_code == 200:
            current_app.logger.debug('Authentication request delivered to provider {!s}'.format(
                current_app.config['PROVIDER_CONFIGURATION_INFO']['issuer']))
            current_app.proofing_statedb.save(proofing_state)
            current_app.logger.debug('Proofing state {!s} for user {!s} saved'.format(proofing_state.state, eppn))
        else:
            payload = {'error': response.reason, 'message': response.content}
            raise ApiException(status_code=response.status_code, payload=payload)
    # Return nonce and nonce as qr code
    current_app.logger.debug('Returning nonce for user {!s}'.format(eppn))
    buf = StringIO()
    qrcode.make(proofing_state.nonce).save(buf)
    qr_b64 = buf.getvalue().encode('base64')
    ret = {
        'nonce': proofing_state.nonce,
        'qr_img': '<img src="data:image/png;base64, {!s}"/>'.format(qr_b64),
    }
    return ret

    def encode(user, secret, organization, otp_type):
        """Encodes a HOTP or TOTP URL into a QR Code.

        The URL format conforms to what is expected by Google Authenticator.
        https://code.google.com/p/google-authenticator/wiki/KeyUriFormat

        Keyword arguments:
        user -- The user of the HOTP or TOTP secret
        secret -- The shared secret used to generate the TOTP value
        organization -- The issuer for the HOTP or TOTP secret
        otp_type -- The OTP type. Accepted values are hotp or totp

        Returns:
        The encoded QR Code image as a PIL Image type.

        """

        otp_types = ['hotp', 'totp']

        if otp_type not in otp_types:
            raise IncorrectOTPType()

        url = ''.join(['otpauth://', otp_type, '/', organization,
                       ':', user, '?', 'secret=', secret])

        return qrcode.make(url)

def format_element(bfo, width="100"):
    """
    Generate a QR-code image linking to the current record.

    @param width: Width of QR-code image.
    """
    if not HAS_QR:
        return ""

    width = int(width)

    bibrec_id = bfo.control_field("001")
    link = "%s/%s/%s" % (CFG_SITE_SECURE_URL, CFG_SITE_RECORD, bibrec_id)
    hash_val = _get_record_hash(link)

    filename = "%s_%s.png" % (bibrec_id, hash_val)
    filename_url = "/img/qrcodes/%s" % filename
    filename_path = os.path.join(CFG_WEBDIR, "img/qrcodes/%s" % filename)

    if not os.path.exists(filename_path):
        if not os.path.exists(os.path.dirname(filename_path)):
            os.makedirs(os.path.dirname(filename_path))

        img = qrcode.make(link)
        img._img = img._img.convert("RGBA")
        img._img = img._img.resize((width, width), Image.ANTIALIAS)
        img.save(filename_path, "PNG")

    return """<img src="%s" width="%s" />""" % (filename_url, width)

 def create_website_qrcode(self):
     storage = get_storage_class(settings.DEFAULT_FILE_STORAGE)()
     img_name = '%s-webite-qrcode.png' % self.id
     img_file = BytesIO()
     img = qrcode.make(self.website, image_factory=PymagingImage)
     img.save(img_file)
     storage.save(img_name, img_file)

def qr_code_command(bot, update, args):
    message = update.message.text

    if "-help" in args:
        bot.send_chat_action(chat_id=update.message.chat_id, action=ChatAction.TYPING)
        bot.send_message(chat_id=update.message.chat_id, text=help_command())
        return

    if len(args) == 0:
        bot.send_message(chat_id=update.message.chat_id, 
                        text="Wrong syntax. See /qrcode -help.",
                        reply_to_message_id=update.message.message_id)
        return

    # Remove "/qrcode" from the message
    message = message.split(' ', 1)[1].strip()

    # Inform that the bot will send an image
    bot.send_chat_action(chat_id=update.message.chat_id, action=ChatAction.UPLOAD_PHOTO)

    try:
        img = qrcode.make(message)

        qrcode_unique = "qrcode_" + str(update.message.message_id) + ".jpg"

        img.save(qrcode_unique)
    except:
        bot.send_message(chat_id=update.message.chat_id, 
                        text="Failed to create qrcode, try again.",
                        reply_to_message_id=update.message.message_id)
        return

    bot.send_photo(chat_id=update.message.chat_id, photo=open(qrcode_unique, 'rb'))

    os.remove(qrcode_unique)

    def handle(self, *args, **options):
        events = self.explara.get_events()
        orders = self.explara.get_orders(events[0]['eventId'])
        if not os.path.isdir(settings.QR_CODES_DIR):
            os.makedirs(settings.QR_CODES_DIR)
        for order in orders:
            for attendee in order.get('attendee', []):
                ticket_no = attendee.get('ticketId')
                defaults = {
                    'order_no': order.get('orderNo'),
                    'order_cost': order.get('orderCost'),
                    'address': order.get('address', None),
                    'city': order.get('city', None),
                    'zipcode': order.get('zipcode', None),
                    'name': attendee.get('name'),
                    'email': attendee.get('email') or order.get('email'),
                    'status': attendee.get('status'),
                    'others': order,
                }
                with transaction.atomic():
                    ticket, created = Ticket.objects.update_or_create(
                        ticket_no=ticket_no,
                        defaults=defaults
                    )

                if created:
                    qr_code = qrcode.make(ticket_no)
                    file_name = attendee.get('name') + '_' + ticket_no
                    qr_code.save('{}/{}.png'.format(settings.QR_CODES_DIR, file_name))

def remoteScanSetup(request, id):
    #TODO: Security
    
    endpoint = RemoteScanEndpoint.objects.get(pk=id)
    
    url = request.build_absolute_uri(reverse(remoteScan, kwargs={'id': endpoint.id}))
    
    data = {
        "remotescan": {
            "title": endpoint.title,
            "url": url,
            "signing_key": endpoint.auth_key,
            "code_types": ["QR"],
            "version": 1
        }
    }
    
    encodedData = json.dumps(data)
    
    img = qrcode.make(encodedData, image_factory=qrcode.image.svg.SvgPathImage, box_size=20)
    
    out = BytesIO()
    img.save(out)
    out.seek(0)
    
    return HttpResponse(out.read(), content_type="image/svg+xml")    

    def qrgen(self, url):
        """Generation du qrcode pour l'url"""
        qrc = qrcode.make(url, version = 5, error_correction = qrcode.constants.ERROR_CORRECT_H)
        file_name = self.keygen(12)
        qrc.save('tmp/' + file_name + '.png')

        return file_name