def create(self, attrs, instance=None):
"""
Given a dictionary of deserialized field values, either update
an existing model instance, or create a new model instance.
"""
if instance is not None:
instance.user.email = attrs.get('user.email', instance.user.email)
instance.poi = attrs.get('poi', instance.poi)
instance.user.password = attrs.get('user.password',
instance.user.password)
return instance
print attrs
user = attrs.get('user')
confirm_password = attrs.get('confirm_password')
password = user.get('password')
if password != confirm_password:
raise serializers.ValidationError('Password confirmation mismatch')
check_passwd(password, confirm_password)
user = User.objects.create_user(username=user.get('username'),
email=user.get('email'),
password=user.get('password'))
profile = Profile.objects.create(user=user,
poi=attrs.get('poi'),
email=attrs.get('email'))
p = Profile(user=user)
print p
return Profile(user=user)
def update(self, instance, attrs):
"""
Given a dictionary of deserialized field values, either update
an existing model instance, or create a new model instance.
"""
raise serializers.ValidationError('method not valid')
print attrs
if instance is not None:
user = attrs.get('user')
print instance.user.email
instance.user.email = '*****@*****.**'
instance.poi = attrs.get('poi', instance.poi)
instance.user.password = attrs.get('user.password',
instance.user.password)
print instance.user.email
instance.save()
return instance
print attrs
user = attrs.get('user')
user = User.objects.create_user(username=user.get('username'),
email=user.get('email'),
password=user.get('password'))
profile = Profile.objects.create(user=user, poi=attrs.get('poi'))
p = Profile(user=user)
print p
return Profile(user=user)
def test_it_lists_profiles_in_slices():
profiles = SQLAlchemyProfiles(db)
profiles.add(Profile('11111111', Name('Name 1')))
profiles.add(Profile('11111112', Name('Name 2')))
profiles.add(Profile('11111113', Name('Name 3')))
profiles_list = profiles.list(limit=1)
assert len(profiles_list) == 1
assert str(profiles_list[0].name) == 'Name 3'
profiles_list = profiles.list(offset=1)
assert len(profiles_list) == 2
assert str(profiles_list[0].name) == 'Name 2'
assert str(profiles_list[1].name) == 'Name 1'
profiles_list = profiles.list(limit=1, offset=1)
assert len(profiles_list) == 1
assert str(profiles_list[0].name) == 'Name 2'
profiles_list = profiles.list(offset=10)
assert len(profiles_list) == 0
def test_it_gets_profiles_by_their_email_address():
profiles = SQLAlchemyProfiles(db)
profile1 = Profile('12345678', Name('name1'))
profile1.add_email_address('*****@*****.**')
profile1.add_email_address('*****@*****.**')
profile2 = Profile('12345679', Name('name2'))
profile2.add_email_address('*****@*****.**')
profiles.add(profile1)
profiles.add(profile2)
assert profiles.get_by_email_address('*****@*****.**') == profile1
assert profiles.get_by_email_address('*****@*****.**') == profile1
assert profiles.get_by_email_address('*****@*****.**',
'*****@*****.**') == profile1
assert profiles.get_by_email_address('*****@*****.**',
'*****@*****.**') == profile1
assert profiles.get_by_email_address('*****@*****.**') == profile2
with pytest.raises(ProfileNotFound):
profiles.get_by_email_address()
with pytest.raises(ProfileNotFound):
profiles.get_by_email_address('*****@*****.**')
with pytest.raises(ProfileNotFound):
profiles.get_by_email_address('*****@*****.**', '*****@*****.**')
def setUp(self):
### USERS ###
self.password = '******'
ferromet = User()
ferromet.username = '******'
ferromet.first_name = 'FERROMET'
ferromet.set_password(self.password)
ferromet.save()
admin = User()
admin.username = '******'
admin.first_name = 'Главный куратор'
admin.set_password(self.password)
admin.save()
### PROFILES ###
profile1 = Profile()
profile1.user = admin
profile1.is_company = False
profile1.is_report = True
profile1.is_super_user = True
profile1.telefon = '+7 921 622 22 50'
profile1.save()
profile2 = Profile()
profile2.user = ferromet
profile2.save()
### COMPANYS ###
fer_com = Company()
fer_com.com_user = ferromet
fer_com.save()
### DEPS ###
dep1 = Departments()
dep1.pk = 1
dep1.company = fer_com
dep1.name = u'Основной'
dep1.save()
### PC ###
pc1 = CompanyPC()
pc1.id = 1
pc1.company = fer_com
pc1.departament = dep1
pc1.pc_nameId = '1'
pc1.pc_name = 'buh'
pc1.save()
### PC_OPTIONS ###
option1 = PcOptions()
option1.id = 1
option1.name = u'Процессор'
option1.save()
def test_it_avoids_orcid_conflicts():
profiles = SQLAlchemyProfiles(db)
profile1 = Profile('12345678', Name('name1'), '0000-0002-1825-0097')
profile2 = Profile('12345679', Name('name2'), '0000-0002-1825-0097')
profile1 = profiles.add(profile1)
profile2 = profiles.add(profile2)
assert profile1 == profile2
with pytest.raises(ProfileNotFound):
profiles.get('12345679')
def test_it_gets_profiles_by_their_orcid():
profiles = SQLAlchemyProfiles(db)
profile1 = Profile('12345678', Name('name1'), '0000-0002-1825-0097')
profile2 = Profile('12345679', Name('name2'))
profiles.add(profile1)
profiles.add(profile2)
assert profiles.get_by_orcid('0000-0002-1825-0097') == profile1
with pytest.raises(ProfileNotFound):
profiles.get_by_orcid('0000-0002-1825-0098')
def test_it_contains_profiles():
profiles = SQLAlchemyProfiles(db)
profile1 = Profile('12345678', Name('name1'), '0000-0002-1825-0097')
profile2 = Profile('12345679', Name('name2'))
profile1 = profiles.add(profile1)
profile2 = profiles.add(profile2)
assert profiles.get('12345678') == profile1
assert profiles.get('12345679') == profile2
with pytest.raises(ProfileNotFound):
profiles.get('12345670')
def test_it_avoids_email_address_conflicts():
profiles = SQLAlchemyProfiles(db)
profile1 = Profile('12345678', Name('name1'))
profile1.add_email_address('*****@*****.**')
profile2 = Profile('12345679', Name('name2'))
profile2.add_email_address('*****@*****.**')
profile1 = profiles.add(profile1)
profile2 = profiles.add(profile2)
assert profile1 == profile2
with pytest.raises(ProfileNotFound):
profiles.get('12345679')
def create_profile(request):
jwt_token = request.data.get('token')
name = request.data.get('name')
is_professor = request.data.get('is_professor')
# Validação do token
client = Client()
response = client.post('/token_verify/', request.data)
if response.status_code != HTTP_200_OK:
return response
# Decodificação do usuário
user_obj = jwt.decode(jwt_token, SECRET_KEY, algorithms=['HS256'])
user = User.objects.get(pk=user_obj['user_id'])
if is_professor:
is_professor = ast.literal_eval(is_professor)
else:
return Response(data={'error': 'Parametro invalido: is_professor'},
status=HTTP_400_BAD_REQUEST)
# Obtendo profile
if is_professor:
profile = Profile(user=user, is_professor=is_professor)
profile.save()
professor = Professor(profile=profile)
professor.save()
if name:
profile.name = name
classes = []
all_classes = Class.objects.all()
for each in all_classes:
for professor_name in each.professors:
if professor_name == name:
classes.append([each.discipline.code, each.name])
professor.classes = classes
professor.save()
profile.save()
serializer = ProfileSerializer(profile)
else:
profile = Profile(user=user, is_professor=is_professor)
profile.save()
student = Student(profile=profile)
student.save()
if name:
profile.name = name
profile.save()
serializer = ProfileSerializer(profile)
return Response(data=serializer.data, status=HTTP_200_OK)
def test_profile_delete(self):
u = User(email='*****@*****.**')
u.is_active = True
u.save()
p = Profile(contact_email='*****@*****.**', user=u)
p.save()
r = Recommendation(profile=p, reviewer_email='*****@*****.**')
r.save()
self.client.force_login(u)
response = self.client.get(reverse('profiles:user_profile_delete'))
self.assertEqual(response.status_code, HTTPStatus.OK)
User.objects.get(id=u.id)
response = self.client.post(reverse('profiles:user_profile_delete'), data={
'confirm': True,
})
self.assertEqual(response.status_code, HTTPStatus.FOUND)
self.assertEqual(response.url, reverse('profiles:user'))
p = Profile.all_objects.get(id=p.id)
self.assertNotEquals(p.deleted_at, None)
def create(self, validated_data):
user = Profile(**validated_data)
user.set_password(validated_data['password'])
user.save()
# FIXME
self.fields.pop('password')
return user
def test_it_clears_profiles():
profiles = SQLAlchemyProfiles(db)
profiles.add(Profile('11111111', Name('name')))
profiles.clear()
with pytest.raises(ProfileNotFound):
profiles.get('11111111')
def make_profile_for_new_user(sender, user, **kwargs):
new_profile = Profile(user=user,
id=user.id,
confirmed_agreements=True,
date_confirmed_agreements=timezone.now())
new_profile.save()
assign_perm('change_profile', user, new_profile)
def setUpTestData(cls): # noqa: N802
# We need a profile for a spellbook, thus we need a django user
user = User(email="*****@*****.**", password="******")
user.save()
cls.profile = Profile(user=user)
cls.profile.save()
def test_profile(self):
from profiles.models import Profile
p = Profile()
self.assertEqual(len(p.my_packages()), 0)
r = MockGithubRepo()
self.assertEqual(p.url_for_repo(r), None)
def form_valid(self, form):
self.object = form.save(commit=False)
self.object.set_password(form.cleaned_data['password1'])
self.object.save()
profile = Profile(user=self.object)
profile.save()
return HttpResponseRedirect(self.get_success_url())
def get_profile(user):
try:
return Profile.all().filter("user = ", user)[0]
except IndexError:
profile = Profile(user=user, notification=5)
profile.save()
return profile
def test_should_be_blank_if_not_yet_saved(self):
"""test student id when model instance not yet saved"""
with mute_signals(post_save):
user = UserFactory()
profile = Profile(user=user)
assert profile.student_id is None
assert profile.pretty_printed_student_id == ''
def create(self, request):
try:
first_name = request.data['first_name']
email = request.data['email']
username = request.data['username']
password = request.data['password']
user = User.objects.create_user(username, email, password)
user.first_name = first_name
user.save()
profile = Profile(user=User.objects.get(username=username))
profile.save()
serializer_context = {'request': Request(request._request)}
return Response(ProfileSerilializer(profile, context=serializer_context).data)
except (IntegrityError) as e:
if (str(e).find("username") > -1):
return Response({"errorMessage" : "Ese usuario ya ha sido tomado"}, 412)
else:
return Response({"errorMessage" : "Ese correo ya ha sido tomado"}, 412)
except (KeyError) as e:
return HttpResponse(json.dumps({"errorMessage" : "missing_fields"}), 412)
except (User.DoesNotExist):
return HttpResponse(json.dumps({"errorMessage" : "Error al crear el ususario"}), 404)
except (Exception) as e:
return Response({"errorMessage" : "Ese usuario ya ha sido tomado"}, 412)
def register_user(self, **kwargs):
form = RegistrationForm(kwargs)
if form.is_valid():
email = form.cleaned_data['username']
f_name, l_name = self._split_user_fullname(form.cleaned_data['name'])
user = User.objects.create_user(
username=email,
email=email,
password=form.cleaned_data['password'],
first_name=f_name,
last_name=l_name,
is_active=False
)
profile = Profile(
user=user,
company_name=form.cleaned_data['company_name'],
phone=form.cleaned_data['phone']
)
profile.activation_code = Profile.generate_activation_code()
profile.activation_code_hash = Profile.make_code_hash(profile.activation_code)
profile.save()
self._send_register_mail(user)
return user
else:
for f, err in form.errors.items():
raise RegisterError(err[0])
def create_conversation(request):
if request.method == 'POST':
conversation_json = json.loads(request.body)
if 'profile_id' in conversation_json and conversation_json[
'profile_id']:
temporary_profile = get_object_or_404(
Profile, pk=conversation_json['profile_id'])
else:
temporary_profile = Profile(
first_name=conversation_json['first_name'],
picture_url=
"https://www.pngitem.com/pimgs/m/421-4212341_default-avatar-svg-hd-png-download.png"
)
temporary_profile.save()
inquire = temporary_profile
mentor = get_object_or_404(Profile, pk=conversation_json['mentor'])
conversation = Conversation(inquire=inquire, mentor=mentor)
conversation.save()
return JsonResponse(
dict(success=True,
id=conversation.pk,
profile_id=temporary_profile.pk))
def _create_profile(token_data: dict) -> Profile:
if not token_data['name']:
raise InvalidRequest('No name visible')
profile = Profile(profiles.next_id(), Name(token_data['name']),
token_data['orcid'])
return profiles.add(profile)
def post(self, request, *args, **kwargs):
form = ProfileForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data.get('username')
username_obj = User.objects.get(username=username)
username = username_obj.username
raw_password = username_obj.password
first_name = username_obj.first_name
last_name = username_obj.last_name
user = authenticate(username=username, password=raw_password)
profile = Profile(
user = username_obj,
first_name = first_name,
last_name=last_name,
created_date = timezone.now()
)
profile.save()
login(request, username_obj)
return redirect('/')
else:
messages.info(request, "Error occured in signup page. ")
form = ProfileForm()
return render(request, 'blog/signup.html', {'form': form})
def register(request):
"""
kinda trick because you don't want to call is_valid() on this one
:param request:
:return:
"""
if request.POST:
form = forms.RegistrationForm(request.POST)
if form.is_valid():
print("valid")
data = form.cleaned_data
if User.objects.filter(email=data['email']).count > 1:
print("already used")
user = User.objects.create_user(
password=form.cleaned_data['password1'],
email=form.cleaned_data['email']
)
profile = Profile(
user=user,
nick=data['nick'])
profile.save()
authenticated = authenticate(email=data['email'],
password=data['password1'])
login(request, authenticated)
wallet = Wallet(user=request.user)
wallet.save()
return HttpResponseRedirect(reverse('add-photo'))
form = forms.RegistrationForm()
return render(request, 'accounts/register.html', {
'form': form
})
def register(request):
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data.get('username')
name = form.cleaned_data.get('name')
last_name = form.cleaned_data.get('last_name')
email = form.cleaned_data.get('email')
raw_password = form.cleaned_data.get('password1')
# Save user
user = authenticate(username=username, password=raw_password)
# Save profile
user_profile = Profile(user=user,
name=name,
last_name=last_name,
email=email)
user_profile.save()
login(request, user)
return redirect(index)
else:
form = RegisterForm()
return render(request, 'registration/register.html', {'form': form})
def create_credentials(actions):
"""Creates a login session with permissión for the given actions"""
app_a = App(name="Usuarios")
app_a.save()
created_actions = []
for action in actions:
created_actions.append(Action(name=action, label="", app=app_a))
for i in range(0, len(created_actions)):
created_actions[i].save()
profile = Profile(name='Admin', active=True)
profile.save()
for action in created_actions:
ProfilePermissions(profile=profile, action=action,
permission=True).save()
password = '******'
username = '******'
hasher = PBKDF2PasswordHasher()
encoded = hasher.encode(password, "Wake Up, Girls!")
user1 = User(username=username,
password=encoded,
name='ADMINISTRADOR',
lastname='ADMINISTRADOR',
active=True,
profile=profile)
user1.save()
return user1
def register_view(request):
form = UserCreationForm()
context = {}
if request.method == 'POST':
form = UserCreationForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.is_active = False
user.save()
profile = Profile(user=user,
nickname=form.cleaned_data["nickname"])
profile.save()
current_site = get_current_site(request)
message = render_to_string(
'users/active_email.html', {
'user': user,
'domain': current_site.domain,
'uid': force_text(
urlsafe_base64_encode(force_bytes(user.pk))),
'token': account_activation_token.make_token(user),
})
subject = 'Activate your Password Management account.'
to_email = form.cleaned_data.get('email')
email = EmailMessage(subject, message, to=[to_email])
email.send()
messages.add_message(
request, messages.INFO,
'Please confirm your email address to complete the registration'
)
return HttpResponseRedirect(reverse(settings.LOGIN_REDIRECT_URL))
context['form'] = form
return render(request, "users/registration.html", context)
def test_delete(self):
u = User(email='*****@*****.**')
u.is_active = True
u.save()
p = Profile(contact_email='*****@*****.**', user=u)
p.save()
r = Recommendation(profile=p, reviewer_email='*****@*****.**')
r.save()
self.client.force_login(u)
response = self.client.get(reverse('profiles:user_delete'))
self.assertEqual(response.status_code, HTTPStatus.OK)
User.objects.get(id=u.id)
response = self.client.post(reverse('profiles:user_delete'), data={
'confirm': True,
})
self.assertEqual(response.status_code, HTTPStatus.FOUND)
self.assertEqual(response.url, reverse('profiles:login'))
with self.assertRaises(User.DoesNotExist):
User.objects.get(id=u.id)
with self.assertRaises(Profile.DoesNotExist):
Profile.objects.get(id=p.id)
Recommendation.objects.get(id=r.id)
def save_employee_data(request, employee_data, line_count):
line_count = line_count + 1
if User.objects.filter(username__iexact=employee_data['email']).exists():
messages.error(
request,
f"Error! Line: {line_count} {employee_data['email']} email is taken"
)
return redirect('upload_employees')
elif User.objects.filter(email__iexact=employee_data['email']).exists():
messages.error(
request,
f"Error! Line: {line_count} {employee_data['email']} email is taken"
)
return redirect('upload_employees')
else:
# Store user detals
email = employee_data['email'].lower()
user = User.objects.create_user(first_name=employee_data['first_name'],
last_name=employee_data['last_name'],
username=employee_data['email'],
password=employee_data['password'],
email=employee_data['email'])
user.save()
companyObj = None
if Company.objects.filter(name=employee_data['company']).exists():
companyObj = Company.objects.get(name=employee_data['company'])
else:
companyObj = Company(name=employee_data['company'])
companyObj.save()
profile = Profile(user=user, company=companyObj)
profile.save()
return