def qrcode_view(request, code, size, size_in_centimeters=False):
if size_in_centimeters:
size = int(size)
if size <= 6:
size = NORMAL_SIZE
elif size <= 8:
size = LARGE_SIZE
else:
size = VERY_LARGE_SIZE
qr = QRCode(
error_correction=LEVEL[size],
box_size=SIZE[size],
border=0,
)
else:
qr = QRCode(
error_correction=LEVEL[size],
box_size=SIZE[size],
border=0,
)
qr.add_data(code)
img = qr.make_image()
rsp = HttpResponse(content_type='image/png')
img.save(rsp)
return rsp
def create_qr(data, z=None):
box_size = int(z) < 15 and int(z) or 10
meta = PngImagePlugin.PngInfo()
filehash = sha1(data.encode('ascii', 'ignore')).hexdigest()[:12]
filepath = os.path.join(app.config['UPLOAD_FOLDER'], filehash+'.png')
data = data.encode('utf8')
meta.add_text('message', data)
if not os.path.exists(filepath):
qr = QRCode(
version=4,
border=4,
box_size=box_size,
)
qr.add_data(data)
img = qr.make_image()
img.save(filepath, 'png', pnginfo=meta)
else :
img = file(filepath)
return (img, filepath, filehash)
def test_qr_library_equivalence(self):
"""
The `get_matrix` method of the uQR library should produce
identical output to that of the QRCode library.
"""
macro_qr = MacroQRCode()
macro_qr.add_data('uQR rocks!')
macro_matrix = macro_qr.get_matrix()
micro_qr = MicroQRCode()
micro_qr.add_data('uQR rocks!')
micro_matrix = micro_qr.get_matrix()
# The generated matrix should actually contains rows.
self.assertGreater(len(micro_matrix), 0)
# The uQR matrix should have the same number of rows as the
# QRCode matrix
self.assertEqual(len(micro_matrix), len(macro_matrix))
for micro_row, macro_row in zip(micro_matrix, macro_matrix):
# The row should actually contain data.
self.assertGreater(len(micro_row), 0)
# The two rows from the two libraries should be identical
self.assertEqual(len(micro_row), len(macro_row))
def makeQRCode(data, mode):
""" Make a graphical representation of a QRCODE in unicode."""
sio = StringIO()
qr_code = QRCode()
qr_code.add_data(data)
qr_code.print_ascii(out=sio, invert=mode == 'text')
return '\n'.join(line.lstrip() for line in sio.getvalue().split('\n'))
def gen_qrcode(name, data):
fp = open(name, 'w')
gen = QRCode()
gen.add_data(data)
img = gen.make_image()
io = StringIO()
img.save(fp)
fp.close()
def __init__(self, box_size: int = 10, border: int = 4) -> None:
self.logger = logging.getLogger(__name__)
self.qr = QRCode(
error_correction=ERROR_CORRECT_L,
box_size=box_size,
border=border,
image_factory=SvgFragmentImage,
)
def on_change_with_totp_qrcode(self, name=None):
url = self.on_change_with_totp_url()
if not url or not QRCode:
return
data = BytesIO()
qr = QRCode(image_factory=PilImage)
qr.add_data(url)
image = qr.make_image()
image.save(data)
return data.getvalue()
class X4QRCode(object):
def __init__(self, w, h, message, **kwargs):
self.qrc = QRCode()#w, h, **kwargs)
self.qrc.add_data(message)
def getPngImage(self, w, h, fgcol, bgcol):
w = int(w)
h = int(h)
return self.qrc.make_image()
def qr_encode(request):
data = request.GET.get('data', '')
qrc = QRCode(
box_size=20,
image_factory=SvgPathFillImage,
)
qrc.add_data(data)
img = qrc.make_image()
strio = StringIO()
img.save(strio)
res = strio.getvalue()
strio.close()
return HttpResponse(res, content_type='image/svg+xml')
def get(self):
self.set_header(r'Content-Type', r'image/png')
stream = BytesIO()
code = QRCode()
code.add_data(self.get_argument(r'data', r''))
code.make_image().save(stream)
return self.finish(stream.getvalue())
def main():
config_parser = ConfigParser()
config_parser.read(CONFIG_FILE)
config = config_parser['Main']
api = QcosApi(config['api_url'])
ticket_width = int(config['ticket_width'])
ticket_height = int(config['ticket_height'])
while True:
ticket = api.get_printable_ticket()
if ticket is not None:
print(ticket)
ticket_info = api.get_ticket_info(ticket['ticket_info'])
print(ticket_info)
fee = api.get_fee(ticket_info['fee'])
print(fee)
camp = api.get_camp(fee['camp'])
print(camp)
registration = api.get_registration(ticket_info['registration'])
print(registration)
clan = api.get_clan(registration['clan'])
print(clan)
ticket_image = Image.new('RGB', (ticket_width, ticket_height),
color=(255, 255, 255))
ticket_draw = ImageDraw.Draw(ticket_image)
pos = draw_text(ticket_draw, camp['name'], (10, 0), ticket_width,
ticket_height * 0.25)
pos = draw_text(ticket_draw, clan['name'], (10, pos[1]),
ticket_width, ticket_height * 0.1)
pos = draw_text(ticket_draw, fee['name'], (10, pos[1]),
ticket_width, ticket_height * 0.1)
draw_text(ticket_draw, ticket['guid'], (10, pos[1]), ticket_width,
ticket_height * 0.05)
qr = QRCode(version=1,
error_correction=ERROR_CORRECT_M,
box_size=10,
border=4)
qr.add_data(ticket['guid'])
qr_img = qr.make_image(fill_color="black", bakc_color="white")
ticket_image.paste(qr_img, (10, int(ticket_height / 2)))
ticket_image.save(config['temp_file'])
qlr = BrotherQLRaster(config['model'])
create_label(qlr, "test.png", '62')
with open(config['printer_path'], 'wb') as file:
file.write(qlr.data)
api.mark_ticket_printed(ticket)
sleep(2)
def totp_setup(session, client_id, username, password):
response = cognito_client.associate_software_token(Session=session)
secret = response['SecretCode']
qr_uri = f'otpauth://totp/Cognito:{username}?secret={secret}&issuer=Cognito'
qr = QRCode()
qr.add_data(qr_uri)
qr.make(fit=True)
qr.print_ascii()
user_code = input('Scan the QR code, then input the TOTP: ')
response = cognito_client.verify_software_token(
Session=response['Session'], UserCode=user_code)
if response['Status'] != 'SUCCESS':
print(f'Failed to verify MFA: {json.dumps(auth_response)}')
sys.exit(1)
token_response = auth_req(client_id, username, password)
cognito_client.set_user_mfa_preference(
SoftwareTokenMfaSettings={
'Enabled': True,
'PreferredMfa': True
},
AccessToken=token_response['AuthenticationResult']['AccessToken'])
return token_response
def GenCode(self,uid):
data = 'http://'+ServerURL+'/tools/static/query.html?id='+uid
#print data
from qrcode import QRCode
from StringIO import StringIO
gen = QRCode()
gen.add_data(data)
img = gen.make_image()
io = StringIO()
img.save(io)
io.seek(0)
#image = QImage()
self.image.loadFromData(io.read())
def getQRCodePage( urlPage ):
qr = QRCode()
qr.add_data( urlPage )
qr.make()
qrcode = '["' + '",\n"'.join(
[''.join( '1' if v else '0' for v in qr.modules[row] ) for row in six.moves.range(qr.modules_count)]
) + '"]'
result = StringIO()
def w( s ):
result.write( s )
result.write( '\n' )
w( '<html>' )
w( '<head>' )
w( '''<style type="text/css">
body {
font-family: sans-serif;
text-align: center;
}
</style>''' )
w( '''<script>
function Draw() {
var qrcode={qrcode};
var c = document.getElementById("idqrcode");
var ctx = c.getContext("2d");
ctx.fillStyle = '#000';
var s = Math.floor( c.width / qrcode.length );
for( var y = 0; y < qrcode.length; ++y ) {
var row = qrcode[y];
for( var x = 0; x < row.length; ++x ) {
if( row.charAt(x) == '1' )
ctx.fillRect( x*s, y*s, s, s );
}
}
}
'''.replace('{qrcode}', qrcode) )
w( '</script>' )
w( '</head>' )
w( '<body onload="Draw();">' )
w( '<h1 style="margin-top: 32px;">Share Race Results</h1>' )
w( '<canvas id="idqrcode" width="360" height="360"></canvas>' )
w( '<h2>Scan the QRCode.<br/>Follow it to the Race Results page.</h2>' )
w( '<h2>{}</h2>'.format(urlPage) )
w( 'Powered by <a href="http://www.sites.google.com/site/crossmgrsoftware">CrossMgr</a>.' )
w( '</body>' )
w( '</html>' )
return result.getvalue().encode()
def main():
if len(argv) < 3:
print 'Format: enc.py <identifier> <message>'
return
ID = argv[1] # Identifier of origin
MESSAGE = argv[2]
# Read private key of origin
with open(ID + '.pr', 'r') as f:
privatekey = PrivateKey.load_pkcs1(f.read())
# Sign message with private key
SIGN = sign(MESSAGE, privatekey, 'SHA-256').encode('hex')
# Concatenate message, signature and identifier
TEXT = padding(MESSAGE, 100) + padding(SIGN, 400) + padding(ID, 100)
# Create QR code
qr = QRCode(
version=1,
error_correction=ERROR_CORRECT_L,
box_size=10,
border=4,
)
qr.add_data(TEXT)
qr.make(fit=True)
img = qr.make_image()
img.save(ID + '.png')
def versao_full(self, nome_img='qr_complexo'):
nome_img += '.png'
qr = QRCode(version=20, error_correction=ERROR_CORRECT_L)
qr.add_data(self.__msg)
qr.make()
im = qr.make_image()
im.save(self.__caminho_img + nome_img)
def create_qrcode(self, username):
"""
创建二维码，用于google auth扫码
:param username: 用户名字
:return:
"""
'''二维码保存位置'''
filepath = Base_DIR + '/static/google_auth/'
# 根据username获取secert_key
secret_key = auth_orm.get_user_secret_key(username)
data = pyotp.totp.TOTP(secret_key).provisioning_uri(
username, issuer_name='YangHongFeiTest')
qr = QRCode(version=1,
error_correction=constants.ERROR_CORRECT_L,
box_size=6,
border=4)
try:
qr.add_data(data)
qr.make(fit=True)
img = qr.make_image()
print('QRCode Path:', filepath + username + '.png')
img.save(filepath + username + '.png')
return type
except Exception as e:
print(e)
def register():
if request.method == 'POST':
print 'Username: '******'Username']
print 'Password: '******'Password']
# Connect to database
db = sqlite3.connect('google_authenticator.db')
cursor = db.cursor()
# Create secret and add user to database
secret = base64.b32encode(os.urandom(10)).decode('utf-8')
query = 'INSERT INTO USERS (USER, PASSWORD, GOOGLEAUTH) VALUES (\"' + request.form['Username'] + '\",\"' + request.form['Password'] + '\",\"' + secret + '\");'
cursor.execute(query)
db.commit()
db.close()
# Create unique QR code given secret, label, and issuer
auth = OtpAuth(secret)
secret_uri = auth.to_uri('totp', GALabel, GAIssuer)
qr = QRCode()
qr.add_data(secret_uri)
qr.make()
img = qr.make_image()
#img.show() # Opens tmp QR code image
print 'Secret: ', secret
print 'Secret Uri: ', secret_uri
# Display QR code in web browser
return redirect(getQRCodeGoogleUrl(secret_uri))
return "Nothing to see here."
def get_qrcode(user):
if not user.qrcode:
user.qrcode = pyotp.random_base32()
user.save()
file_name = str(aes.encrypt(user.qrcode), encoding='utf-8')
file = settings.QCODE_ROOT + '/' + file_name + '.png'
if not os.path.exists(file):
data = pyotp.totp.TOTP(user.qrcode).provisioning_uri(
user.username, issuer_name="devEops")
qr = QRCode(
version=1,
error_correction=constants.ERROR_CORRECT_L,
box_size=6,
border=4,
)
try:
qr.add_data(data)
qr.make(fit=True)
img = qr.make_image()
img.save(file)
return '/media/qrcode/' + file_name + '.png'
except Exception as e:
return '/media/qrcode/' + file_name + '.png'
else:
return '/media/qrcode/' + file_name + '.png'
def parse_add(datafile, event_id):
csvFile = open(datafile)
fileData = reader(csvFile, delimiter=';', quotechar='|')
for row in fileData:
user = User()
user.first_name = row[0]
user.last_name = row[1]
user.email = row[2]
user.college_name = row[3]
user.qr_data = sha1(user.email).hexdigest()
#qr = QRCode(version=10, error_correction=ERROR_CORRECT_H)
qr = QRCode(version=6,
border=4,
box_size=5,
error_correction=ERROR_CORRECT_Q)
qr.add_data(user.qr_data)
qr.make() # Generate the QRCode itself
#im contains a PIL.Image.Image object
im = qr.make_image()
# To save it
im.save("qr.png")
#db_session.add(user)
sendmail(user.email)
db.session.add(user)
db.session.commit()
eu = EventUsers(event_id, user.id)
db.session.add(eu)
db.session.commit()
def _generate(
cls,
text: str,
*,
size: int = 200,
level: QRCodeLevel = QRCodeLevel.M,
icon_stream: Optional[BytesIO] = None,
bgcolor: str = "#FFFFFF",
fgcolor: str = "#000000",
) -> Path:
qr = QRCode(
error_correction={
QRCodeLevel.L: constants.ERROR_CORRECT_L,
QRCodeLevel.M: constants.ERROR_CORRECT_M,
QRCodeLevel.Q: constants.ERROR_CORRECT_Q,
QRCodeLevel.H: constants.ERROR_CORRECT_H,
}[level],
border=2,
box_size=8,
)
qr.add_data(text)
image: Image.Image = qr.make_image(
PilImage,
back_color=bgcolor,
fill_color=fgcolor,
).get_image() # type:ignore
image = image.resize((size, size))
if icon_stream is not None:
try:
icon = Image.open(icon_stream)
except ValueError:
raise ClientSideException("Invalid image format.")
icon_width, icon_height = icon.size
image.paste(
icon,
box=(
int(size / 2 - icon_width / 2),
int(size / 2 - icon_height / 2),
int(size / 2 + icon_width / 2),
int(size / 2 + icon_height / 2),
),
mask=icon if icon.mode == "RGBA" else None,
)
image.save(file := TempFile.create(ext=".png"))
return file
def register():
form = RegistrationForm(request.form)
if request.method == 'POST' and form.validate_on_submit():
#user = User(form.first_name.data, form.last_name.data, form.username.data,
# form.username.data, form.email.data, form.enrollment.data,
# form.college_name.data)
user = User()
form.populate_obj(user)
#user.password = generate_password_hash(user.password)
user.qr_data = sha1(user.email).hexdigest()
qr = QRCode(version=10, error_correction=ERROR_CORRECT_H)
qr.add_data(user.qr_data)
qr.make() # Generate the QRCode itself
#im contains a PIL.Image.Image object
im = qr.make_image()
# To save it
im.save("qr.png")
#db_session.add(user)
sendmail(user.email)
db.session.add(user)
db.session.commit()
return render_template('register.html', isreg=True)
return render_template('register.html', form=form, isreg=False)
def encode(self, data: bytearray) -> Image:
"""
Encode a bytearray into a ChromaQR code.
Returns a PIL Image which can be saved with `.save("filename.png")`.
"""
codes = []
section_length = math.ceil(len(data) / 3)
split_data = [
data[0:section_length], data[section_length:section_length * 2],
data[section_length * 2:]
]
error_correction_map = {
ErrorCorrection.LOW: constants.ERROR_CORRECT_L,
ErrorCorrection.MED: constants.ERROR_CORRECT_M,
ErrorCorrection.HIGH: constants.ERROR_CORRECT_Q,
ErrorCorrection.MAX: constants.ERROR_CORRECT_H
}
target_version = -1
for i in range(3):
qr_code = QRCode(
version=target_version if i > 0 else None,
error_correction=error_correction_map[self.error_correction])
qr_code.add_data(split_data[i], optimize=0)
qr_code.make()
if i == 0: target_version = qr_code.version
qr_code_image = qr_code.make_image(fill_color="black",
back_color="white")
codes.append(qr_code_image.convert("L"))
return Image.merge("RGB", codes)
def gen_qrcode(self, username, issuer_name="IAM MFA Code"):
data = pyotp.totp.TOTP(self.secret_key).provisioning_uri(username, issuer_name)
qr = QRCode(
version=1,
error_correction=constants.ERROR_CORRECT_L,
box_size=6,
border=4, )
try:
qr.add_data(data)
qr.make(fit=True)
img = qr.make_image()
if settings.KEEP_QR_FILE is True:
self.img_file = self.dirpath + os.sep + self.secret_key + '.png'
img.save(self.img_file) # 保存条形码图片
else:
self.img_file = None
buf = io.BytesIO()
img.save(buf, format='PNG') # 保存成字符串
image_stream = buf.getvalue()
heximage = base64.b64encode(image_stream)
self.img_str = 'data:image/png;base64,' + heximage.decode()
return True
except Exception as e:
traceback.print_exc()
return False
def as_qrcode(self,
error_correction=ERROR_CORRECT_M,
box_size=5,
border=2,
fill_color="black",
back_color="white"):
"""
:param error_correction:
:param box_size:
:param border:
:param fill_color:
:param back_color:
:return:
"""
qr = QRCode(
error_correction=error_correction,
box_size=box_size,
border=border,
)
qr.add_data(self.as_vcard())
qr.make(fit=True)
# make QR Code, removing from PIL and convert into Bytestring
with BytesIO() as f:
img = qr.make_image(fill_color=fill_color, back_color=back_color)
img.save(f)
f.seek(0)
bytes = f.getvalue()
return bytes
def qrcode_view(request, code, size, size_in_centimeters=False):
if size_in_centimeters:
size = int(size)
if size <= 6:
size = NORMAL_SIZE
elif size <= 8:
size = LARGE_SIZE
else:
size = VERY_LARGE_SIZE
qr = QRCode(
error_correction=LEVEL[size],
box_size=SIZE[size],
border=0,
)
else:
qr = QRCode(
error_correction=LEVEL[size],
box_size=SIZE[size],
border=0,
)
qr.add_data(code)
img = qr.make_image()
rsp = HttpResponse(content_type='image/png')
img.save(rsp)
return rsp
def create_pix_payment_qrcode(self, account_id: str, amount: float,
pix_key: dict) -> dict:
payload = {
'createPaymentRequestInput': {
'amount': amount,
'pixAlias': pix_key.get('value'),
"savingsAccountId": account_id
}
}
response = self._make_graphql_request('create_pix_money_request',
payload)
data = response['data']['createPaymentRequest']['paymentRequest']
qr = QRCode()
qr.add_data(data['brcode'])
return {'payment_url': data['url'], 'qr_code': qr}
def _showQRCodeImg(self, str):
if self.commandLineQRCode:
qrCode = QRCode('https://login.weixin.qq.com/l/' + self.uuid)
self._showCommandLineQRCode(qrCode.text(1))
else:
url = 'https://login.weixin.qq.com/qrcode/' + self.uuid
params = {'t': 'webwx', '_': int(time.time())}
data = self._post(url, params, False)
if data == '':
return
QRCODE_PATH = self._saveFile('qrcode.jpg', data, '_showQRCodeImg')
if str == 'win':
os.startfile(QRCODE_PATH)
elif str == 'macos':
subprocess.call(["open", QRCODE_PATH])
else:
return
def generate_qrcode(self, product_id="", url='weixin://wxpay/bizpayurl'):
kwargs = {}
kwargs.update({
'appid': self.appid,
'mch_id': self.mch_id,
'time_stamp': str(int(time())),
'nonce_str': uuid4().hex,
'product_id': product_id,
})
kwargs.update({'sign': self.generate_sign(kwargs)})
scheme, netloc, path, params, query, fragment = urlparse.urlparse(url)
query = urllib.urlencode(kwargs)
url = urlparse.urlunparse((scheme, netloc, path,
params, query, fragment))
qr = QRCode(version=1)
logger.debug(url)
qr.add_data(url)
return qr.make_image()
def show_qr_code(image_file):
from pyzbar import pyzbar
from qrcode import QRCode
from PIL import Image
qr = QRCode()
results = pyzbar.decode(Image.open(image_file),
symbols=[pyzbar.ZBarSymbol.QRCODE])
qr_data = results[0].data
qr.add_data(qr_data)
qr.print_ascii()
qr.clear()
def gen_qrcode(filename,qrdata):
fp = open(filename, 'w')
#564be177d52c9e7a68b2c83d
gen = QRCode()
gen.add_data(qrdata)
img = gen.make_image()
io = StringIO()
#img.save(io)
img.save(fp)
#img.show()
#io.seek(0)
#response = make_response(io.read())
#response.headers['content-Type'] = 'image/jpeg'
fp.close()
class QRCoder:
def __init__(self, box_size: int = 10, border: int = 4) -> None:
self.logger = logging.getLogger(__name__)
self.qr = QRCode(
error_correction=ERROR_CORRECT_L,
box_size=box_size,
border=border,
image_factory=SvgFragmentImage,
)
def generate_inline_svg(self, text: str) -> str:
self.qr.add_data(text)
qrcode = self.qr.make_image().get_image()
inline_svg = ET.tostring(qrcode)
self.qr.clear()
return inline_svg
def create_qrcode(params):
qr = QRCode(error_correction=ERROR_CORRECT_H, box_size=params.size, border=params.border)
qr.add_data(params.content)
qr.make()
output = params.output
img = qr.make_image(fill_color=params.background, back_color=params.foreground)
img.save(output)
print('Created file: {}'.format(output))
def render_qr(data, marker, html):
qr = QRCode(box_size=5, border=2)
qr.add_data(data)
qr.make(fit=True)
img = qr.make_image(fill_color="black", back_color="white")
buf = BytesIO()
img.save(buf)
tag = 'data:image/png;base64,' + encodebytes(buf.getvalue()).decode()
return html.replace(marker, tag)
def print_qr_code(uuid: str):
qr = QRCode()
qr.add_data(uuid)
try:
get_ipython
from IPython.display import display
display(qr.make_image(fill_color="#111", back_color="#ccc"))
except NameError:
qr.print_ascii(invert=True)
def store_to_qr(filename, output_filename, remark, error_correction, compress):
para = textwrap.wrap(remark, width=100)
print('Convert file to paper, output to', output_filename)
with open(filename, 'rb') as f:
content = f.read()
slices = file_to_slice(os.path.basename(filename), content, error_correction, compress)
page_count = ceil(len(slices) / IMAGE_PER_PAGE)
qr_counter = 0
print('Generating PDF,', page_count, 'pages in total')
page_images = list()
temp_files = list()
for i in range(page_count):
page_image = Image.new('1', PAGE_SIZE, color='white')
text_draw = ImageDraw.Draw(page_image)
font = ImageFont.truetype('arial.ttf', REMARK_FONT_SIZE)
text_draw.text(FOOTER_TEXT_START_COORD, os.path.basename(filename), font=font)
text_draw.text((FOOTER_TEXT_START_COORD[0], FOOTER_TEXT_START_COORD[1] + REMARK_FONT_SIZE),
'Page {}/{}'.format(i + 1, page_count), font=font)
for n, line in enumerate(para):
text_draw.text((REMARK_TEXT_START_COORD[0], REMARK_TEXT_START_COORD[1] + REMARK_FONT_SIZE * n), line,
font=font)
for j in range(min(IMAGE_PER_PAGE, len(slices) - IMAGE_PER_PAGE * i)):
qr = QRCode(error_correction=error_correction, box_size=10, border=0)
qr.add_data(slices[i * IMAGE_PER_PAGE + j].serialize())
extended_qr_image = Image.new('1', (IMAGE_SIZE[0], IMAGE_SIZE[1] + IMAGE_TEXT_AREA_HEIGHT),
color='white')
qr_image = qr.make_image()
qr_image = qr_image.resize(IMAGE_SIZE)
extended_qr_image.paste(qr_image)
qr_text_draw = ImageDraw.Draw(extended_qr_image)
qr_text_draw.text((10, IMAGE_SIZE[1]), '{}/{}'.format(qr_counter + 1, len(slices)), font=font)
page_image.paste(extended_qr_image, PAGE_IMAGE_COORD[j])
qr_counter += 1
page_images.append(page_image)
temp_file = TemporaryFile(suffix='.png')
page_image.save(temp_file, format='PNG')
temp_file.seek(0)
temp_files.append(temp_file)
with open(output_filename, 'wb') as f:
img2pdf.convert(temp_files, outputstream=f)
def generate_qrcode(data: str, path: str) -> None:
qr: QRCode = QRCode(
version=1,
error_correction=qrcode.constants.ERROR_CORRECT_L,
box_size=10,
border=4,
)
qr.add_data(data)
qr.make(fit=True)
img: PilImage = qr.make_image(fill_color="black", back_color="white")
img.save(path)
def register():
form = RegistrationForm(request.form)
if request.method == 'POST' and form.validate_on_submit():
#user = User(form.first_name.data, form.last_name.data, form.username.data,
# form.username.data, form.email.data, form.enrollment.data,
# form.college_name.data)
user = User()
form.populate_obj(user)
#user.password = generate_password_hash(user.password)
user.qr_data = sha1(user.email).hexdigest()
qr = QRCode(version=10, error_correction=ERROR_CORRECT_H)
qr.add_data(user.qr_data)
qr.make() # Generate the QRCode itself
#im contains a PIL.Image.Image object
im = qr.make_image()
# To save it
im.save("qr.png")
#db_session.add(user)
sendmail(user.email)
db.session.add(user)
db.session.commit()
return render_template('register.html',isreg=True)
return render_template('register.html', form=form, isreg=False)
async def generate_invitation(
self,
use_did_exchange: bool,
auto_accept: bool = True,
display_qr: bool = False,
wait: bool = False,
):
self._connection_ready = asyncio.Future()
with log_timer("Generate invitation duration:"):
# Generate an invitation
log_status(
"#7 Create a connection to alice and print out the invite details"
)
invi_rec = await self.get_invite(use_did_exchange, auto_accept)
if display_qr:
qr = QRCode(border=1)
qr.add_data(invi_rec["invitation_url"])
log_msg(
"Use the following JSON to accept the invite from another demo agent."
" Or use the QR code to connect from a mobile agent.")
log_msg(json.dumps(invi_rec["invitation"]),
label="Invitation Data:",
color=None)
qr.print_ascii(invert=True)
if wait:
log_msg("Waiting for connection...")
await self.detect_connection()
return invi_rec
def parse_add(datafile, event_id):
csvFile=open(datafile)
fileData = reader(csvFile, delimiter=';', quotechar='|')
for row in fileData:
user = User()
user.first_name=row[0]
user.last_name=row[1]
user.email=row[2]
user.college_name=row[3]
user.qr_data = sha1(user.email).hexdigest()
#qr = QRCode(version=10, error_correction=ERROR_CORRECT_H)
qr = QRCode(
version=6,
border=4,
box_size=5,
error_correction=ERROR_CORRECT_Q
)
qr.add_data(user.qr_data)
qr.make() # Generate the QRCode itself
#im contains a PIL.Image.Image object
im = qr.make_image()
# To save it
im.save("qr.png")
#db_session.add(user)
sendmail(user.email)
db.session.add(user)
db.session.commit()
eu = EventUsers(event_id,user.id)
db.session.add(eu)
db.session.commit()
def makeQRCode(data, mode):
""" Make a graphical representation of a QRCODE in unicode."""
sio = StringIO()
qr_code = QRCode()
qr_code.add_data(data)
qr_code.print_ascii(out=sio, invert=mode == 'text')
return '\n'.join(line.lstrip() for line in sio.getvalue().split('\n'))
async def generate_invitation(agent, use_did_exchange: bool):
agent._connection_ready = asyncio.Future()
with log_timer("Generate invitation duration:"):
# Generate an invitation
log_status(
"#7 Create a connection to alice and print out the invite details")
if use_did_exchange:
invi_rec = await agent.admin_POST(
"/out-of-band/create-invitation",
{"include_handshake": True},
)
else:
invi_rec = await agent.admin_POST("/connections/create-invitation")
qr = QRCode(border=1)
qr.add_data(invi_rec["invitation_url"])
log_msg(
"Use the following JSON to accept the invite from another demo agent."
" Or use the QR code to connect from a mobile agent.")
log_msg(json.dumps(invi_rec["invitation"]),
label="Invitation Data:",
color=None)
qr.print_ascii(invert=True)
log_msg("Waiting for connection...")
await agent.detect_connection()
def buildQRRegion():
qr = QRCode(box_size=1,
border=1,
image_factory=LPQRImage)
qr.add_data(sha256("").hexdigest())
qr.make()
img = qr.make_image().get_image()
return img
def print_qr(self, data):
qr = QRCode(version=None,
error_correction=ERROR_CORRECT_H,
box_size=20
)
qr.add_data(data)
qr.make(fit=True) # Generate the QRCode itself
# im contains a PIL.Image.Image object
im = qr.make_image()
prntr = Popen(["lp", "-s", "-d%s" % self.printer_name], stdin = PIPE, stdout = None, stderr = None)
## To send it to the printer
im.save(prntr.stdin)
# wait for process to do its stuff
prntr.communicate()
def generate_qr_code_response(request):
user = request.user
qrcode = QRCode(
error_correction=ERROR_CORRECT_H,
box_size=4,
border=4
)
uri = generate_uri('totp', bytes(user.secret), user.email, 'keybar')
qrcode.add_data(uri)
qrcode.make(fit=True)
img = qrcode.make_image()
stream = io.BytesIO()
img.save(stream)
return HttpResponse(stream.getvalue(), content_type='image/png')
def _gen_code_img(data_url, img_seed_name):
from qrcode import QRCode, constants
qr = QRCode(
version=1,
error_correction=constants.ERROR_CORRECT_L,
box_size=10,
border=4,
)
full_url = "http://" + QRCodeManager.HOST + data_url
qr.add_data(full_url)
qr.make(fit=True)
img = qr.make_image()
img_name = "qrcode_" + img_seed_name + ".png"
img_path = settings.MEDIA_ROOT + "qrcodes/" + img_name
img_url = settings.MEDIA_URL + "qrcodes/" + img_name
img.save(img_path, 'PNG')
return img_url
def adduser(event_id=1):
form = RegistrationForm(request.form)
eventdata = db.session.query(Events).filter_by(id = event_id).all()
if request.method == 'POST' and form.validate_on_submit():
#user = User(form.first_name.data, form.last_name.data, form.username.data,
# form.username.data, form.email.data, form.enrollment.data,
# form.college_name.data)
user = User()
form.populate_obj(user)
#user.password = generate_password_hash(user.password)
user.qr_data = sha1(user.email).hexdigest()
#qr = QRCode(version=10, error_correction=ERROR_CORRECT_H)
qr = QRCode(
version=6,
border=4,
box_size=5,
error_correction=ERROR_CORRECT_Q
)
qr.add_data(user.qr_data)
qr.make() # Generate the QRCode itself
#im contains a PIL.Image.Image object
im = qr.make_image()
# To save it
im.save("qr.png")
#db_session.add(user)
sendmail(user.email)
db.session.add(user)
db.session.commit()
eu = EventUsers(event_id,user.id)
db.session.add(eu)
db.session.commit()
event_d = db.session.query(Events).filter_by(id = event_id).all()
cnt = db.session.query(EventUsers).filter_by(event_id = event_id).count()
return render_template('eventdetails.html', event_id=event_id, eventdata=event_d[0],cnt=cnt)
return render_template('adduser.html', form=form, isreg=False,event_id=event_id, event=eventdata[0])
def _getAnswer(self):
config = Config.getInstance()
checkin_app_client_id = config.getCheckinAppClientId()
if checkin_app_client_id is None:
raise NoReportError(_("indico-checkin client_id is not defined in the Indico configuration"))
checkin_app = OAuthApplication.find_first(client_id=checkin_app_client_id)
if checkin_app is None:
raise NoReportError(
_("indico-checkin is not registered as an OAuth application with client_id {}").format(
checkin_app_client_id
)
)
# QRCode (Version 6 with error correction L can contain up to 106 bytes)
qr = QRCode(version=6, error_correction=constants.ERROR_CORRECT_M, box_size=4, border=1)
baseURL = config.getBaseSecureURL() if config.getBaseSecureURL() else config.getBaseURL()
qr_data = {
"event_id": self._conf.getId(),
"title": self._conf.getTitle(),
"date": format_date(self._conf.getAdjustedStartDate()),
"server": {
"baseUrl": baseURL,
"consumerKey": checkin_app.client_id,
"auth_url": url_for("oauth.oauth_authorize", _external=True),
"token_url": url_for("oauth.oauth_token", _external=True),
},
}
json_qr_data = json.dumps(qr_data)
qr.add_data(json_qr_data)
qr.make(fit=True)
qr_img = qr.make_image()
output = StringIO()
qr_img._img.save(output, format="png")
im_data = output.getvalue()
return "data:image/png;base64,{0}".format(base64.b64encode(im_data))
def generate_ticket_qr_code(registration):
"""Generate a Pillow `Image` with a QR Code encoding a check-in ticket.
:param registration: corresponding `Registration` object
"""
qr = QRCode(
version=17,
error_correction=constants.ERROR_CORRECT_Q,
box_size=3,
border=1
)
qr_data = {
"registrant_id": registration.id,
"checkin_secret": registration.ticket_uuid,
"event_id": unicode(registration.event.id),
"server_url": config.BASE_URL,
"version": 1
}
signals.event.registration.generate_ticket_qr_code.send(registration, ticket_data=qr_data)
json_qr_data = json.dumps(qr_data)
qr.add_data(json_qr_data)
qr.make(fit=True)
return qr.make_image()._img
def generate(key_type, key, user, issuer, counter=None, **kwargs):
r"""
Generate a QR code suitable for Google Authenticator.
See: https://code.google.com/p/google-authenticator/wiki/KeyUriFormat
:param str key_type: the auth type, either ``totp`` or ``hotp``
:param str key: the secret key
:param str user: the username
:param str issuer: issuer name
:param counter: initial counter value (HOTP only)
:type counter: :func:`int` or :data:`None`
:param \*\*kwargs: Arguments passed to the :class:`qrcode.QRCode`
constructor
:returns: an image object
:rtype: :class:`qrcode.image.base.BaseImage`
"""
qr = QRCode(**kwargs)
oath_uri = uri.generate(key_type, key, user, issuer, counter)
qr.add_data(oath_uri)
if kwargs.get('version') is None:
qr.make(fit=True)
return qr.make_image()
def create_pdf(name, orderid, ticketid, event, tickettype):
packet = StringIO.StringIO()
# create a new PDF with Reportlab
can = canvas.Canvas(packet)
qr = QRCode(version=1, error_correction=ERROR_CORRECT_L, box_size=50, border=4, )
qr.add_data(uuid.uuid4())
qr.make(fit=True) # Generate the QRCode itself
# im contains a PIL.Image.Image object
im = qr.make_image()
im.save(os.path.join(settings.PDF_LOCATION, 'qr', "qr" + str(ticketid) + ".jpg"), 'JPEG')
can.drawImage(os.path.join(settings.PDF_LOCATION, 'qr', 'qr' + str(ticketid) + ".jpg"), 150, 50, 125, 125)
os.remove(os.path.join(settings.PDF_LOCATION, 'qr', 'qr' + str(ticketid) + ".jpg"))
terms = Terms.objects.get(id=1).terms
terms = terms.replace('\r\n', 'SPLIT')
terms = terms.split("SPLIT")
x = 150
for line in terms:
can.drawString(300, x, line)
x -= 15
can.drawString(20, 150, str(name))
can.drawString(20, 135, "OrderNr: " + str(orderid))
can.drawString(20, 120, "TicketNr: " + str(ticketid))
can.drawString(20, 30, "Type: " + str(tickettype))
can.line(290, 160, 290, 5)
can.drawString(110, 150, "")
can.save()
# move to the beginning of the StringIO buffer
packet.seek(0)
new_pdf = PdfFileReader(packet)
# read your existing PDF
existing_pdf = PdfFileReader(file(event.template.path, "rb"))
output = PdfFileWriter()
# add the "watermark" (which is the new pdf) on the existing page
page = existing_pdf.getPage(0)
page.mergePage(new_pdf.getPage(0))
output.addPage(page)
return output
def _getAnswer(self):
consumers = dict((consumer.getName(), consumer) for consumer in ConsumerHolder().getList())
if "indico-checkin" not in consumers:
raise NoReportError(_("There is no indico-checkin consumer key for OAuth"))
# QRCode (Version 6 with error correction L can contain up to 106 bytes)
qr = QRCode(
version=6,
error_correction=constants.ERROR_CORRECT_M,
box_size=4,
border=1
)
oauth_checkin = consumers["indico-checkin"]
config = Config.getInstance()
baseURL = config.getBaseSecureURL() if config.getBaseSecureURL() else config.getBaseURL()
qr_data = {"event_id": self._conf.getId(),
"title": self._conf.getTitle(),
"date": format_date(self._conf.getAdjustedStartDate()),
"server": {"baseUrl": baseURL,
"consumerKey": oauth_checkin.getId(),
"consumerSecret": oauth_checkin.getSecret(),
}
}
json_qr_data = json.dumps(qr_data)
qr.add_data(json_qr_data)
qr.make(fit=True)
qr_img = qr.make_image()
output = StringIO()
qr_img._img.save(output, format="png")
im_data = output.getvalue()
return 'data:image/png;base64,{0}'.format(base64.b64encode(im_data))
def make_code(self, code):
q = QRCode()
q.add_data(code)
stream = FakeStream()
q.print_ascii(stream)
return self.template % u''.join(stream).replace('\n', self.eol)
def qrcode(self):
qrcode = QRCode(error_correction=self.LEVELS[self.level], version=self.size)
qrcode.add_data(self.data)
qrcode.make()
return qrcode
def __init__(self, w, h, message, **kwargs):
self.qrc = QRCode()#w, h, **kwargs)
self.qrc.add_data(message)
def qrcode(msg):
qr = QRCode()
qr.add_data(msg)
return qr
def generate_qr_as_pil_image(data):
qr = QRCode(error_correction=ERROR_CORRECT_L, box_size=5, border=1)
qr.add_data(data)
qr.make()
return qr.make_image()
def _str2qr(self, str):
qr = QRCode()
qr.border = 1
qr.add_data(str)
mat = qr.get_matrix()
self._printQR(mat) # qr.print_tty() or qr.print_ascii()
def _generate_image(self):
qr = QRCode(error_correction=ERROR_CORRECT_L)
qr.add_data(self.url)
return qr.make_image()
