def setUp(self):
User.objects.bulk_create([
User(id=1,
first_name='first',
last_name='last',
user_name='test',
password=1234567,
email='*****@*****.**'),
User(id=2,
first_name='we',
last_name='plash',
user_name='weplash',
email='*****@*****.**',
password=1234567)
])
Photo.objects.create(id=1, image='image', location='location')
HashTag.objects.create(id=1, name='tag')
PhotoHashTag.objects.create(id=1,
photo=Photo.objects.get(id=1),
hashtag=HashTag.objects.get(id=1))
Collection.objects.create(id=1,
name='collection',
user=User.objects.get(id=1))
PhotoCollection.objects.create(id=1,
photo=Photo.objects.get(id=1),
collection=Collection.objects.get(id=1))
def create(self, validated_data):
user = User(email=validated_data.get('email'),
fullname=validated_data.get('fullname'))
password = self.clean_password()
user.set_password(password)
user.save()
return user
def sign_up(request):
"""
Retrieves essential fields for user creation. returns 'invalid params given' for missing fields.
also returns 'Username already taken' if username is not unique.
logs the user in, right after user creation.
"""
data = json.loads(request.body)
username = data.get('username')
password = data.get('password')
phone_number = data.get('phone_number')
first_name = data.get("first_name")
last_name = data.get("last_name")
email = data.get("email")
if (username is None)\
or (password is None)\
or (phone_number is None)\
or (email is None)\
or (first_name is None)\
or (last_name is None):
return JsonResponse({"message": "invalid params give"}, status=400)
user = User(email=email,
username=username,
password=make_password(password, salt=SALT),
mobile_number=phone_number,
first_name=first_name,
last_name=last_name)
try:
user.save()
except IntegrityError:
return JsonResponse({'message': "Username already taken."}, status=400)
token = user.login_user(remember_me=False)
return JsonResponse({'token': "token " + token}, status=200)
def post(self, request):
uid = request.headers.get('Authorization')
decoded_token = auth.verify_id_token(uid)
uid = decoded_token['uid']
print(uid)
# Check if User is valid or not #
try:
firebase_user = auth.get_user(uid)
except:
message = {
"message": "User Not Valid",
"status": str(status.HTTP_403_FORBIDDEN)
}
raise AuthenticationFailed(message)
# Trying to fetch a User with Firebase uid exist's , if not create a new user and fetch user's display name #
try:
user = User.objects.get(username=uid)
user.first_name = firebase_user.display_name
user.save()
except:
user = User(username=uid,
first_name=firebase_user.display_name,
is_active=True)
user.save()
message = {
"message": "Successfully Updated first_name",
"status": str(status.HTTP_201_CREATED),
"phone": user.mobile
}
return Response(message, status.HTTP_201_CREATED)
def create(self, validated_data):
password = validated_data.pop('password')
user = User(**validated_data)
user.set_password(password)
user.is_sponsor = True
user.save()
return user
def process_request(request):
print('>>>>>>>>>>>>>>>>>>>>> THIS IS SIGNUP.PY')
clientemail = request.POST.get('first_name')
clientmessage = request.POST.get('last_name')
print('>>>>>>>>>> fname was', clientemail)
print('>>>>>>>>>> lname was', clientmessage)
# process the form (ie validation)
form = SignupForm()
if request.method == 'POST': # just submitted the form
form = SignupForm(request.POST)
if form.is_valid():
print('>>>>>>>>>>>>>>>>>> THE FORM IS VALID?')
u = User()
u.username = form.cleaned_data.get('username')
u.first_name = form.cleaned_data.get('first_name')
u.last_name = form.cleaned_data.get('last_name')
u.email = form.cleaned_data.get('email')
u.set_password(form.cleaned_data.get('password'))
u.address1 = form.cleaned_data.get('address')
u.address2 = form.cleaned_data.get('address2')
u.save()
return HttpResponseRedirect('/homepage/index/')
template_vars = {
'form': form,
}
return dmp_render_to_response(request, 'signup.html', template_vars)
def test_null_station_id(self):
username = '******'
password = '******'
user = User(username=username)
user.set_password(password)
user.kind = User.STATION
user.save()
station = Station()
station.name = 'no name'
station.user = user
station.max_sessions = 3
station.save()
# login
data = {
'username': username,
'password': password,
'api_key': settings.API_KEY
}
client = APIClient()
client.post(reverse('general:register'), data, format='json')
try:
session = Session.objects.get(user=user)
except:
session = None
data = {'token': session.token, 'api_key': settings.API_KEY}
response = self.client.post(self.url, data)
self.assertEqual(response.data, {
'status': 'error',
'reason': 'station_error'
})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def register(request):
if request.method == "POST":
uf = UserForm(request.POST)
if uf.is_valid():
username = uf.cleaned_data['username']
password = uf.cleaned_data['password']
email = uf.cleaned_data['email']
phone = uf.cleaned_data['phone']
domain = uf.cleaned_data['domain']
vip = uf.cleaned_data['vip']
clientname = uf.cleaned_data['clientname']
user = User()
user.username = username
user.password = password
user.email = email
user.phone = phone
user.domain = domain
user.vip = vip
user.clientname = clientname
user.save()
return render_to_response('success.html', {'username': username})
else:
uf = UserForm()
return render_to_response('register.html', {'uf': uf})
def get_answerlist(self, qid=None, uid=None):
""" get answers list width user evaluation by question_id and user_id
"""
if qid:
answer_list = []
cursor = connection.cursor()
if uid:
cursor.execute(
"""
select a.id,a.content,a.addtime,a.commentcount,a.favorcount,a.opposecount,u.id uid,u.email,u.name,u.surname,
e.status,e.evaluation_id as eid,u.avatar avatar from quest_answer a inner join account_user u on a.user_id=u.id left join\
quest_answerevaluation e on (a.id=e.answer_id and e.user_id=%s ) where a.question_id=%s
""", [uid, qid])
else:
cursor.execute(
"""
select a.id,a.content,a.addtime,a.commentcount,a.favorcount,a.opposecount,u.id uid,u.email,u.name,u.surname,
null as status,null as eid,u.avatar avatar from quest_answer a inner join account_user u on a.user_id=u.id
where a.question_id=%s""", [qid])
for row in cursor.fetchall():
answer=self.model(id=row[0],content=row[1],addtime=row[2],commentcount=row[3],favorcount=row[4],\
opposecount=row[5],user=User(id=row[6],email=row[7],name=row[8],surname=row[9],avatar=row[12]),\
question=Question(id=qid))
answer.evaluation = row[10]
#import pdb;pdb.set_trace()
if not row[10]:
answer.evaluation = 0
answer.eid = row[11]
answer_list.append(answer)
return answer_list
else:
return None
def register(request):
if request.method == "POST":
uf = UserFrom(request.POST)
if uf.is_valid():
username = uf.cleaned_data['username']
password = uf.cleaned_data['password']
email = uf.cleaned_data['email']
qq = uf.cleaned_data['qq']
userResult = User.objects.filter(username=username,
password=password)
#error=[]
filterResult = User.objects.filter(username=username)
if len(filterResult) > 0:
return render_to_response('hasregister.html',
{'username': username})
else:
user = User()
user.username = username
user.password = password
user.email = email
user.qq = qq
user.save()
return render_to_response('success.html',
{'username': username})
else:
uf = UserFrom()
return render_to_response('register.html', {'uf': uf})
def setUpTestData(self):
self.username = '******'
self.password = '******'
self.user = User(username=self.username)
self.user.set_password(self.password)
self.user.kind = User.STATION
self.user.save()
self.name = 'NTU'
self.station = Station()
self.station.name = self.name
self.station.user = self.user
self.station.external_id = 1
self.station.max_sessions = 3
self.station.save()
self.url = reverse('general:ping')
# login
data = {
'username': self.username,
'password': self.password,
'api_key': settings.API_KEY
}
client = APIClient()
client.post(reverse('general:register'), data, format='json')
try:
session = Session.objects.get(user=self.user)
except:
session = None
self.session = session
self.token = session.token
def register2(request):
print("hhhhhhhhh====")
if request.method == "POST":
uf = UserForm(request.POST)
if uf.is_valid():
#获取表单信息
username = uf.cleaned_data['username']
password = uf.cleaned_data['password']
phone = uf.cleaned_data['phone']
email = uf.cleaned_data['email']
#将表单写入数据库
print('1111======')
user = User()
user.username = username
user.password = password
user.phone = phone
user.email = email
user.save()
print('save======')
#返回注册成功页面
return render(request, 'success.html', {'username': username})
else:
uf = UserForm()
return render(request, 'register.html', {'uf': uf})
def show_signup(request):
if request.method == "POST":
na = request.POST['name']
m_no = request.POST['mno']
e_mail = request.POST['email']
password1 = request.POST['password1']
password2 = request.POST['password2']
#print(na,m_no,e_mail,password1)
if password1 == password2:
if User.objects.filter(email=e_mail).exists():
print('email name taken')
return redirect("home")
else:
us = User(name=str(na),
mno=str(m_no),
email=e_mail,
password=str(password1))
us.save()
messages.success(request, "thanks for signup")
print('signup succesfully')
name = User.objects.get(name=na)
return render(request, "signup.html", {'data': name})
else:
print('password not matching')
return redirect("home")
else:
return render(request, "signup.html")
def get_questions_by_id(self, id_list):
question_list = []
if id_list:
cursor = connection.cursor()
#import pdb;pdb.set_trace()
cursor.execute(
"""select q.id as qid, q.title as qtitle,q.answercount as answercount,aid,acontent,uid ,`name`,surname
,avatar,followcount from quest_question q left join (select a.id as aid,a.question_id as question_id, a.content
as acontent, au.id as uid ,au.`name` as `name`, au.surname as surname ,au.avatar as avatar from quest_answer
a left JOIN account_user au on a.user_id=au.id WHERE a.id=(select id from quest_answer a1 where
a1.question_id=a.question_id ORDER BY a1.favorcount desc limit 1 ))a2 on a2.question_id=q.id left join ( select
COUNT(question_id) as followcount,question_id from quest_qustionfollow GROUP BY question_id)qf on
qf.question_id=q.id where q.id in(""" +
','.join(['%s' for _ in id_list]) + ")", id_list)
for row in cursor.fetchall():
question = self.model(id=row[0],
title=row[1],
answercount=row[2])
if row[3]:
question.answer = Answer(id=row[3],
content=row[4],
user=User(id=row[5],
name=row[6],
surname=row[7],
avatar=row[8]))
if not row[9]:
question.followcount = 0
question_list.append(question)
return question_list
def create(self, request, *args, **kwargs):
email = request.POST.get('email', '')
password = request.POST.get('password', '')
name = request.POST.get('name', '')
if not email or not password or not name:
result = {
'result': 'error',
'error': 'No Required Field',
'error_msg': 'Email, Password, Name은 필수입니다.'
}
return JsonResponse(result)
phone = request.POST.get('phone', '')
is_partner = request.POST.get('is_partner', '')
is_partner = True if is_partner == 'true' else False
if is_partner:
center = request.POST.get('center', '')
center = Center.objects.filter(id=center).first()
if not center:
result = {
'result': 'error',
'error': 'No Required Field',
'error_msg': '직원의 경우 센터 코드는 필수입니다.'
}
return JsonResponse(result)
else:
center = None
nick_name = request.POST.get('nick_name', '')
user = User.objects.filter(email=email).first()
if user:
result = {
'result': 'error',
'error': 'User Exist',
'error_msg': '동일한 이메일을 가진 유저가 존재합니다.'
}
return JsonResponse(result)
sid = transaction.savepoint()
try:
with transaction.atomic():
user = User(username=email,
email=email,
phone=phone,
is_partner=is_partner,
center=center,
name=name,
nick_name=nick_name)
user.set_password(password)
user.save()
transaction.savepoint_commit(sid)
result = {'result': 'success', 'error': '', 'error_msg': ''}
except:
traceback.print_exc()
transaction.savepoint_rollback(sid)
result = {
'result': 'error',
'error': 'Exception in generating User',
'error_msg': '유저 생성 과정중 예외가 발생했습니다.'
}
return JsonResponse(result)
def jwt_get_username_from_payload_handler(payload):
auth0_id = payload.get('sub').replace("|", ".")
authenticate(remote_user=auth0_id)
if len(User.objects.filter(username=auth0_id).all()) < 1:
user = User()
user.username = auth0_id
user.save()
return auth0_id
def create(self, validated_data):
profile_data = validated_data.pop('profile')
password = validated_data.pop('password')
user = User(**validated_data)
user.set_password(password)
user.save()
UserProfile.objects.create(user=user, **profile_data)
return user
def insert(request):
# save()
user = User(username='******', password='******')
# user.username = '******'
# force_insert 强行添加 开发中不要使用 因为可能会违反约束,导致脏数据
# force_update 强制更新
user.save()
return HttpResponse('添加单个对象')
def __init__(self, username, email):
UserModels = User.objects.filter(username=username)
if not UserModels:
UserModels = User(username=username, email=email, password='')
UserModels.save()
self.username = username
self.email = email
self.UserModels = UserModels[0]
def setUp(self):
self.user_name = 'test'
self.user_email_id = '*****@*****.**'
self.password = '******'
self.user = User(username=self.user_name,
email_id=self.user_email_id,
password=self.password)
self.user.save()
print('user object created')
def setUp(self):
super(VDTest, self).setUp()
self.user = User()
self.user.username = SG('[\w]{30}').render()
self.user.password = SG('[\l]{6:10}&[\d]{2}').render()
self.user.save()
self.realUser = RealUser(email='*****@*****.**')
self.realUser.save()
def test_login_external_fail(self):
user = User(username='******')
user.set_password('pass')
user.save()
response = self.client.post('/api-auth/login/',
dict(username='******', password='******'))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertNotLogin()
def create_user(_username, _password, _is_admin):
md5_password = utils.get_md5_value(_password)
if _is_admin.upper() == 'Y':
admin_flag = True
else:
admin_flag = False
user = User(username=_username, password=md5_password, is_admin=admin_flag)
user.save()
return True
def m_add_student(request):
if request.method == "POST":
ret = {"status": True, "msg": None}
obj = AddStudent(request.POST)
if obj.is_valid():
username = obj.cleaned_data.get("username")
name = obj.cleaned_data.get("name")
gender = obj.cleaned_data.get("gender")
college = obj.cleaned_data.get("college")
grade = obj.cleaned_data.get("grade")
province = obj.cleaned_data.get("province")
card_id = obj.cleaned_data.get("card_id")
nation = obj.cleaned_data.get("nation")
email = obj.cleaned_data.get("email")
telephone = obj.cleaned_data.get("telephone")
qq = obj.cleaned_data.get("qq")
print(obj.cleaned_data)
grade_ = Grade.objects.get(id=grade)
try:
user = User(
username=username,
name=name,
gender=gender,
college=college,
grade=grade_,
province=province,
card_id=card_id,
nation=nation,
email=email,
telephone=telephone,
QQ=qq,
birthday=card_id[6:10] + '-' + card_id[10:12] + '-' + card_id[12:14],
role_id=3
)
user.set_password(card_id[-6:])
user.save()
ret["msg"] = "创建成功"
return HttpResponse(json.dumps(ret, ensure_ascii=False))
except ValidationError as e:
print(str(e))
ret["msg"] = str(e)
ret["status"] = False
return HttpResponse(json.dumps(ret, ensure_ascii=False))
except Exception as e:
if str(e) == "UNIQUE constraint failed: account_user.user_no":
ret["status"] = False
ret["msg"] = "学号已存在，请检查学号"
return HttpResponse(json.dumps(ret, ensure_ascii=False))
else:
ret["status"] = False
ret["msg"] = obj.errors
print(obj.errors)
return HttpResponse(json.dumps(ret, ensure_ascii=False))
def create_job_apply(self, apply_reason='bla bla bla'):
u = User(1)
u.save()
user = u
j = JobPost(1)
j.save()
jobapply = j
return JobApply.objects.create(user=user, job=jobapply, JobApplyReason=apply_reason)
def setUp(self):
user=User(username="******",email="*****@*****.**")
user.set_password("haslo123")
user.is_admin=False
user.is_active=True
user.is_customer=True
user.save()
user.customer.birth_date=datetime.date(1997,10,1)
user.customer.money=500.0
user.customer.save()
def commit(self, req):
u = User()
u.email = self.cleaned_data.get('email')
u.set_password(self.cleaned_data.get('password'))
u.save()
user = authenticate(username=u.email,
password=self.cleaned_data.get('password'))
login(req, user)
def post(self, request):
serializer = UserSerializer(data=request.data)
if not serializer.is_valid():
self.error(serializer.errors)
with transaction.atomic():
roles = serializer.validated_data.pop('roles')
user = User(**serializer.validated_data)
user.set_password(serializer.validated_data['password'])
user.save()
user.roles.set(roles)
return self.success(status=201)
def init_instance(self, row=None):
instance = super().init_instance(row)
try:
user = User.objects.get(email=row.get('email'))
except ObjectDoesNotExist:
user = User(email=row.get('email'), name=row.get('name'))
user.save()
instance.user = user
instance.client = Client.objects.get(name=row.get('client'))
instance.role = Role.objects.get(name=row.get('role'))
return instance
def staff_create(request):
form = StaffCreationForm(request.POST or None, instance=User())
print(form)
if request.POST and form.is_valid():
form.save()
msg = pgettext_lazy('Dashboard message',
'Created staff member %s') % (form['username'], )
messages.success(request, msg)
return redirect('dashboard:staff-index')
ctx = {'staff_form': form}
return TemplateResponse(request, 'dashboard/staff/detail.html', ctx)
