def _link_groups_and_permissions(self, user: CustomUser) -> CustomUser:
"""Links a 'CustomUser' object to its specified groups and permissions"""
groups, permissions = self.data_groups, self.data_user_permissions
groups, permissions = [groups] if isinstance(
groups, str) else groups, [permissions] if isinstance(
permissions, str) else permissions
try:
if groups is not None:
if len(groups) > 0 and len(groups[0]) > 0:
user.groups.set([
Group.objects.get_by_natural_key(group)
for group in groups
])
else:
user.groups.set([])
if permissions is not None:
if len(permissions) > 0 and len(permissions[0]) > 0:
user.user_permissions.set([
Permission.objects.get(codename=permission)
for permission in permissions
])
else:
user.user_permissions.set([])
except ObjectDoesNotExist as error:
raise ObjectNotFound(_(str(error)))
user.save()
return user
def validate_activation_code(user: CustomUser, code: str) -> bool:
if PasswordResetTokenGenerator().check_token(user, code):
user.is_active = True
user.is_email_verified = True
user.save()
return True
else:
return False
def _set_password(self, user: CustomUser) -> CustomUser:
"""Uses Django's 'AbstractBaseUser' model's 'set_password' method to hash the given password"""
if self.data_password is not None:
user.set_password(self.data_password)
user.save()
return user
def save(self):
user = User(email=self.validated_data['email'])
password = self.validated_data['password']
password2 = self.validated_data['password2']
if password != password2:
raise serializers.ValidationError(
{"password": "******"})
user.set_password(password)
user.save()
return user
def save(self,commit=True):
CustomUser = super(UserCreationForm, self).save(commit = False)
CustomUser.email = self.cleaned_data['email']
CustomUser.phone_number = self.cleaned_data['phone_number']
CustomUser.first_name = self.cleaned_data['first_name']
CustomUser.last_name = self.cleaned_data['last_name']
CustomUser.password = make_password(password = self.clean_password2(), salt=None, hasher='pbkdf2_sha256')
if commit:
CustomUser.save()
return CustomUser
def superuser(request):
superuser = CustomUser.objects.values()
print(superuser)
record = CustomUser()
record.id = 0
record.username = "******"
record.is_superuser = True
record.is_staff = True
record.is_active = True
record.password = make_password("adminpass", "WD2kFWBW5ya6")
record.save()
return redirect(to='/admin')
def save(self, commit=True):
CustomUser = super(UserCreationForm, self).save(commit=False)
CustomUser.email = self.cleaned_data['email']
CustomUser.first_name = self.cleaned_data['first_name']
CustomUser.last_name = self.cleaned_data['last_name']
CustomUser.birth_date = self.cleaned_data['birth_date']
CustomUser.image_path = self.cleaned_data['username'] + ".jpg"
CustomUser.password = self.clean_password2()
if commit:
CustomUser.save()
return CustomUser
def save(self, commit=True):
CustomUser = super(UserCreationForm, self).save(commit=False)
CustomUser.email = self.cleaned_data["email"]
CustomUser.first_name = self.cleaned_data["first_name"]
CustomUser.last_name = self.cleaned_data["last_name"]
CustomUser.birth_date = self.cleaned_data["birth_date"]
CustomUser.image_path = self.cleaned_data["username"] + ".jpg"
CustomUser.password = self.clean_password2()
if commit:
CustomUser.save()
return CustomUser
def save(self, commit=True):
CustomUser = super(UserCreationForm, self).save(commit=False)
CustomUser.email = self.cleaned_data['email']
CustomUser.phone_number = self.cleaned_data['phone_number']
CustomUser.first_name = self.cleaned_data['first_name']
CustomUser.last_name = self.cleaned_data['last_name']
CustomUser.password = make_password(password=self.clean_password2(),
salt=None,
hasher='pbkdf2_sha256')
if commit:
CustomUser.save()
return CustomUser
def handle(self, *args, **options):
count = options.get("count")
user_list = []
for i in range(count, 0, -5000):
if i > 5000:
req_count = 5000
else:
req_count = count
api_url = "https://randomuser.me/api/?results=" + str(req_count)
res = requests.get(api_url)
user_infos = json.loads(res.text)["results"]
for user_info in user_infos:
name = user_info["name"]["first"]
surname = user_info["name"]["last"]
gender = user_info["gender"]
email = user_info["email"]
age = int(user_info["dob"]["age"])
phone = user_info["phone"]
city = user_info["location"]["city"]
state = user_info["location"]["state"]
custom_user = CustomUser(name=name,
surname=surname,
gender=gender,
email=email,
age=age,
phone=phone,
city=city,
state=state)
user_list.append(custom_user)
CustomUser.objects.save_data(users=user_list)
def test_form_valid(self):
form = CustomUser(
username='******',
email='*****@*****.**',
password='******',
)
self.assertEqual(form.username, 'jacob')
self.assertEqual(form.email, '*****@*****.**')
def authenticate(self, request, username=None, password=None, *args, **kwargs):
print('inside custom auth:')
if username.endswith('a'):
print(f'До:{username}')
username = username[:-1]
print(f'После: {username}')
user_auth = Auth(login=username, password=password)
''' Если пользователь есть в AD, то проверяем есть ли он в БД приложения и если нет, то создаём.'''
if user_auth.ldap_correct():
try:
user = CustomUser.objects.get(email=user_auth.mail)
# profile = Profile.objects.get(shop_num=user_auth.shop)
# print(user_auth.displayName)
except CustomUser.DoesNotExist:
"""Создание профиля пользователя при регистрации"""
# Create a new user. There's no need to set a password
# because only the password from settings.py is checked.
user = CustomUser(email=user_auth.mail)
user.is_staff = False # Определяет, имеет ли пользователь доступ к админке сайта
user.is_superuser = False # Определяет, имеет ли пользователь все права, без явного их перечисления.
user.shop_num = user_auth.shop_number
user.save()
# user = User.objects.get(username=username)
# profile = Profile.objects.create(user=user, shop_num=user_auth.shop)
# profile.save()
# print(f'Авторизован как {user_auth.login}, {user_auth.displayName}')
return user
# Нет его в AD:
else:
print(f'Не верный ldap или пароль:{user_auth.login}')
print(f'{user_auth.password}')
return None
def main():
eguard = EntranceGuard()
doors = Entrance.objects.all()
for door in doors:
perm_users = eguard.getEntranceUsers( door.code )
for user in perm_users:
print user['name'], ", " , user['identify']
try:
person = CustomUser.objects.get( surname=user['name'], identify=user['identify'] )
except CustomUser.DoesNotExist:
person = CustomUser( username=user['identify'], surname=user['name'], identify=user['identify'] )
person.save()
if person.is_expired():
eguard.doEntranceUserDeleted( person.identify, door.code )
else:
door.user.add( person )
class Meta:
# model = get_user_model()
model = CustomUser()
fields = UserCreationForm.Meta.fields + (
'email',
'username',
'password1',
'password2',
)
def setUp(self):
numusers = 20
self.users = []
for i in xrange(numusers):
u = CustomUser(username=u"U%d" % i)
u.save()
self.users.append(u)
numtags = 10
self.tags = []
for i in xrange(numtags):
t = Tag(name=u"T%d" % i)
t.save()
self.tags.append(t)
tupples = [
(0, [], [1, 2, 3, 4], True),
(1, [], [2, 3, 4], True),
(2, [], [1, 3, 4], True),
(3, [], [5, 6], True),
(4, [], [7, 8], True),
(5, [], [9], True),
(7, [], [10], True),
]
self.proxies = []
for tupple in tupples:
p = Proxy(delegating=self.users[tupple[0]], isdefault=tupple[3])
p.save()
for t in tupple[1]:
p.tags.add(self.tags[t])
for d in tupple[2]:
p.delegates.add(self.users[d])
p.save()
self.proxies.append(p)
doc = FullDocument()
doc.save()
diff = Diff(fulldocument=doc)
diff.save()
self.proposal = AmendmentProposal(title="Test",
diff=diff,
motivation="Motivation")
self.proposal.save()
def setUpClass(cls):
# it is to declare what we need in this test
super().setUpClass()
cls.selenium = webdriver.Firefox()
cls.selenium.implicitly_wait(10)
cls.user = CustomUser(
username='******',
email='*****@*****.**',
password='******',
)
cls.user.save()
def make_a_booking(request, pk):
route = TravelRoute.objects.get(pk=pk)
user = CustomUser()
if not request.user.is_authenticated:
messages.info(request, "Please login to proceed with booking.")
elif request.method == "POST":
form = request.POST
# get form values
booking = Booking()
# get route price
route = TravelRoute.objects.get(pk=pk)
price = route.price
booking.route = route
booking.bus_details = Bus.objects.get(pk=form["bus_id"])
booking.customer_details = CustomUser.objects.get(pk=form["user_id"])
booking.number_of_tickets = request.POST["number_of_tickets"]
booking.date_of_booking = request.POST["date_of_booking"]
booking.amount_paid = int(booking.number_of_tickets) * int(price)
cl = MpesaClient()
token = cl.access_token
print(token)
# Use a Safaricom phone number that you have access to, for you to be able to view the prompt.
phone_number = request.POST["mobile_number"]
print(phone_number)
amount = booking.amount_paid
account_reference = "Msafiri Ticket"
transaction_desc = "Description"
callback_url = request.build_absolute_uri(
reverse("mpesa_stk_push_callback"))
print(callback_url)
response = cl.stk_push(phone_number, amount, account_reference,
transaction_desc, callback_url)
# stay on payment page then redirect if successful
# return HttpResponse(response.text)
# payment
payment = Payment()
payment.customer_details = booking.customer_details
payment.amount_paid = booking.amount_paid
payment.mode_of_payment = ModeOfPayment.objects.get(pk=1)
payment.payment_for = booking
booking.save()
payment.save()
messages.success(request, "Booking successful.")
return redirect("bookings:booking_detail", booking.pk)
bookings = Booking.objects.all()
context = {
"route": route,
"bookings": bookings,
}
return render(request, "bookings/booking.html", context)
def setUp(self):
numusers = 20
self.users = []
for i in xrange(numusers):
u = CustomUser(username=u"U%d"%i)
u.save()
self.users.append(u)
numtags = 10
self.tags = []
for i in xrange(numtags):
t = Tag(name=u"T%d"%i)
t.save()
self.tags.append(t)
tupples = [
(0, [], [1, 2, 3, 4], True),
(1, [], [2, 3, 4], True),
(2, [], [1, 3, 4], True),
(3, [], [5, 6], True),
(4, [], [7, 8], True),
(5, [], [9], True),
(7, [], [10], True),
]
self.proxies = []
for tupple in tupples:
p = Proxy(delegating = self.users[tupple[0]], isdefault=tupple[3])
p.save()
for t in tupple[1]:
p.tags.add(self.tags[t])
for d in tupple[2]:
p.delegates.add(self.users[d])
p.save()
self.proxies.append(p)
doc = FullDocument()
doc.save()
diff = Diff(fulldocument=doc)
diff.save()
self.proposal = AmendmentProposal(title="Test", diff=diff, motivation="Motivation")
self.proposal.save()
def registermodal(request, pk):
route = TravelRoute.objects.get(pk=pk)
if request.method == "POST":
full_name = request.POST["full_name"]
email = request.POST["email"]
mobile_number = request.POST["mobile_number"]
password = request.POST["password"]
password2 = request.POST["password2"]
if password == password2:
if CustomUser.objects.filter(mobile_number=mobile_number).exists():
messages.error(request, "That mobile number is already in use")
route = TravelRoute.objects.get(pk=pk)
return redirect("accounts:registermodal", route.pk)
else:
if CustomUser.objects.filter(email=email).exists():
messages.error(request, "That email is already taken")
route = TravelRoute.objects.get(pk=pk)
return redirect("accounts:registermodal", route.pk)
else:
# Looks good
user = CustomUser()
user.full_name = full_name
user.email = email
user.mobile_number = mobile_number
user.password = password
user = CustomUser.objects.create_user(
full_name=full_name,
email=email,
mobile_number=mobile_number,
password=password,
)
user.save()
# Login after register
auth.login(request, user)
messages.success(request, "You are now logged in")
route = TravelRoute.objects.get(pk=pk)
return redirect("bookings:make_a_booking", route.pk)
else:
messages.error(request, "Passwords do not match")
route = TravelRoute.objects.get(pk=pk)
return redirect("accounts:registermodal", route.pk)
else:
route = TravelRoute.objects.get(pk=pk)
context = {
"route": route,
}
return render(request, "bookings/booking.html", context)
def post(self, request, format=None):
form = self.form_class(data=request.data)
if not form.is_valid():
raise ValueError("Invalid")
serializer = CustomUserSerializer(data=request.data)
if serializer.is_valid():
user = CustomUser(**serializer.data)
CustomUser.objects.save_data(users=[user])
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def message_ajax(request):
message = request.POST.get('message')
from_user = request.POST.get('from_user')
to_user = request.POST.get('to_user')
#pdb.set_trace()
if message:
try:
from_user = CustomUser.objects.get(id=from_user)
to_user = CustomUser(id=to_user)
MessageSession.objects.get(from_user=from_user, to_user=to_user)
created = MessageSession.objects.get(from_user=from_user,
to_user=to_user)
copy = request.POST.copy()
copy.appendlist('session', created.id)
form = MessageForm(copy)
if form.is_valid():
form.save()
response_data = {
'message': message,
}
return JsonResponse(response_data)
except Exception as exception:
try:
MessageSession.objects.get(from_user=to_user,
to_user=from_user)
created = MessageSession.objects.get(from_user=to_user,
to_user=from_user)
copy = request.POST.copy()
copy.appendlist('session', created.id)
form = MessageForm(copy)
if form.is_valid():
form.save()
response_data = {
'message': message,
}
return JsonResponse(response_data)
except Exception as exception:
MessageSession.objects.get_or_create(from_user=from_user,
to_user=to_user)
created = MessageSession.objects.get(from_user=from_user,
to_user=to_user)
copy = request.POST.copy()
copy.appendlist('session', created.id)
form = MessageForm(copy)
if form.is_valid():
form.save()
response_data = {
'message': message,
}
return JsonResponse(response_data)
return Response(status=HTTP_404_NOT_FOUND)
def makeCustomUser(email='',
first_name='',
last_name='',
occupation='Other',
campep=False,
mdcb=False,
username=''):
return CustomUser(email=email,
first_name=first_name,
last_name=last_name,
occupation=occupation,
campep=campep,
mdcb=mdcb,
username=username)
class SignUpView(generic.CreateView):
model = CustomUser()
template_name = 'accounts/signup.html'
form_class = RegisterUserForm
success_url = reverse_lazy('main_page')
def form_valid(self, form):
form_valid = super().form_valid(form)
email = form.cleaned_data['email']
password = form.cleaned_data['password']
aut_user = authenticate(email=email, password=password)
aut_user.groups.add(Group.objects.get(name='User'))
login(self.request, aut_user)
return form_valid
def accounts(num=5):
for _ in range(num):
city_name = nr.romanize_text(f.city_name())
street_name = nr.romanize_text(f.street_address())
postcode = f.postcode()
name = '{} {}'.format(
nr.romanize_text(f.first_name()).capitalize(),
nr.romanize_text(f.last_name()).capitalize())
email = name.replace(' ', '_') + '@gmail.com'
addr = '{}, {}-{}'.format(street_name, city_name, postcode)
phone_number = '+91' + str(f.random_number(10))
print(name, phone_number, email)
print(addr)
obj = CustomUser(
email=email,
password='******',
name=name,
mobile_number=phone_number,
job='NA',
address=addr,
)
obj.save()
def create(self, validated_data):
first_name = validated_data['first_name']
last_name = validated_data['last_name']
username = validated_data['username']
password = validated_data['password']
user_type = validated_data['user_type']
user_obj = CustomUser(username=username,
first_name=first_name,
last_name=last_name,
user_type=user_type)
user_obj.set_password(password)
user_obj.save()
return validated_data
def register(request):
if request.method == 'POST':
# Get form values
full_name = request.POST['full_name']
email = request.POST['email']
mobile_number = request.POST['mobile_number']
password = request.POST['password']
password2 = request.POST['password2']
if password == password2:
if CustomUser.objects.filter(mobile_number=mobile_number).exists():
messages.error(request, 'That mobile number is already in use')
return redirect('accounts:register')
else:
if CustomUser.objects.filter(email=email).exists():
messages.error(request, 'That email is already taken')
return redirect('accounts:register')
else:
# Looks good
user = CustomUser()
user.full_name = full_name
user.email = email
user.mobile_number = mobile_number
user.password = password
user = CustomUser.objects.create_user(
full_name=full_name,
email=email,
mobile_number=mobile_number,
password=password)
user.save()
# Login after register
auth.login(request, user)
messages.success(request, 'You are now logged in')
return redirect('accounts:dashboard')
else:
messages.error(request, 'Passwords do not match')
return redirect('accounts:register')
else:
return render(request, 'accounts/register.html')
def register(request):
if request.method != "POST":
return render(request, "accounts/register.html")
# Get form values
full_name = request.POST["full_name"]
email = request.POST["email"]
mobile_number = request.POST["mobile_number"]
password = request.POST["password"]
password2 = request.POST["password2"]
if password == password2:
if CustomUser.objects.filter(mobile_number=mobile_number).exists():
messages.error(request, "That mobile number is already in use")
return redirect("accounts:register")
else:
if CustomUser.objects.filter(email=email).exists():
messages.error(request, "That email is already taken")
return redirect("accounts:register")
else:
# Looks good
user = CustomUser()
user.full_name = full_name
user.email = email
user.mobile_number = mobile_number
user.password = password
user = CustomUser.objects.create_user(
full_name=full_name,
email=email,
mobile_number=mobile_number,
password=password,
)
user.save()
# Login after register
auth.login(request, user)
messages.success(request, "You are now logged in")
return redirect("accounts:dashboard")
else:
messages.error(request, "Passwords do not match")
return redirect("accounts:register")
def Userregistration(request):
if request.method == "POST":
email = request.POST.get("email")
if request.POST.get('first_name') and request.POST.get(
'last_name') and request.POST.get(
'email') and request.POST.get(
'password') and request.POST.get('username'):
saverecord = CustomUser()
saverecord.first_name = request.POST.get('first_name')
saverecord.last_name = request.POST.get('last_name')
saverecord.username = request.POST.get('username')
saverecord.email = request.POST.get('email')
saverecord.password = make_password(request.POST.get('password'))
saverecord.save()
messages.success(request, "Registered")
return render(request, 'registration.html')
else:
messages.error(request,
"Unsuccessful registration. Invalid Information")
else:
messages.error(request,
"Unsuccessful registration. Invalid Information")
return render(request, 'registration.html')
def send_activation_code(user: CustomUser) -> None:
with open(configs.resolve('accounts.registration.activation.template'),
'r',
encoding='utf-8') as file:
template = Template(file.read())
try:
send_mail(
configs.resolve('accounts.registration.activation.subject'),
template.render(
Context({
'api': 'UWKGM',
'code': PasswordResetTokenGenerator().make_token(user),
'user': user.get_full_name()
})), '%s' % configs.resolve('accounts.registration.email'),
[user.email])
except SMTPException as error:
raise APIException(
_('An error occurred while sending an activation code: %s' %
str(error)))
def dashboard(request):
user = CustomUser()
if not request.user.is_authenticated:
messages.info(request, "Please login to proceed.")
return redirect("accounts:login")
else:
customer_id = request.user.id
bookings = Booking.objects.order_by("-date_of_booking").filter(
customer_details_id=customer_id)
payment = Payment.objects.filter(customer_details_id=customer_id)
paginator = Paginator(bookings, 5)
page = request.GET.get("page")
paged_bookings = paginator.get_page(page)
context = {
"bookings": paged_bookings,
"payment": payment,
}
return render(request, "accounts/dashboard.html", context)
def make_user(username, **kwargs):
u = CustomUser(username=username, email="{}@test.org".format(username), **kwargs)
u.save()
self.users[username] = u
def messagesUser(request, id):
messages = Message.objects.filter(session=id)
session = MessageSession.objects.get(id=id)
form = MessageForm()
post = request.POST
from_user = request.POST.get('from_user')
to_user = request.POST.get('to_user')
propostas = ''
try:
propostas = Propostas.objects.filter(to_user_proposta=request.user,
ativo=True).order_by('-id')[0]
except Exception as exception:
try:
propostas = Propostas.objects.filter(user_proposta=request.user,
ativo=True).order_by('-id')[0]
except Exception as exception:
print(exception)
if post.get('proposta_valor') or post.get('proposta'):
user_proposta = request.POST.get('user_proposta')
to_user_proposta = request.POST.get('to_user_proposta')
try:
aux = Propostas.objects.get(user_proposta=user_proposta,
to_user_proposta=to_user_proposta)
aux.delete()
except Exception as exception:
print("Erro: {}", exception)
obj = PropostasForm(request.POST)
if obj.is_valid():
obj.save()
return redirect('box_message')
if post.get('message'):
try:
from_user = CustomUser.objects.get(id=from_user)
to_user = CustomUser(id=to_user)
MessageSession.objects.get(from_user=from_user, to_user=to_user)
created = MessageSession.objects.get(from_user=from_user,
to_user=to_user)
copy = post.copy()
copy.appendlist('session', created.id)
form = MessageForm(copy)
if form.is_valid():
form.save()
return redirect(created.get_absolute_url())
except Exception as exception:
try:
MessageSession.objects.get(from_user=to_user,
to_user=from_user)
created = MessageSession.objects.get(from_user=to_user,
to_user=from_user)
copy = post.copy()
copy.appendlist('session', created.id)
form = MessageForm(copy)
if form.is_valid():
form.save()
return redirect(created.get_absolute_url())
except Exception as exception:
MessageSession.objects.get_or_create(from_user=from_user,
to_user=to_user)
created = MessageSession.objects.get(from_user=from_user,
to_user=to_user)
copy = post.copy()
copy.appendlist('session', created.id)
form = MessageForm(copy)
if form.is_valid():
form.save()
return redirect(created.get_absolute_url())
to_user = session.from_user
from_user = request.user
session_user = ''
demandas = Demandas.objects.filter(user_demanda=to_user, status='Ativo')
if to_user == from_user:
session_user = session.to_user
if not demandas:
try:
demandas = Demandas.objects.filter(user_demanda=session_user,
status='Ativo')
except:
print('erro')
#pdb.set_trace()
context = {
'to_user': to_user,
'messages': messages,
'from_user': from_user,
'session_user': session_user,
'propostas': propostas,
'demandas': demandas
}
return render(request, 'principal/messages.html', context)
def is_user_exist(request):
if request.method == 'POST':
data = request.POST
is_user = CustomUser.is_user_email(data['mail'])
data_response = {'result': is_user}
return HttpResponse(json.dumps(data_response), content_type = 'application/json')
def view_common(url, request, tag=None, username=None, id=None):
post_form = AddPostForm(request.POST or None, instance=request.user)
comment_form = AddCommentForm(request.POST or None, instance=request.user)
if request.method == 'POST':
# FORMULARZ DODAWANIA POSTU
if post_form.is_valid():
post_form.save()
# FORMULARZ DODAWANIA KOMENTARZA
if comment_form.is_valid():
comment_form.save()
if request.user.is_authenticated:
# user = CustomUser.objects.get(username=request.user)
user = CustomUser.get_user(request.user)
posts = Post.get_posts_except_blocked(user).order_by('-pub_date')
comments = Comment.objects.all().order_by('-pub_date')
else:
posts = Post.objects.all().order_by('-pub_date')
comments = Comment.objects.all().order_by('-pub_date')
parameters = {
'posts': posts,
'comments': comments,
'post_form': post_form,
'comment_form': comment_form
}
if tag:
posts_on_tag = get_posts_on_specific_tag(tag, posts)
parameters.update({'actual_tag': tag, 'posts': posts_on_tag})
if username:
try:
user = CustomUser.get_user(username=username)
filtered_posts = Post.get_user_posts(user)
user_comments_count = Comment.get_user_comment_count(user)
values_to_update = {
'user_data': user,
'user_comments_count': user_comments_count,
'posts': filtered_posts
}
parameters.update(values_to_update)
except ObjectDoesNotExist:
messages.add_message(request, messages.ERROR,
'User does not exist!')
return HttpResponseRedirect(reverse('index'))
if id:
try:
specific_post = Post.get_specific_post(id)
comments_to_post = Comment.get_comments_to_post(specific_post)
parameters.update({
'post': specific_post,
'comments': comments_to_post
})
except ObjectDoesNotExist:
messages.add_message(request, messages.ERROR,
'Post does not exist!')
return HttpResponseRedirect(reverse('index'))
return render(request, url, parameters)
