def api_registration_view(request):
logger = logging.getLogger(__name__)
data = {}
email = request.data.get('email').lower()
role = request.data.get('role')
if validate_email(email) is not None:
data['error_message'] = 'That email is already in use.'
data['response'] = 'Error'
return Response(data)
instaAccount = request.data.get('instaAccount')
if validate_instaacount(
instaAccount
) is not None: # TODO: Hay que corregir la funcion validate_instaacount()
data['error_message'] = 'That instagram account is already in use.'
data['response'] = 'Error'
return Response(data)
serializer = RegistrationSerializer(data=request.data)
if request.data.get('password') != request.data.get('password2'):
data['error_message'] = 'Passwords must match'
data['response'] = 'Error'
return Response(data)
if serializer.is_valid():
user = serializer.save()
if (role == '2'):
company = Company(user=user,
instaAccount=request.data.get('instaAccount'),
phone=request.data.get('phone'))
company.save()
elif (role == '1'):
if (request.data.get('phone') is None):
profile = Profile(
user=user, instaAccount=request.data.get('instaAccount'))
profile.save()
else:
profile = Profile(
user=user,
instaAccount=request.data.get('instaAccount'),
phone=request.data.get('phone')).save()
data['response'] = 'user registered successfuly'
data['email'] = user.email
data['full_name'] = user.full_name
data['active'] = user.active
data['staff'] = user.staff
data['admin'] = user.admin
data['instaAccount'] = instaAccount
data['phone'] = request.data.get('phone')
data['role'] = role
data['timestamp'] = user.timestamp
token = Token.objects.get(user=user).key
data['token'] = token
logger.error(data)
else:
data = serializer.errors
return Response(data)
return Response(data, status=status.HTTP_201_CREATED)
def test_2_users_1_card(self, mock):
with patch('nexchange.api_clients.uphold.'
'AddressReserve.objects.filter') as filter:
with patch('nexchange.api_clients.base.BaseApiClient.'
'renew_cards_reserve') as allocate_reserver:
filter.return_value = []
allocate_reserver.return_value = True
user1 = User(username='******')
user1.save()
profile1 = Profile(user=user1)
profile1.save()
# user1 created, but has no cards
self.assertEqual(len(user1.addressreserve_set.all()), 0)
self._mock_cards_reserve(mock)
# user2 steals user1 cards
renew_cards_reserve(expected_reserve=1)
user2 = User(username='******')
user2.save()
profile2 = Profile(user=user2)
profile2.save()
self.assertEqual(len(user2.addressreserve_set.all()),
self.len_crypto_curencies)
self._mock_cards_reserve(mock)
self.assertEqual(len(user1.addressreserve_set.all()),
self.len_crypto_curencies)
def setUp(self):
# user01 생성
user = User.objects.create_user(username="******", password="******")
profile = Profile(user=user)
profile.timetable_url = 'https://everytime.kr/@VKdmH6zYuryplICMJzaf'
profile.save()
# user02 생성 // 현 유저
self.user = User.objects.create_user(username="******",
password="******")
profile2 = Profile(user=self.user)
profile2.timetable_url = 'https://everytime.kr/@7987rGNQELr5Q8SBUiNR'
profile2.save()
def update_profile(request):
if request.method == "POST":
user = User.objects.get(id=request.user.id)
try:
profile_user = Profile.objects.get(user=request.user)
except:
profile_user = Profile()
bio = request.POST['edit_bio']
interest = request.POST['edit_interests']
email = request.POST['edit_email']
github = request.POST['edit_github']
linkedin = request.POST['edit_linkedin']
if 'picture' in request.FILES:
if request.FILES['picture']:
profile_picture = request.FILES['picture']
profile_user.picture = profile_picture
else:
pass
profile_user.bio = bio
if len(bio) > 140:
messages.error(request,
'Your bio cant contain more than 140 characters')
return redirect('dashboard')
profile_user.interests = interest
profile_user.github = github
profile_user.linkedIn = linkedin
user.email = email
user.save()
profile_user.user = user
profile_user.save()
return redirect('dashboard')
def save_profile(backend, user, response, *args, **kwargs):
"""
Pipeline called when user log in.
Creates profile for the first time.
Updates groups managed by user and all other user info.
"""
if isinstance(backend, VKOAuth2):
if not hasattr(user, 'profile'):
user.profile = Profile(user=user)
user.vk_groups.clear()
groups = get_user_groups(response["access_token"])
for group in groups:
if not Group.objects.filter(gid=group["id"]).exists():
g = Group.objects.create(gid=group["id"],
name=group["name"],
photo=group["photo_200"],
members=group["members_count"])
else:
g = Group.objects.get(gid=group["id"])
g.name = group["name"]
g.photo = group["photo_200"]
g.members = group["members_count"]
g.screen_name = group["screen_name"]
g.admins.add(user)
g.save()
user.profile.avatar = response["photo"]
user.profile.access_token = response["access_token"]
user.profile.save()
def post(self, request):
form = self.form_class(request.POST or None)
if form.is_valid():
user = form.save(commit=False)
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user_email = form.cleaned_data['email']
user.set_password(password)
user.save()
profile = Profile(user=user)
profile.save()
user = authenticate(username=username, password=password)
send_mail('Social School - Email Activation',
'Link to email activation', '*****@*****.**',
[user_email])
if user is not None:
if user.is_active:
login(request, user)
return redirect('index')
else:
return render(request, self.template_name, {'form': form})
def save(self, commit=True):
self.instance.is_active = False
result = super().save(commit)
profile = Profile(user=result)
if commit:
profile.save()
return result
def _create_anonymous_user(request):
def _create_username():
_username = '******'.format(User.objects.last().pk + 1)
exists = len(User.objects.filter(username=_username))
while exists == 1:
_username += get_random_string(length=5)
exists = len(User.objects.filter(username=_username))
return _username
username = _create_username()
user_data = {}
profile_data = {}
user_data['username'] = username
profile_data.update({'disabled': True, 'anonymous_login': True})
user = User(**user_data)
user.save()
profile_data['user'] = user
profile = Profile(**profile_data)
profile.save()
next_uri = reverse('accounts.change_password')
key = create_user_key(user, usage_left=None, next=next_uri)
user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, user)
return key
def signup(request):
regist_terms=Texts.objects.get(name="regist_terms")
privacy_info_terms=Texts.objects.get(name="privacy_info_terms")
if request.method=="POST":
userform = SignupForm(request.POST)
if userform.is_valid():
user = userform.save(commit=False)
user.username = userform.cleaned_data['username']
user.save()
profile = Profile(user=user)
profile.save()
return HttpResponseRedirect(reverse("signup_ok"))
return render(request, "accounts/signup.html", {
'userform': userform,
'message':'입력정보를 정확히 확인해주세요.',
'regist_terms':regist_terms.contents,
'privacy_info_terms':privacy_info_terms.contents,
})
elif request.method=="GET":
userform = SignupForm()
return render(request, "accounts/signup.html", {
'userform':userform,
'message':'첫 화면',
'regist_terms':regist_terms.contents,
'privacy_info_terms':privacy_info_terms.contents,
})
def post(self, request):
res = {"status": 0}
user_data = AddUserForm(request.POST)
if user_data.is_valid():
try:
user = {
"username": user_data.cleaned_data["username"],
"email": user_data.cleaned_data["email"],
}
user_obj = User(**user)
user_obj.set_password(user_data.cleaned_data["password"])
user_obj.save()
profile = {
"user": user_obj,
"name": user_data.cleaned_data["name"],
"phone": user_data.cleaned_data["phone"],
"weixin": user_data.cleaned_data["weixin"]
}
Profile(**profile).save()
except Exception as e:
print(e)
res["status"] = 1
res["errmsg"] = "保存发布发生异常，请查看后台日志"
else:
err = user_data.errors.as_data()
res["status"] = 1
res["errmsg"] = get_errors_message(err)
return JsonResponse(res)
def mypage(request):
message=None
if request.method == "POST":
mypageform=MypageForm(request.POST)
if mypageform.is_valid():
profile = Profile.objects.get(user=request.user)
profile.phone = mypageform.cleaned_data['phone']
profile.postcode=request.POST.get('postcode')
profile.address=request.POST.get('address')
profile.address_detail=request.POST.get('address_detail')
check = request.POST.get('ads_agree')
if check == None :
profile.ads_agree=False
else:
profile.ads_agree=True
profile.save()
user=request.user
user.first_name = mypageform.cleaned_data['first_name']
user.save()
message = '정보가 업데이트 되었습니다.'
else:
message = mypageform.errors
user=User.objects.get(id=request.user.id)
#프로필 있는지 확인 없으면생성
try:
profile=Profile.objects.get(user=request.user)
except:
new_profile=Profile(user=request.user)
new_profile.save()
mypageform = MypageForm({'first_name':request.user.first_name, 'phone':user.profile.phone})
context={'message':message,'mypageform':mypageform, 'user':user, 'brands':get_brands(),}
return render(request,"accounts/mypage.html", context)
def form_valid(self, form):
"""
If the form is valid, redirect to the supplied URL.
"""
user = self.request.user
try:
p = user.profile
except ObjectDoesNotExist:
p = Profile(user=user)
p.save()
p.full_name = form.cleaned_data['full_name']
p.phone = form.cleaned_data['phone']
p.address = form.cleaned_data['address']
p.save()
o = Order(user=user,
session_key=self.request.session.session_key,
shipping=form.cleaned_data['shipping'])
o.save()
self.success_url = reverse('orders:ThanksForOrder',
kwargs={'pk': o.id})
return super(CreateOrderView, self).form_valid(form)
def sign_up(request):
if request.method == 'POST':
form = Register(request.POST)
if form.is_valid():
email = form.cleaned_data['email']
get_email = User.objects.filter(email=email)
for i in get_email:
if i.email == email:
messages.warning(request, 'Email already exists.')
context = {'form': form}
return render(request, 'register.html', context)
break
user = form.save()
user_profile = Profile(user=user)
user_profile.save()
messages.success(request, 'Account Created Successfully.')
return redirect('login')
else:
context = {
'form': form,
}
return render(request, 'register.html', context)
else:
form = Register()
context = {
'form': form,
}
return render(request, 'register.html', context)
def save(self):
username = self.cleaned_data["username"]
email = self.cleaned_data["email2"]
password = self.cleaned_data["password2"]
first_name = self.cleaned_data.get("first_name", "")
last_name = self.cleaned_data.get("last_name", "")
newsletter = self.cleaned_data.get("newsletter", False)
accepted_tos = self.cleaned_data.get("accepted_tos", False)
user = User(username=username,
first_name=first_name,
last_name=last_name,
email=email,
password=password,
is_staff=False,
is_active=False,
is_superuser=False)
user.set_password(password)
user.save()
profile = Profile(user=user,
wants_newsletter=newsletter,
accepted_tos=accepted_tos)
profile.save()
return user
def create(self, validated_data):
email = validated_data["email"]
username = validated_data["username"]
first_name = validated_data["first_name"]
last_name = validated_data["last_name"]
password = validated_data["password"]
profile_data = validated_data.pop("profile")
if (not validate_contact_no(None, profile_data["contact_no"])):
raise serializers.ValidationError(
"account with this contact no. exists")
user_profile = Profile(**profile_data)
#user is created and saved
user = User.objects.create_user(profile=user_profile,
email=email,
username=username,
first_name=first_name,
last_name=last_name,
password=password)
#after user is created and saved,profile is also saved in database
user_profile.save()
return user
def registration(request):
if request.user.is_authenticated:
return redirect(reverse('dashboard'))
if request.method == 'POST':
registration_form = UserRegistrationForm(request.POST)
if registration_form.is_valid():
registration_form.save()
username = request.POST['username']
password = request.POST['password1']
user = User.objects.get(username=username)
profile = Profile(user=user,
first_name=request.POST['first_name'],
surname=request.POST['last_name'],
email=request.POST['email'],
username=request.POST['username'])
profile.save()
user = auth.authenticate(username=username, password=password)
if user:
auth.login(user=user, request=request)
messages.success(request, 'You have successfully registered')
return redirect(reverse('dashboard'))
else:
messages.error(request,
'Unable to register your account at this time')
else:
registration_form = UserRegistrationForm()
return render(request, 'registration.html',
{'registration_form': registration_form})
def save_user(self, request, sociallogin, form=None):
user = super().save_user(request, sociallogin, form)
p = Profile(user=user)
p.save()
return user
def insert_db():
count = 100000
users = (User(username='******' % i,
password='******' % i, email='User email %s' % i) for i in range(count))
users = User.objects.bulk_create(users)
profiles = (Profile(user_id=users[i].pk, city='Moscow', birthday=datetime.date(7, 7, 7)) for i in range(count))
Profile.objects.bulk_create(profiles)
ingredients = (Ingredient(name='Ingredient name %s' % i,
description='Ingredient description %s' % i) for i in range(count))
ingredients = Ingredient.objects.bulk_create(ingredients)
dishes = (Dish(name='Dish name %s' % i, description='Dish description %s' % i,
author_id=users[random.randint(0, count - 1)].pk) for i in range(count))
dishes = Dish.objects.bulk_create(dishes)
ThroughModel = Dish.ingredients.through
throughs1 = [ThroughModel(ingredient_id=ingredients[i].pk, dish_id=dishes[i].pk) for i in range(count)]
throughs2 = [ThroughModel(ingredient_id=ingredients[i].pk,
dish_id=dishes[random.randint(i + 1, count - 1)].pk) for i in range(count - 2)]
throughs1.extend(throughs2)
ThroughModel.objects.bulk_create(throughs1)
comments = (Comment(author_id=users[random.randint(0, count - 1)].pk,
dish_id=dishes[random.randint(0, count - 1)].pk,
text='Comment text %s' % i, ) for i in range(3 * count))
comments = Comment.objects.bulk_create(comments)
likes1 = [Like(content_object=comments[random.randint(0, count - 1)],
author=users[i]) for i in range(count)]
likes2 = [Like(content_object=dishes[random.randint(0, count - 1)],
author=users[i]) for i in range(count)]
likes1.extend(likes2)
Like.objects.bulk_create(likes1)
favorites = (Favorite(dish=dishes[random.randint(0, count - 1)],
author=users[i]) for i in range(count))
Favorite.objects.bulk_create(favorites)
def me(self, request):
"""
Get personal account details, if logged in.
"""
if request.user.is_authenticated():
try:
profile = request.user.profile
except Profile.DoesNotExist:
p = Profile(user=request.user)
p.save()
serializer = UserSerializer(instance=request.user,
context={'request': request})
if request.method == 'PATCH':
password = request.data.pop('password', None)
serializer.update(request.user, request.data)
if password:
request.user.set_password(password)
request.user.save()
return Response(serializer.data)
else:
return Response({'authenticated': False})
def setUp(self):
self.user1 = User(
username = '******',
password = '******'
)
self.profile1 = Profile (
user = self.user1,
bio = 'This is great',
photo = 'pic.jpg',
email = '*****@*****.**')
self.project1 = Project(
title ='testuser',
description = 'This is great',
profile = self.profile1,
pub_date = '12-05-2019',
image = 'default.jpg',
website = 'http://www.gabriel.com')
self.review1 = Review (
pub_date = '12-05-2019',
author = self.profile1,
project = self.project1,
body = 'This is a great comment')
def setUp(self):
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******',
first_name="user",
last_name="serializer")
self.profile = Profile(user=self.user, role=Profile.ADMINISTRATOR)
def mypage(request):
message='get method'
if request.method == "POST":
test='post'
mypageform=MypageForm(request.POST, request.FILES)
if mypageform.is_valid():
profile = Profile.objects.get(user=request.user)
profile.userid = mypageform.cleaned_data['userid']
profile.skill = mypageform.cleaned_data['skill']
profile.context = mypageform.cleaned_data['context']
profile.server = mypageform.cleaned_data['server']
profile.race = mypageform.cleaned_data['race']
profile.image = mypageform.cleaned_data['image']
profile.save()
user=request.user
user.save()
messages.success(request, '마이페이지가 작성됐습니다. 유저 목록을 확인해주세요.')
else:
message = mypageform.errors
user=User.objects.get(id=request.user.id)
#프로필 있는지 확인 없으면생성
try:
profile=Profile.objects.get(user=request.user)
except:
new_profile=Profile(user=request.user)
new_profile.save()
mypageform = MypageForm({'userid':user.profile.userid,'skill':user.profile.skill,
'context':user.profile.context,'server':user.profile.server,
'race':user.profile.race,'image':user.profile.image})
return render(request,"accounts/mypage.html", {
'message':message, 'mypageform':mypageform
})
def mypage(request):
message='get method'
if request.method == "POST":
test='post'
mypageform=MypageForm(request.POST)
if mypageform.is_valid():
profile = Profile.objects.get(user=request.user)
profile.city = mypageform.cleaned_data['city']
profile.address = mypageform.cleaned_data['address']
profile.phone = mypageform.cleaned_data['phone']
profile.save()
user=request.user
user.first_name = mypageform.cleaned_data['first_name']
user.save()
message = 'updated'
else:
message = mypageform.errors
user=User.objects.get(id=request.user.id)
#프로필 있는지 확인 없으면생성
try:
profile=Profile.objects.get(user=request.user)
except:
new_profile=Profile(user=request.user)
new_profile.save()
mypageform = MypageForm({'first_name':request.user.first_name ,'city':user.profile.city,'address':user.profile.address, 'phone':user.profile.phone})
context={'message':message,'point':user.profile.point, 'mypageform':mypageform}
return render(request,"accounts/mypage.html", context)
def register_view(request):
if request.method == "POST":
email = request.POST['email']
username = request.POST['username']
password = request.POST['password']
password_confirm = request.POST['password_confirm']
if password != password_confirm:
messages.error(request, "password is not a match")
return render(request, "accounts/register.html")
try:
pass
user = User.objects.create_user(username, email, password)
profile = Profile(user=user)
profile.save()
except IntegrityError:
messages.error(request, "Username is taken already")
return render(request, 'accounts/register.html')
login(request, user)
messages.success(request, f'Account created for {username}!')
return redirect("accounts:user_login")
else:
# messages.error(request, "Unsuccessful registration. Invalid information.")
form = UserCreationForm()
return render(request, "accounts/register.html", {"form": form})
def register_view(request):
form = RegisterForm.UserRegisterForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
user = form.save(commit=False)
user.save()
#Authenticates user before logging in
# new_user = authenticate(username=user.username, password=password)
# login(request, new_user)
#Set default values to accounts_profile
new_entry = Profile(email=user,
ethaddress='null',
indicativecontribution=0,
actualcontribution=0,
mytoken=0,
bonustoken=0,
tokenwithdrawn=0)
new_entry.save()
print('Successfully registered')
return redirect('../')
context = {
"form": form,
}
return render(request, "register.html", context)
def setUp(self):
self.topic = Topic(name="Development")
self.topic.save()
self.tag = Tag(name="Press Release")
self.tag.save()
self.user = User(username="******",
email="*****@*****.**",
password="******")
self.user.save()
self.author = Profile(user=self.user,
job="Tech-lead",
bio="web dev from sudan")
self.author.save()
self.article = Article(main_title="Making Python",
author=self.author,
topic=self.topic,
content="Hello World")
self.article.save()
self.article.tags.add(self.tag)
self.author.save()
self.comment = Comment(article=self.article,
text="What is python any way")
self.comment.save()
self.reply = Reply(comment=self.comment, text="a programming language")
self.reply.save()
def setUp(self):
self.credentials = {
"email": "*****@*****.**",
"password": "******"
}
self.user = User.objects.create_user(
email=self.credentials['email'],
password=self.credentials['password'],
first_name="oliver",
last_name="twist",
role=1)
# THIS SHOULD BE CHANGED IF WE ARE USING CONFIRMATION EMAIL FOR USERS
self.email_confirmed, _ = EmailConfirmed.objects.get_or_create(
user=self.user)
self.email_confirmed.confirmed = True
self.email_confirmed.save()
self.token = Token.objects.get(user=self.user)
self.profile = Profile(user=self.user, instaAccount="insta")
self.profile.save()
self.event = Event(eventOwner=self.user,
eventType="A",
title="title to watch",
status="O")
self.event.save()
def userinfo(request):
model = Profile
name = Profile()
conn_user = request.user
conn_profile = Profile.objects.get(user=conn_user)
level_dict = dict(Profile.LEVEL)
if not conn_profile.profile_image:
pic_url = ""
else:
pic_url = conn_profile.profile_image.url
context = {
'id': conn_user.username,
# '이름':conn_profile.이름,
'create_date': conn_profile.create_date,
'직업': level_dict[conn_profile.직업],
'학생핸드폰번호': conn_profile.학생핸드폰번호,
'부모님핸드폰번호': conn_profile.부모님핸드폰번호,
'지점': conn_profile.지점,
'학교': conn_profile.학교,
'학교이름': conn_profile.학교이름,
'학년': conn_profile.학년,
'profile_pic': pic_url,
'회원현황': conn_profile.회원현황,
'특이사항': conn_profile.특이사항,
}
return render(request, 'mypage.html', context=context)
def signup_user(request):
if request.method == 'GET':
context = {
'form': RegisterForm(),
}
return render(request, 'accounts/signup.html', context)
else:
# &qy^a}ay4J\vpXeR
form = RegisterForm(request.POST)
if form.is_valid():
user = form.save()
profile = Profile(
user=user,
phone=request.POST['phone']
)
profile.save()
login(request, user)
return redirect('index')
else:
context = {
'form': form,
}
return render(request, 'accounts/signup.html', context)
def views_register(request):
if request.method == "POST":
first_name = request.POST['first_name']
last_name = request.POST['last_name']
username = request.POST['username']
email = request.POST['email']
city = request.POST['city']
country = request.POST['country']
password = request.POST['password']
confirm_password = request.POST['confirm_password']
if password != confirm_password:
messages.error(request, "password in not match")
return render(request, "accounts/register.html")
try:
pass
user = User.objects.create_user(username, email, password, first_name=first_name, last_name=last_name)
profile = Profile(city=city, country=country, user=user)
profile.save()
except IntegrityError:
messages.error(request, "Username is taken already")
return render(request, 'accounts/register.html')
login(request, user)
return redirect("events:musics_index")
else:
form = UserCreationForm()
return render(request, "accounts/register.html", {"form": form})
return render(request, "accounts/register.html")