def test_bases():
b36 = base36()
b52 = base52()
b56 = base56()
b58 = base58()
b62 = base62()
b94 = base94()
def make_hash(cls, object_pk, klass):
base36 = basehash.base36()
content_type = ContentType.objects.get_for_model(klass, for_concrete_model=False)
return base36.hash('%(contenttype_pk)03d%(object_pk)06d' % {
'contenttype_pk': content_type.pk,
'object_pk': object_pk
})
def user_application(request):
# getting form
form_id = basehash.base36().unhash(request.GET['application'])
form_fields = FormFields.objects.filter(form_id=form_id)
if request.method == 'POST':
data = request.POST
# list of all form tegs
tegs = []
for field in form_fields:
# all fields for tegs to be fill
if field.field_title not in data or len(data[field.field_title]) < 0:
return render(request, 'form/user_application.html', {"form_fields": form_fields,
"error": "заполните все поля"})
else:
# object for each teg for processing application and creating user application text
tag = {
"key": field.teg,
"value": data[field.field_title]
}
tegs.append(tag)
# getting form text
form = Form.objects.get(id=form_id)
text = form.text
title = form.title
# processing form text, replacing all tegs with user data
for teg in tegs:
text = text.replace('#{}'.format(teg['key']), '{}'.format(teg['value']))
title = title.replace('#{}'.format(teg['key']), '{}'.format(teg['value']))
# generating user unique key for signature, checking it to be unique
number = random.randint(1000, 9999)
key_exist = Application.objects.filter(key=number)
if key_exist:
while key_exist:
number = random.randint(1000, 9999)
key_exist = Application.objects.get(key=number)
else:
# if key unique registering user application
key = str(number)
date = datetime.datetime.now()
new_application = Application(form_id=form_id, title=title, user_id=request.user.id, text=text, key=key,
date=date)
new_application.save()
application = Application.objects.get(key=key)
# creating and sending email with msg for user (now in terminal)
message = render_to_string('form/signature_confirmation_email.html', {
"key": application.key,
'domain': 'stormy-mountain-84583.herokuapp.com/',
'aid': urlsafe_base64_encode(force_bytes(application.pk))
})
mail_subject = form.email_subject
to_email = request.user.email
email = EmailMessage(mail_subject, message, to=[(to_email)])
email.send()
return redirect('sign_confirmation', aid=urlsafe_base64_encode(force_bytes(application.pk)))
return render(request, 'form/user_application.html', {"form_fields": form_fields})
def parse_hash(cls, obj_hash):
try:
base36 = basehash.base36(length=len(obj_hash))
unhashed = '%09d' % base36.unhash(obj_hash)
contenttype_pk = int(unhashed[:-6])
object_pk = int(unhashed[-6:])
except Exception as e:
print e.message
raise e
else:
return contenttype_pk, object_pk
def create_form(request):
if request.user.is_staff:
if request.method == 'POST':
data = request.POST
# checking do admin feel all data needed to create form
if 'name' and "form_text" and 'add_number' and "email_subject" in data and len(data['name']) > 0 and \
len(data['form_text']) > 0 and int(data['add_number']) > 0 and len(data['email_subject']) > 0:
name = data['name']
form_text = data['form_text']
fields_number = int(data['add_number'])
email_subject = data['email_subject']
# list to get all tegs what was created
fields = []
# for each created teg in form
for i in range(fields_number):
# checking is each teg created properly
if len(data['name{}'.format(i)]) <=0 or len(data['type{}'.format(i)]) <=0 or len(data['tag{}'.format(i)]) <=0:
return render(request, 'form/create_form.html', {'error': "Заполните все поля"})
else:
# details for each teg
field = {
"name": data['name{}'.format(i)],
'type': data['type{}'.format(i)],
"tag": data['tag{}'.format(i)]
}
fields.append(field)
# getting date
date = datetime.datetime.now()
# creating new form
new_form = Form(user_create_id=request.user.id, title=name, text=form_text, email_subject=email_subject,
date_created=date)
new_form.save()
form = Form.objects.get(user_create_id=request.user.id, date_created=date)
# hashing url
hash_fn = basehash.base36()
hash_value = hash_fn.hash(form.id)
link = "https://stormy-mountain-84583.herokuapp.com/application/?application={}".format(hash_value)
# creating tegs for form
for field in fields:
new_field = FormFields(form_id=form.id, field_title=field['name'], teg=field['tag'],
type=field['type'])
new_field.save()
# updating link for form application
link = Form.objects.filter(id=form.id).update(link=link)
return redirect('admin_index')
else:
return render(request, 'form/create_form.html', {'error': "Заполните все поля"})
else:
return render(request, 'form/create_form.html')
else:
return HttpResponse('Not allowed')
from nose.tools import raises
from basehash import base36
base36 = base36()
def test_base36_encode_with_1234567890_KF12OI():
assert base36.encode(1234567890) == 'KF12OI'
def test_base36_decode_with_KF12OI_1234567890():
assert base36.decode('KF12OI') == 1234567890
def test_base36_hash_with_1234567890_10_FT9Q9O71KI():
assert base36.hash(1234567890, 10) == 'FT9Q9O71KI'
def test_base36_unhash_with_FT9Q9O71KI_1234567890():
assert base36.unhash('FT9Q9O71KI') == 1234567890
def test_base36_maximum_value_with_6_2176782335():
assert base36.maximum_value(6) == 2176782335
@raises(ValueError)
def test_base36_hash_fail_with_2176782336_6():
assert base36.hash(2176782336, 6)
import csv
import basehash
import pandas as pd
from pathlib import Path
import json
import event
import log
from colorama import Fore
hash_pas = basehash.base36()
class User:
def __init__(self, user_name, password):
self.user_name = user_name
self.password = password
self.money = 0
def buy(self, id, num, code):
"""
this function is for buying tickets of the event.
:param id: id of event that want to buy.
:param num: number of ticket that want to buy.
:param code: code if discount.
"""
with open('Event.csv', 'r') as events:
events_read = csv.DictReader(events)
for row in events_read:
if row['id'] == id:
id_error = 1
if int(row['Remaining Capacity']) >= int(num):
if code != 'N':
def GroupCall(request, groupid):
""" render group call page """
ip = '10.101.248.46' #static ip to run this call
group = models.Group.objects.filter(
pk=groupid).first() # get group from given id
user = get_user(request) # get user from session
group_member = models.group_members.objects.filter(
user=user,
group=group).first() #get the relation between user and group
if not request.POST:
# Join call request
if group_member.in_call == 0 and group.call_state != 0:
group_member.in_call = 1 # change call state for user
group_member.save()
# create client for request join
Client.Client(ip, group.call_state, group_member)
# start call request
elif group.call_state == 0:
server = Server.Server(ip, group) # establish call server
''' generate unique invite code include ip and group id
(user would use it in desktop app to join call) '''
hash_fn = basehash.base36() #use base hash to encrypt id & ip
sp = ip.split('.') #remove dots in ip
invite_code = hash_fn.hash(sp[0]) + 'z' + hash_fn.hash(
sp[1]) + 'z' + hash_fn.hash(sp[2]) + 'z' + hash_fn.hash(
sp[3]) + 'z' + hash_fn.hash(groupid) #final code
#update group object
group.call_state = server.port # change call state for group
group.invite_code = invite_code
group.call_start_at = timezone.now()
group.save()
# change call state for host user
group_member.in_call = 1
group_member.save()
Client.Client(ip, server.port,
group_member) # create client for host
if request.POST:
''' end group call request '''
if request.POST.get("end_call") == 'true':
group.call_state = 0 # change group call state
group.invite_code = 0
group.save()
# change all group members in call state to zero
for member in group.members.filter():
group_member = models.group_members.objects.filter(
user=member, group=group).first()
group_member.in_call = 0
group_member.save()
return redirect('viewGroup',
groupid=group.id) #redirect to group page
''' leave group call request '''
if request.POST.get("leave_call") == 'true':
# change member in call state to zero
group_member = models.group_members.objects.filter(
user=user, group=group).first()
group_member.in_call = 0
group_member.save()
return redirect('viewGroup',
groupid=group.id) #redirect to group page
#send user to call page, send required contexts to this page
return render(
request, 'app/group/group_call.html', {
'group': group,
'group_member': group_member,
'ip': ip,
'title': 'create call',
'year': datetime.now().year
})
def parse_hash(cls, obj_hash):
base36 = basehash.base36()
unhashed = '%09d' % base36.unhash(obj_hash)
contenttype_pk = int(unhashed[:-6])
object_pk = int(unhashed[-6:])
return contenttype_pk, object_pk
from nose.tools import raises
from basehash import base36
bh36 = base36()
bh6 = base36(6)
bh10 = base36(10)
def test_base36_encode_with_1234567890_KF12OI():
assert bh36.encode(1234567890) == 'KF12OI'
def test_base36_decode_with_KF12OI_1234567890():
assert bh36.decode('KF12OI') == 1234567890
def test_base36_hash_with_1234567890_10_FT9Q9O71KI():
assert bh10.hash(1234567890) == 'FT9Q9O71KI'
def test_base36_unhash_with_FT9Q9O71KI_1234567890():
assert bh10.unhash('FT9Q9O71KI') == 1234567890
def test_base36_maximum_value_with_6_2176782335():
assert bh6.maximum == 2176782335
@raises(ValueError)
from nose.tools import raises
from basehash import base36
base36 = base36()
def test_base36_encode_with_1234567890_KF12OI():
assert base36.encode(1234567890) == 'KF12OI'
def test_base36_decode_with_KF12OI_1234567890():
assert base36.decode('KF12OI') == 1234567890
def test_base36_hash_with_1234567890_10_FT9Q9O71KI():
assert base36.hash(1234567890, 10) == 'FT9Q9O71KI'
def test_base36_unhash_with_FT9Q9O71KI_1234567890():
assert base36.unhash('FT9Q9O71KI') == 1234567890
def test_base36_maximum_value_with_6_2176782335():
assert base36.maximum_value(6) == 2176782335
@raises(ValueError)
def test_base36_hash_fail_with_2176782336_6():
assert base36.hash(2176782336, 6)
from pymongo import MongoClient
import pprint
import flask
from flask import request
from flask import Flask
from flask_cors import CORS
import json
import datetime
import random
import basehash
app = Flask(__name__)
CORS(app)
TOKEN = 55555
hash_fn = basehash.base36()
client = MongoClient(
"mongodb+srv://dbUser:[email protected]/test?retryWrites=true&w=majority"
)
db = client['stores']
accounts = db['accounts']
# pprint.pprint(db.collection_names())
# collection = db['storeOne']
# pprint.pprint(collection.distinct("_id"))
# collection.insert_one({"x":1})
# collection.update_one({"x": 1},{"$inc":{"x":3}})
# doc = collection.find_one({"Name" : "FirstDummy"})
# pprint.pprint(doc)
from nose.tools import raises
from basehash import base36
bh36 = base36()
bh6 = base36(6)
bh10 = base36(10)
def test_base36_encode_with_1234567890_KF12OI():
assert bh36.encode(1234567890) == 'KF12OI'
def test_base36_decode_with_KF12OI_1234567890():
assert bh36.decode('KF12OI') == 1234567890
def test_base36_hash_with_1234567890_10_FT9Q9O71KI():
assert bh10.hash(1234567890) == 'FT9Q9O71KI'
def test_base36_unhash_with_FT9Q9O71KI_1234567890():
assert bh10.unhash('FT9Q9O71KI') == 1234567890
def test_base36_maximum_value_with_6_2176782335():
assert bh6.maximum == 2176782335
@raises(ValueError)
def test_base36_hash_fail_with_2176782336_6():
def connect(self, code):
app = App.get_running_app()
app.code = code
try:
# unhashing the invite code
hash_fn = basehash.base36()
sp = code.split('z')
ip = str(hash_fn.unhash(sp[0])) + '.' + str(hash_fn.unhash(sp[1]))+ '.' +\
str(hash_fn.unhash(sp[2])) + '.' + str(hash_fn.unhash(sp[3]))
global gid
gid = int(hash_fn.unhash(sp[4]))
uid = login.uid
#add screen incall here (not in main) as it uses gid and uid
self.manager.add_widget(incall(name='incall'))
#connect to database to check for the inv. code
con = cx_Oracle.connect('meetapp/meetapp@localhost')
cursor = con.cursor()
cursor.execute(
"select ID from APP_GROUP where INVITE_CODE=:inv_code",
inv_code=code)
row = cursor.fetchone()
if row != None:
# Check if the user in this group
cursor.execute(
"select USER_ID from APP_GROUP_MEMBERS where GROUP_ID=:groupid and USER_ID=:userid",
groupid=gid,
userid=uid)
row = cursor.fetchone()
if row != None:
cursor.execute(
"select call_state from app_group where id=:groupid",
groupid=gid)
row = cursor.fetchone()
if row != None:
port = row[0]
# update call state
cursor.execute(
"update app_group_members set in_call=:incall where group_id=:groupid and user_id=:userid",
incall=1,
groupid=gid,
userid=uid)
con.commit()
cursor.execute(
"select id from APP_GROUP_MEMBERS where group_id=:groupid and user_id=:userid",
groupid=gid,
userid=uid)
print(uid)
row = cursor.fetchone()
print(row[0])
group_member_id = row[0]
global client
client = Client.Client(ip, port, group_member_id)
self.manager.transition = SlideTransition(
direction="right")
self.manager.current = 'incall'
else:
Alert('Error', 'Please try again')
self.manager.get_screen('connected').resetForm()
# if not group member
else:
Alert(
'Error',
'You are not in this group.\nAsk the group admin to enter you.'
)
self.manager.get_screen('connected').resetForm()
#cursor.close()
else:
Alert('Error', 'No available call for this group')
self.manager.get_screen('connected').resetForm()
# if code is invalid
except:
Alert('Error', 'Please enter valid code')
self.manager.get_screen('connected').resetForm()
