def register(request):
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
user_name = form.cleaned_data['name']
user_surname = form.cleaned_data['surname']
user_email = form.cleaned_data['email']
user_password = form.cleaned_data['password']
try:
user = User(name=user_name,
surname=user_surname,
email=user_email,
password=user_password)
user.save()
except IntegrityError as e:
return render(request, 'register.html', {
'form': form,
'reason': 'User with that email already exists!'
})
return render(request, 'register_success.html', {'user': user})
else:
return render(request, 'register.html', {
'form': form,
'error': form.errors
})
else:
return render(request, 'register.html', {'form': RegisterForm})
def index(request):
form = ContactForm(request.POST or None)
data = {}
if request.is_ajax():
if form.is_valid():
form.save()
data['name'] = form.cleaned_data.get('name')
data['status'] = 'ok'
return JsonResponse(data)
def get_ip(request):
address = request.META.get('HTTP_X_FORWARDED_FOR')
if address:
ip = address.split(',')[-1].strip()
else:
ip = request.META.get('REMOTE_ADDR')
return ip
ip = get_ip(request)
u = User(user=ip)
print(ip)
result = User.objects.filter(Q(user__icontains=ip))
if len(result) == 1:
print('user exits')
elif len(result) > 1:
print('users exists')
else:
u.save()
print('This is a new user')
count = User.objects.all().count()
print('total visitors', count)
context = {'form': form, 'count': count}
return render(request, 'main/index.html', context)
def register(request):
"""
注册处理事件
:param request:注册请求
:return:
①result: '0'表示成功， '1'表示用户名重名， '2'表示未知错误,可能昵称/邮箱/密码为空，可能传输出错
②
"""
# 回复
response = HttpResponse()
response['Content-Type'] = 'application/json'
if request.method == 'POST':
# 获取客户端信息
nickname = request.POST.get('userName', '')
password = request.POST.get('userCode', '')
avatar = request.POST.get('avatar', '')
if nickname and password:
try:
user = User.objects.get(nickname=nickname)
result = '1'
except ObjectDoesNotExist:
user = User(nickname=nickname, mail='nomail', password=password, create_time=time.time(),
action_time=time.time())
user.save()
result = '0'
else:
result = '2'
else:
result = '-1'
response.write(result)
response.write(fetch_recommend()) # 返回首页信息
return response
def create_user_from_email(email):
username, _ = email.split("@")
user = User(username=username, email=email)
user.save()
password = generate_random_password()
user.set_password(password)
user.profile.email = email
user.profile.save()
return user
def homepage(request):
if request.method == "POST":
response = HttpResponse() # data that will be send back to the client
email = request.POST["Email"]
password = request.POST["Password"]
request_type = request.POST[
"type"] # wether the user registers("new"), logs in("existing") or modifies their vault("change")
if request_type == "new" or request.POST["type"] == "change":
data = request.POST["Vault"]
#check if email format is valid
if re.search("^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$",
email):
# hashing the password again
hashedPasswordBytes = PBKDF2(password,
bytes(email, 'utf-8'),
dkLen=64,
count=100000,
prf=prf)
# turn hashed password into string to store in db
hashedPassword = b64encode(hashedPasswordBytes).decode('utf-8')
# check if user already exists
if len(User.objects.filter(mail=email)) != 0:
if request_type == "new":
response.write("User already exists.")
elif request.POST["type"] == "change":
modifiedUser = User.objects.get(mail=email)
modifiedUser.data = data
modifiedUser.save()
response.write("Vault updated!")
else:
storedPassword = User.objects.filter(
mail=email)[0].password
if storedPassword == hashedPassword:
response.write("Vault:" +
User.objects.filter(mail=email)[0].data)
else:
response.write("Password wrong!")
else:
if request_type == "new":
newUser = User(mail=email,
password=hashedPassword,
data=data)
newUser.save()
response.write("User created!")
else:
response.write("User doesn't exist yet!")
else:
response.write("Email is invalid")
return response
return render(request=request, template_name="index.html")
def add_player(username, first_name, last_name, team):
if username:
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = User(username=username)
user.first_name = first_name
user.last_name = last_name
user.save()
team.members.add(user)
def setUp(self):
###### create Users #######
users = ['UserA', 'UserB', 'UserC', 'UserD']
for i in range(4):
newUser = AUser(password='', last_login=timezone.now(), is_superuser=True, username=users[i], first_name='Firstname', last_name='Lastname', email='*****@*****.**', is_staff=True, is_active=True, date_joined=timezone.now())
newUser.save()
testDBModel.testUsers.append(newUser)
testDBModel.testUsersID.append(newUser.pk)
###### add Category ######
category1 = Category(name="hats")
testDBModel.testCategory.append(category1)
category1.save()
category2 = Category(name="glasses")
testDBModel.testCategory.append(category2)
category2.save()
user = User(id=testDBModel.testUsersID[0],user_id=testDBModel.testUsersID[0], user_image="profile1.jpg")
user.save()
###### add product ######
addProducts = ["ProductA", "ProductB", "ProductC", "ProductD"]
for i in range(4): # # add products
newOne = Product(category=category1, name=addProducts[i], brand='brand', url='url', photo='photo', price=1.0, description='')
newOne.save()
testDBModel.testProducts.append(newOne)
###### add custom product #####
newAdded = Added(owner = testDBModel.testUsers[0], product = testDBModel.testProducts[0])
newAdded.save()
newAdded = Added(owner = testDBModel.testUsers[1], product = testDBModel.testProducts[1])
newAdded.save()
###### add temp product ######
tempP = TempProduct(owner = testDBModel.testUsers[0], overlay = 'overlay1ol.jpg', token = '1', category = testDBModel.testCategory[0])
tempP.save()
tempP = TempProduct(owner = testDBModel.testUsers[1], overlay = 'overlay2ol.jpg', token = '2', category = testDBModel.testCategory[0])
tempP.save()
testDBModel.testOverlay = ['overlay1ol.jpg', 'overlay2ol.jpg']
##### ## add comments ######
for i in range(4):
newOne = Comment(product=testDBModel.testProducts[i], owner=testDBModel.testUsers[i], content="null", time = timezone.now())
newOne.save()
testDBModel.testComments.append(newOne)
# add to wishlist first
for i in range(4):
newOne = WishList(product=testDBModel.testProducts[i], owner=testDBModel.testUsers[i])
newOne.save()
# add to FitList:
for i in range(4):
newOne = FitList(product = testDBModel.testProducts[i], owner = testDBModel.testUsers[i])
newOne.save()
def signup(request):
if request.POST.has_key('login'):
new_user = User()
new_user.setName(request.POST['login'])
feed = Feed()
feed.parent = new_user
new_user.save()
feed.save()
response = HttpResponseRedirect(reverse('main:index'))
response.set_cookie('login',request.POST['login'])
return response
def signup(request):
if request.POST.has_key('login'):
new_user = User()
new_user.setName(request.POST['login'])
feed = Feed()
feed.parent = new_user
new_user.save()
feed.save()
response = HttpResponseRedirect(reverse('main:index'))
response.set_cookie('login', request.POST['login'])
return response
def update(self, instance: User, validated_data):
username = validated_data.get('username', None)
first_name = validated_data.get('first_name')
last_name = validated_data.pop('last_name', None)
instance.username = username
instance.first_name = first_name
instance.last_name = last_name
instance.save()
return instance
def get_user(request):
pk = request.COOKIES.get('user_id')
if (pk is None):
user = User()
user.save()
else:
try:
user = User.objects.get(id=pk)
except:
user = User()
user.save()
return user
def signup(request):
try:
if request.POST['submit']:
try:
user = User.objects.get(email=request.POST['email'])
return render(request, 'signup.html', {'message': 'User already exits'})
except ObjectDoesNotExist:
user = User(name=request.POST['name'], email=request.POST['email'], password=request.POST['password'], invited=False)
user.save()
return redirect('../')
except Exception as ex:
print(ex)
return render(request, 'signup.html')
def useradd(self, username, password):
'''
添加一个用户，如果用户存在则更新用户名和密码。
:username 要添加或更新的用户名称
:password 用户要设置或者更新的密码
'''
user = User.select().where(User.username == username).first()
if user:
user.password = password
else:
user = User()
user.username = username
user.password = password
user.role = 'ADMIN'
user.locked = False
user.save()
def register(request):
if request.method == 'GET':
return render(request, 'reg.html')
elif request.method == 'POST':
username = request.POST.get('id')
user = User.objects.filter(pk=username)
if user.exists():
return HttpResponse('用户名已存在')
user = User()
user.u_id = username
user.u_pwd = request.POST.get('pwd')
user.u_identity = request.POST.get('iden')
user.save()
return render(request, 'success_reg.html')
else:
pass
def post(self, request, *args, **kwargs):
device_id = request.data.get('device_id')
fcm_token = request.data.get('fcm_token')
user_list = User.objects.filter(device_id=device_id)
if user_list.count() == 0:
user = User()
user.device_id = device_id
user.fcm_token = fcm_token
user.save()
return HttpResponse(json.dumps(user),
content_type="application/json")
else:
user = user_list.first()
user.fcm_token = fcm_token
user.save()
return HttpResponse(json.dumps(user),
content_type="application/json")
def create_user(request):
if request.session.get('id') is None: # First Access
request.session['id'] = str(uuid1.uuid1())
try:
user = User(session_id=request.session['id'],
nickname=random.choice(adjective_list) + " " +
random.choice(animal_list))
user.save()
except Exception as e:
return Message(Status.INTERNAL_ERROR,
f'Internal server error, {e}')
return Message(Status.SUCCESS, user=user)
else:
return Message(Status.BAD_REQUEST, 'User already exists')
def user_signup(request):
context = {
}
if request.is_ajax():
response_data = {}
data = json.loads(request.body.decode('utf-8'))
postEmail = data.get('email')
postUsername = data.get('username')
postPassword = data.get('password')
user = User(email=postEmail, username=postUsername)
user.set_password(postPassword)
try:
user.save()
except IntegrityError as e:
response_data['status'] = False
response_data['msg'] = 'Sorry! This email is already signed up.'
return HttpResponse(json.dumps(response_data),
content_type="application/json"
)
response_data['status'] = True
response_data['msg'] = 'Success!'
return HttpResponse(
json.dumps(response_data),
content_type="application/json"
)
else:
if request.method == 'POST':
form = UserCreationForm(request.POST)
if form.is_valid():
form.save()
else:
form = UserCreationForm()
context.update({'form': form})
return render(request, 'main/pages/signup.html', context)
def createUser(request):
#this is how we get queryArgs
fn = request.GET['fn']
ln = request.GET['ln']
age = request.GET['age']
sex = request.GET['sex']
email = request.GET['e']
password = request.GET['p']
# TODO - check to make sure email/username isn't taken before creating
u = User(createdAt=timezone.now(), inPool=False, signedIn=True, hasReviewed=True, firstName=fn, lastName=ln, age=age, sex=sex, email=email, password=password, totalMatches=0, missedMatches=0)
u.save()
response = JsonResponse({'possibly': 'created user'})
return response
def ldap_login(socket_station):
"""
:param socket_station: SocketStation instance
Credentials Format : handle, password in that order
Further info : pk_of_other_friend
Response : If filter is success : SUCCESS, json_response in that order
If invalid credentials : INVALID_CREDENTIALS
Searches for the user in local db first
If found then SUCCESS
Else searches in ldap db
If found then create user in local db, SUCCESS
Else INVALID_CREDENTIALS
"""
handle = socket_station.receive()
password = socket_station.receive()
try:
user = User.objects.get(handle=Namespace.LDAP + handle,
password=password)
user.last_active = ""
user.save()
print 'Ldap Login successful for handle : ', handle
socket_station.send(Flags.ResponseType.SUCCESS)
socket_station.send(user.name)
except ObjectDoesNotExist:
ldap_uid = authentication_ldap(handle, password)
if ldap_uid is not False:
new_user = User(name=ldap_uid,
handle=Namespace.LDAP + handle,
password=password,
last_active="")
new_user.save()
# Every user is a friend of himself
new_user.friends.add(new_user)
print 'Ldap Signup with handle ', handle, ' : Success'
socket_station.send(Flags.ResponseType.SUCCESS)
socket_station.send(ldap_uid)
else:
print 'Ldap Login failed for handle : ', handle
socket_station.send(Flags.ResponseType.INVALID_CREDENTIALS)
def start(message):
try:
user = User.objects.get(user_id=message.chat.id)
user.username = message.chat.username
user.first_name = message.chat.first_name
user.last_name = message.chat.last_name
except User.DoesNotExist:
user = User(user_id=message.chat.id,
username=message.chat.username,
first_name=message.chat.first_name,
last_name=message.chat.last_name)
finally:
user.save()
bot.send_message(message.chat.id,
preferences.Texts.start_message,
parse_mode='html')
bot.send_message(message.chat.id,
preferences.Texts.main_message,
parse_mode='html')
def insert_visitor(fname, lname, age, description, photo_path):
"""
Depreciated. Please use serializer to insert visitors.
:param fname: user first name
:param lname: user last name
:param age: user age
:param description: user description
:param photo_path: photo path
:return: user object
"""
user = User()
user.fname = fname
if age != "":
user.age = age
user.lname = lname
user.description = description
user.photo_path = photo_path
user.enroll_time = timezone.now()
user.save()
return user
class PrepopulatedUserForm(forms.ModelForm):
advisor = None
account_class = ""
def define_advisor(self, advisor):
self.advisor = advisor
def add_account_class(self, account_class):
self.account_class = account_class
class Meta:
model = User
fields = USER_DETAILS
@transaction.atomic
def save(self, *args, **kwargs):
self.instance = User(password="******",
prepopulated=True,
**self.cleaned_data)
self.instance.save()
# create client instance
defs = {
'address':
'Default Unset Address',
'region':
Region.objects.get_or_create(country='AU',
name='New South Wales')[0]
}
# TODO: Change this so we only create a client once all the info is complete from external onboarding.
# TODO: Until then, they're just a user.
new_client = Client(
advisor=self.advisor,
user=self.instance,
client_agreement=self.advisor.firm.client_agreement_url,
residential_address=Address.objects.get_or_create(
global_id=UNSET_ADDRESS_ID, defaults=defs)[0])
new_client.save()
personal_account = new_client.accounts_all.all()[0]
personal_account.account_class = self.account_class
personal_account.save()
return self.instance
async def verify(ctx):
if await channelcheck(server_list, ctx):
return
async with ctx.channel.typing():
for address in address_holder:
if address.user_id == ctx.author.id:
r = requests.get(
f"http://45.33.60.42/bank_transactions?format=json&limit=1&block__sender={address.address}&recipient={bot_wallet}"
) # sender and receiver logic needed as well as a user DB
info = r.json()
if any(info["results"]):
query = User(DiscordID=int(ctx.author.id),
Address=address.address)
query.save()
newTX = Transaction(Type="DEPOSIT",
TxID=info["results"][0]["id"],
Amount=int(
info["results"][0]['amount']))
newTX.save()
embed = discord.Embed(
title='Success!',
description=
f"Address `{address.address}` succesfully associated with {ctx.author.mention}",
color=bot_color)
await ctx.send(embed=embed)
address_holder.remove(address)
else:
embed = discord.Embed(
title='No Transaction',
description=
f"No transaction detected from `{address.address}`")
await ctx.send(embed=embed)
return
embed = discord.Embed(
title="No Address",
description=
f"No address to verify. Did you make sure to use `{bot_prefix}register ACCOUNT_NUMBER`?",
color=bot_color)
await ctx.send(embed=embed)
def login_view(request):
if 'appSignature' not in request.POST:
return JSONResponse({'status': 400, 'message': 'No application signature found'})
if 'phone_number' not in request.POST or 'pin' not in request.POST:
return JSONResponse({'status': 400, 'message': 'You need to supply both phone number and pin'})
if request.POST['appSignature'] != constants.APP_SIGNATURE:
return JSONResponse({'status': 400, 'message': 'Application Signatures did not match'})
try:
phone_number = request.POST['phone_number']
pin = request.POST['pin']
if not User.objects.filter(phone_number=phone_number).exists():
user = User(phone_number=phone_number, pin=pin)
user.save()
return JSONResponse({'status': 200, 'message': 'User logged in successfully'})
except Exception as e:
_log.error('Exception while logging in: %s' % str(e))
return JSONResponse({'status': 401, 'message': str(e)})
def register(request):
result = {}
if request.method == "POST":
user = User.objects.filter(UserName=request.POST["username"])
if len(user) != 0:
result["success"] = False
result["error"] = -1003
else:
new_user = User(
UserName=request.POST["username"],
Password=request.POST["password"],
Contract=ContractSize.objects.get(pk=request.POST["contract"])
)
new_user.save()
request.session["user"] = new_user.pk
result["success"] = True
result["info"] = 1002
else:
result["success"] = False
result["error"] = -1
return JsonResponse(result)
def add_user(email, password):
"""
Adds user to database and populates their email and pw
:param email: email string
:param password: plain text pw
:return: person object
"""
# Instantiate main and populate fields
person = User()
person.notifications = [Notification()]
person.linked_platforms = []
platform_arr = ['fb', 'yt', 'netflix', 'google']
# Create placeholder for platforms
for platform in platform_arr:
platform_obj = LinkedPlatform()
platform_obj.platform = platform
person.linked_platforms.append(platform_obj)
for lp in person.linked_platforms:
data_obj = Data()
lp.data = [data_obj]
# Create placeholder for summary stats
person.summary_stats = [SummaryStats()]
for sp in person.summary_stats:
sp.timestamp = timezone.now()
sp.fb = FacebookEntry()
sp.yt = YTEntry()
sp.netflix = NetflixEntry()
sp.google = GoogleEntry()
person.username = email
person.password = password
person.save()
return person
def sign_up(socket_station):
"""
:param socket_station: SocketStation instance
Credentials Format : not required
Further info : name, handle, password in that order
Response : If sign up is success : SUCCESS
If handle's namespace is invalid : INVALID_NAME_SPACE
If handle already exists : HANDLE_ALREADY_EXIST
If SUCCESS:
Creates a new user in local db
"""
name = socket_station.receive()
handle = socket_station.receive()
password = socket_station.receive()
# Restricts handle to exclude ldap name space
if len(handle) >= len(
Namespace.LDAP) and handle[:len(Namespace.LDAP)] == Namespace.LDAP:
print 'Sign up with handle ', handle, ' : Fail - invalid name space'
socket_station.send(Flags.ResponseType.INVALID_NAME_SPACE)
else:
try:
User.objects.get(handle=handle)
print 'Sign up with handle ', handle, ' : Fail - Handle already exists'
socket_station.send(Flags.ResponseType.HANDLE_ALREADY_EXIST)
except ObjectDoesNotExist:
new_user = User(name=name,
handle=handle,
password=password,
last_active="")
new_user.save()
# Every user is a friend of himself
new_user.friends.add(new_user)
print 'Sign up with handle ', handle, ' : Success'
socket_station.send(Flags.ResponseType.SUCCESS)
def register(request):
"""
注册处理事件
:param request:注册请求
:return:
①result: '0'表示成功， '1'表示用户名重名， '2'表示未知错误,可能昵称/邮箱/密码为空，可能传输出错
②
"""
# 回复
response = HttpResponse()
response['Content-Type'] = 'application/json'
if request.method == 'POST':
# 获取客户端信息
nickname = request.POST.get('userName', '')
password = request.POST.get('userCode', '')
avatar = request.POST.get('avatar', '')
if nickname and password:
try:
user = User.objects.get(nickname=nickname)
result = '1'
except ObjectDoesNotExist:
user = User(nickname=nickname,
mail='nomail',
password=password,
create_time=time.time(),
action_time=time.time())
user.save()
result = '0'
else:
result = '2'
else:
result = '-1'
response.write(result)
response.write(fetch_recommend()) # 返回首页信息
return response
def user_signup(request):
context = {}
if request.is_ajax():
response_data = {}
data = json.loads(request.body.decode('utf-8'))
postEmail = data.get('email')
postUsername = data.get('username')
postPassword = data.get('password')
user = User(email=postEmail, username=postUsername)
user.set_password(postPassword)
try:
user.save()
except IntegrityError as e:
response_data['status'] = False
response_data['msg'] = 'Sorry! This email is already signed up.'
return HttpResponse(json.dumps(response_data),
content_type="application/json")
response_data['status'] = True
response_data['msg'] = 'Success!'
return HttpResponse(json.dumps(response_data),
content_type="application/json")
else:
if request.method == 'POST':
form = UserCreationForm(request.POST)
if form.is_valid():
form.save()
else:
form = UserCreationForm()
context.update({'form': form})
return render(request, 'main/pages/signup.html', context)
def get(self, request):
#nickname = 'm.lefay'
nickname = request.GET.get('nickname')
#token = '2377482807.24242fb.55f6b006ec0f43d3a45db141259e2e3a'
token = request.GET.get('token')
if not nickname or not token:
return JsonResponse({'nickname':None,'token':None})
try:
u = User.objects.get(nick=nickname)
except:
u = None
if u:
# get pic from db
r = []
img = u.pic_set.all()
if img:
for i in img:
r.append(i.location)
return JsonResponse({'nickname':nickname,'token':token, 'path':r})
#else download and store
api = InstAPI(access_token=token)
r = api.get_user_popular_media(nickname)
u = User(nick=nickname)
u.save()
epath = os.path.join(settings.BASE_DIR, 'insta', 'pics', nickname)
os.mkdir(epath)
if r:
for link in r:
req = requests.get(link, stream=True)
ipath = os.path.join(epath, link.split('/')[-1:][0])
if req.status_code == 200:
with open(ipath, 'wb') as f:
for chunk in req.iter_content(1024):
f.write(chunk)
p = Pic(owner=u, url=link, location=ipath)
p.save()
return JsonResponse({'nickname':nickname,'token':token, 'urls':r})
def add_user_to_workspace(request, workspace, channel):
try:
user = User.objects.get(email=request.POST['user'])
workspace = WorkSpace.objects.get(name=workspace)
user_workspace_rel = UserWorkSpace(user=user, workspace=workspace, privilege=request.POST.get('is_admin', False))
user_workspace_rel.save()
user_channel_rel = UserChannel(user=user, channel=Channel.objects.get(name='general', workspace=workspace))
user_channel_rel.save()
send_mail(
"Invitation to join workspace",
"You have been added to %s workspace." % workspace,
"*****@*****.**",
[request.POST['user']],
fail_silently=False,
)
return redirect('../')
except ObjectDoesNotExist:
min_char = 8
max_char = 12
allchar = string.ascii_letters + string.punctuation + string.digits
password = "".join(choice(allchar) for x in range(randint(min_char, max_char)))
user = User(email=request.POST['user'], password=password, name="", invited=True)
user.save()
workspace = WorkSpace.objects.get(name=workspace)
user_workspace_rel = UserWorkSpace(user=user, workspace=workspace, privilege=request.POST.get('is_admin', False))
user_workspace_rel.save()
user_channel_rel = UserChannel(user=user, channel=Channel.objects.get(name='general', workspace=workspace))
user_channel_rel.save()
send_mail(
"Invitation to join workspace",
"Here are your login credentials \n username: %s \n password: %s \n" %(request.POST['user'], password),
"*****@*****.**",
[request.POST['user']],
fail_silently=False,
)
return redirect('../')
def give_soromoney_to_user(user: User, amount: int): user.points += amount user.save()
class BaseConfiguration(TestCase):
ZAKAZSCHIK1_LOGIN = '******'
ZAKAZSCHIK2_LOGIN = '******'
ZAKUPSCHIK_LOGIN = '******'
ADMINISTRATOR_LOGIN = '******'
PASSWORD = '******'
def setUp(self) -> None:
birth_date = date(1960, 10, 23)
self.zakazschik1 = User(
email=self.ZAKAZSCHIK1_LOGIN,
phone='+7-999-23-12',
delivery_address='Test Address 111',
birth_date=birth_date,
role=Roles.ZAKAZSCHIK,
)
self.zakazschik1.set_password(self.PASSWORD)
self.zakazschik1.save()
self.zakazschik2 = User(
email=self.ZAKAZSCHIK2_LOGIN,
phone='+7-999-23-55',
delivery_address='Test Address 222',
birth_date=birth_date - timedelta(weeks=100),
role=Roles.ZAKAZSCHIK,
)
self.zakazschik2.set_password(self.PASSWORD)
self.zakazschik2.save()
self.zakupschik = User(
email=self.ZAKUPSCHIK_LOGIN,
phone='+7-555-11-22',
delivery_address='Test Address 333',
birth_date=birth_date + timedelta(weeks=55),
role=Roles.ZAKUPSCHIK,
)
self.zakupschik.set_password(self.PASSWORD)
self.zakupschik.save()
self.administrator = User(
email=self.ADMINISTRATOR_LOGIN,
phone='+7-333-44-55',
delivery_address='Test Address 444',
birth_date=birth_date - timedelta(weeks=200),
role=Roles.ADMINISTRATOR,
)
self.administrator.set_password(self.PASSWORD)
self.administrator.save()
SettingOptionHandler('extra_charge').value = 10 # 10%
self.extra_charge = SettingOptionHandler('extra_charge').value
self.client = Client()
def tearDown(self) -> None:
Order.objects.all().delete()
OrderItem.objects.all().delete()
Product.objects.all().delete()
SettingOption.objects.all().delete()
SettingOptionImages.objects.all().delete()
@staticmethod
def get_image_file(name='test.png',
ext='png',
size=(50, 50),
color=(256, 0, 0)):
file_obj = BytesIO()
image = Image.new("RGBA", size=size, color=color)
image.save(file_obj, ext)
file_obj.seek(0)
return File(file_obj, name=name)
def check_for_created_objects(self, orders=0, order_items=0, products=0):
self.assertEqual(Order.objects.count(), orders)
self.assertEqual(OrderItem.objects.count(), order_items)
self.assertEqual(Product.objects.count(), products)
def indexHandler(request):
current_user = request.session.get('user_id', None)
if request.session.get('endtest', 0):
request.session['test_question_id'] = None
request.session['active_test_id'] = None
request.session['endtest'] = 0
active_test_id = request.session.get('active_test_id', None)
test_question_id = request.session.get('test_question_id', None)
test_question = None
choosen_variant_info = None
all_user_choosen_variants = []
endtest = None
random_variants = get_random_variants()
active_test_questions = []
classs = []
active_test = None
tests = []
subject_id = int(request.GET.get('subject_id', 0))
subjects = Subject.objects.all()
left_time_min = 0
left_time_sec = 0
left_time = 0
if current_user:
current_user = User.objects.get(id=int(current_user))
tests = Test.objects.filter(clas__id=current_user.clas.id)
if subject_id:
tests = Test.objects.filter(clas__id=current_user.clas.id).filter(
subject__id=subject_id)
if active_test_id:
active_test = UserTestItem.objects.get(id=int(active_test_id))
ac_questions = active_test.questions and active_test.questions.split(
',') or []
left_time = active_test.stop_date - timezone.now()
left_time = int(left_time.total_seconds())
if left_time < 0:
left_time = 0
left_time_min = int(left_time / 60)
left_time_sec = int(left_time % 60)
active_test_questions = []
if ac_questions:
for i in range(len(ac_questions)):
new_ac_question = TestItem.objects.get(
id=int(ac_questions[i]))
active_test_questions.append(new_ac_question)
if test_question_id:
test_question_id = int(test_question_id)
test_question = TestItem.objects.get(id=test_question_id)
elif active_test_questions:
test_question = TestItem.objects.get(
id=int(ac_questions[0]))
test_question_id = test_question.id
if test_question_id:
utvs = UserTestItemVariant.objects.filter(
user_test_item__id=active_test.id).filter(
test_item__id=test_question.id)
all_user_choosen_variants = []
utvs2 = UserTestItemVariant.objects.filter(
user_test_item__id=active_test.id)
for utv in utvs2:
all_user_choosen_variants.append(int(utv.test_item.id))
if utvs:
choosen_variant_info = utvs[0]
else:
active_test_questions = TestItem.objects.filter(
test__id=int(active_test.test.id))
if test_question_id:
test_question_id = int(test_question_id)
test_question = TestItem.objects.get(id=test_question_id)
elif active_test_questions:
test_question = active_test_questions[0]
test_question_id = test_question.id
if test_question_id:
utvs = UserTestItemVariant.objects.filter(
user_test_item__id=active_test.id).filter(
test_item__id=test_question.id)
all_user_choosen_variants = []
utvs2 = UserTestItemVariant.objects.filter(
user_test_item__id=active_test.id)
for utv in utvs2:
all_user_choosen_variants.append(int(utv.test_item.id))
if utvs:
choosen_variant_info = utvs[0]
if request.POST:
action = request.POST.get('action', '')
if action == 'start_test':
test_id = int(request.POST.get('test_id', 0))
if test_id:
test_questions = TestItem.objects.filter(
test__id=int(test_id))
tqv = []
for tq in test_questions:
tqv.append(tq.id)
new_res = get_random_question_variants(tqv)
new_res2 = ","
new_res = new_res2.join(new_res)
choosen_test = Test.objects.get(id=test_id)
new_user_test = UserTestItem()
new_user_test.start_date = timezone.now()
new_user_test.stop_date = timezone.now() + timedelta(
minutes=choosen_test.limit)
new_user_test.test = choosen_test
new_user_test.user = current_user
new_user_test.questions = new_res
new_user_test.save()
request.session['active_test_id'] = new_user_test.id
active_test = new_user_test
return JsonResponse({
'success': True,
'errorMsg': '',
'_success': True
})
elif action == 'choose_question':
test_question_id = int(request.POST.get('test_question_id', 0))
request.session['test_question_id'] = test_question_id
return JsonResponse({
'success': True,
'errorMsg': '',
'_success': True
})
elif action == 'choose_variant':
utvs = UserTestItemVariant.objects.filter(
user_test_item__id=active_test.id).filter(
test_item__id=test_question.id)
if utvs:
utv = utvs[0]
else:
utv = UserTestItemVariant()
utv.user_test_item = active_test
utv.test_item = test_question
utv.correct_variant = test_question.correct_answer
utv.ball = 0
utv.user_variant = int(request.POST.get('variant', 0))
if utv.user_variant == utv.correct_variant:
utv.ball = 1
utv.save()
return JsonResponse({
'success': True,
'errorMsg': '',
'_success': True
})
elif action == 'endtest':
active_test_questions = UserTestItemVariant.objects.filter(
user_test_item__id=active_test.id)
s = 0
for atq in active_test_questions:
if atq.user_variant == atq.correct_variant and atq.user_variant != 0:
s += 1
active_test.count_question = len(active_test_questions)
active_test.ball = s
active_test.stop_date = timezone.now()
active_test.save()
request.session['endtest'] = 1
return JsonResponse({
'success': True,
'errorMsg': '',
'_success': True
})
elif action == 'endalltest':
all_user_tests = UserTestItem.objects.all()
for aut in all_user_tests:
active_test_questions = UserTestItemVariant.objects.filter(
user_test_item__id=aut.id)
s = 0
for atq in active_test_questions:
if atq.user_variant == atq.correct_variant and atq.user_variant != 0:
s += 1
aut.count_question = len(active_test_questions)
aut.ball = s
#active_test.stop_date = timezone.now()
aut.save()
elif action == 'coorect_true_variant':
old_test_item_id = int(request.POST.get('old_test_item_id', 0))
if old_test_item_id:
ti = TestItem.objects.get(id=old_test_item_id)
old_variants = UserTestItemVariant.objects.filter(
test_item__id=old_test_item_id)
for ov in old_variants:
ov.correct_variant = ti.correct_answer
ov.save()
else:
if request.POST:
new_user = User()
new_user.last_name = request.POST.get('ln', '')
new_user.first_name = request.POST.get('fn', '')
clas_id = int(request.POST.get('class', 0))
if clas_id:
new_user.clas = Class.objects.get(id=int(clas_id))
tests = Test.objects.filter(clas__id=int(clas_id))
old_user = User.objects.filter(
last_name=new_user.last_name).filter(
first_name=new_user.first_name).filter(
clas__id=int(clas_id))
if old_user:
new_user = old_user[0]
else:
new_user.save()
request.session['user_id'] = new_user.id
current_user = User.objects.get(id=int(new_user.id))
else:
current_user = None
classs = Class.objects.all()
return render(
request, 'index.html', {
'tests': tests,
'classs': classs,
'current_user': current_user,
'active_test': active_test,
'random_variants': random_variants,
'active_test_questions': active_test_questions,
'test_question': test_question,
'choosen_variant_info': choosen_variant_info,
'endtest': endtest,
'left_time': left_time,
'all_user_choosen_variants': all_user_choosen_variants,
'left_time_min': left_time_min,
'left_time_sec': left_time_sec,
'subjects': subjects,
'subject_id': subject_id,
})
def populate_test_reviews(self):
robert = User(name="Robert", external_id=1, email="*****@*****.**")
robert.save()
josh = Professional.objects.get(pk=1)
josh_r1 = Review(user=User.objects.get(pk=1),
userDisplayName="Raging Robert",
professional=josh,
text="I hate this guy",
rating="0.5",
date=datetime.utcnow(),
karma=1)
josh_r2 = Review(user=User.objects.get(pk=1),
userDisplayName="Angry Robert",
professional=josh,
text="Terrible",
rating="1",
date=datetime.utcnow(),
karma=1)
josh_r3 = Review(user=User.objects.get(pk=1),
userDisplayName="Mad Robert",
professional=josh,
text="Very bad",
rating="1.5",
date=datetime.utcnow(),
karma=1)
josh_r4 = Review(user=User.objects.get(pk=1),
userDisplayName="Disappointed Robert",
professional=josh,
text="Bad",
rating="2",
date=datetime.utcnow(),
karma=1)
josh_r5 = Review(user=User.objects.get(pk=1),
userDisplayName="Unimpressed Robert",
professional=josh,
text="Meh",
rating="2.5",
date=datetime.utcnow(),
karma=1)
josh_r6 = Review(user=User.objects.get(pk=1),
userDisplayName="Placated Robert",
professional=josh,
text="Not bad",
rating="3",
date=datetime.utcnow(),
karma=1)
josh_r7 = Review(user=User.objects.get(pk=1),
userDisplayName="Pleased Robert",
professional=josh,
text="Okay",
rating="3.5",
date=datetime.utcnow(),
karma=1)
josh_r8 = Review(user=User.objects.get(pk=1),
userDisplayName="Happy Robert",
professional=josh,
text="Good",
rating="4",
date=datetime.utcnow(),
karma=1)
josh_r9 = Review(user=User.objects.get(pk=1),
userDisplayName="Ecstatic Robert",
professional=josh,
text="Great",
rating="4.5",
date=datetime.utcnow(),
karma=1)
josh_r10 = Review(user=User.objects.get(pk=1),
userDisplayName="Blown-Away Robert",
professional=josh,
text="ZOMGAMAZING!!",
rating="5",
date=datetime.utcnow(),
karma=1)
josh_r1.save()
josh_r2.save()
josh_r3.save()
josh_r4.save()
josh_r5.save()
josh_r6.save()
josh_r7.save()
josh_r8.save()
josh_r9.save()
josh_r10.save()
def post(request):
user = User(**request.info)
user.id = None
user.save()
return RestJsonResponse(user)
def setUp(self):
###### create Users #######
users = ['UserA', 'UserB', 'UserC', 'UserD']
for i in range(4):
newUser = AUser(password='',
last_login=timezone.now(),
is_superuser=True,
username=users[i],
first_name='Firstname',
last_name='Lastname',
email='*****@*****.**',
is_staff=True,
is_active=True,
date_joined=timezone.now())
newUser.save()
testDBModel.testUsers.append(newUser)
testDBModel.testUsersID.append(newUser.pk)
###### add Category ######
category1 = Category(name="hats")
testDBModel.testCategory.append(category1)
category1.save()
category2 = Category(name="glasses")
testDBModel.testCategory.append(category2)
category2.save()
user = User(id=testDBModel.testUsersID[0],
user_id=testDBModel.testUsersID[0],
user_image="profile1.jpg")
user.save()
###### add product ######
addProducts = ["ProductA", "ProductB", "ProductC", "ProductD"]
for i in range(4): # # add products
newOne = Product(category=category1,
name=addProducts[i],
brand='brand',
url='url',
photo='photo',
price=1.0,
description='')
newOne.save()
testDBModel.testProducts.append(newOne)
###### add custom product #####
newAdded = Added(owner=testDBModel.testUsers[0],
product=testDBModel.testProducts[0])
newAdded.save()
newAdded = Added(owner=testDBModel.testUsers[1],
product=testDBModel.testProducts[1])
newAdded.save()
###### add temp product ######
tempP = TempProduct(owner=testDBModel.testUsers[0],
overlay='overlay1ol.jpg',
token='1',
category=testDBModel.testCategory[0])
tempP.save()
tempP = TempProduct(owner=testDBModel.testUsers[1],
overlay='overlay2ol.jpg',
token='2',
category=testDBModel.testCategory[0])
tempP.save()
testDBModel.testOverlay = ['overlay1ol.jpg', 'overlay2ol.jpg']
##### ## add comments ######
for i in range(4):
newOne = Comment(product=testDBModel.testProducts[i],
owner=testDBModel.testUsers[i],
content="null",
time=timezone.now())
newOne.save()
testDBModel.testComments.append(newOne)
# add to wishlist first
for i in range(4):
newOne = WishList(product=testDBModel.testProducts[i],
owner=testDBModel.testUsers[i])
newOne.save()
# add to FitList:
for i in range(4):
newOne = FitList(product=testDBModel.testProducts[i],
owner=testDBModel.testUsers[i])
newOne.save()
def add_quantity(request):
# First retrieve all the required arguments
try:
quantity_name = request.POST['name']
except:
return HttpResponse("name is missing")
else:
try:
definition = QuantityDefinition.objects.get(name=quantity_name)
except ObjectDoesNotExist:
definition = QuantityDefinition(name=quantity_name)
definition.save()
try:
object_name = request.POST['object']
except:
return HttpResponse("object is missing")
else:
try:
object = Object.objects.get(name=object_name)
except ObjectDoesNotExist:
object = Object(name=object_name)
object.save()
try:
value = float(request.POST['value'])
except KeyError:
return HttpResponse("value is missing")
except ValueError:
return HttpResponse("value should be a float")
try:
unit = request.POST['unit']
except:
return HttpResponse("unit is missing")
try:
user_name = request.POST['user']
except:
return HttpResponse("user is missing")
else:
try:
user = User.objects.get(name=user_name)
except ObjectDoesNotExist:
user = User(name=user_name)
user.save()
# Instantiate the quantity
q = Quantity(definition=definition,
object=object,
value=value,
unit=unit,
user=user,
date_entered=datetime.now()
)
# Now optionally set the remaining properties
if 'uncertainty' in request.POST:
q.uncertainty = float(request.POST['uncertainty'])
if 'origin' in request.POST:
q.origin = request.POST['origin']
# Save quantity to database
q.save()
return HttpResponse("success")
def post(self,
request,
method,
phone_number,
password,
validation_code,
invitation_code=None,
icon=DEFAULT_ICON_URL,
wechatid=None,
nickname=None,
gender=0,
province=None,
city=None):
"""注册，若成功返回用户令牌"""
if method == 'phone':
if User.objects.filter(phone_number=phone_number).count() > 0:
abort(403, '用户已经注册')
return
elif method == 'wechat':
if wechatid is None or nickname is None:
abort(400, 'wechatid 或昵称不能为空')
return
# 防止绑定过微信的用户重复绑定
if User.objects.filter(wechat_id=wechatid).count() > 0:
abort(403, '用户已经注册')
return
user = User.objects.filter(phone_number=phone_number).first()
if user is not None:
# 绑定已经使用手机号注册的账户
User.objects.filter(phone_number=phone_number).update(
wechat_id=wechatid)
return JsonResponse({'token': user.token})
else:
abort(400)
return
if not UserValidationCode.verify(phone_number, validation_code):
abort(400, '验证码错误')
with transaction.atomic():
try:
user = User(phone_number=phone_number,
wechat_id=wechatid,
city=city,
province=province,
gender=gender,
icon=icon)
user.set_password(password)
user.generate_info(phone_number)
user.save()
code, desc = register_to_huanxin(phone_number, user.password,
user.name)
if code != 200:
raise RuntimeError(desc)
if invitation_code:
self.__add_invited_users(request.user,
invitation_code.split(','))
# 加积分
user.score += get_score_stage(3)
user.score_records.create(score=get_score_stage(3),
type="初始数据",
description="首次手机号注册")
return JsonResponse({'token': user.token})
except RuntimeError as e:
print(e)
abort(403, str(e) or '创建用户失败')
from datetime import datetime
import pytz
from django.utils import timezone
from main.models import User, Property, Booking, \
Experience, Location, Rating, Review, Gallery
user1 = User(
firstName="Raymond",
lastName="Yau",
email="*****@*****.**",
)
user1.save()
location1 = Location(
city='Glasgow',
country='UK',
imgUrl="https://via.placeholder.com/300/0000FF/808080?text=GlasgowCityImage"
)
location1.save()
location2 = Location(
city='Edinburgh',
country='UK',
imgUrl=
"https://via.placeholder.com/300/0000FF/808080?text=EdinburghCityImage")
location2.save()
location3 = Location(
city='Highclere',
