def create_admin(request):
"""
creates a new admin account.
"""
if not request.user.is_superuser:
return json_response(
False,
error="You are not authorized to carry out this operation.")
else:
try:
name = request.POST["name"]
try:
first_name, last_name = name[:name.rindex(" ")].title(
), name[name.rindex(" ") + 1:]
except ValueError:
first_name, last_name = name, ""
admin = models.Admin(
username=request.POST["username"].title(),
first_name=first_name,
last_name=last_name,
email=request.POST["email"],
)
admin.is_superuser = request.POST["superuser"] == "true"
admin.set_password(request.POST["password"])
admin.save()
return json_response(True)
except IntegrityError:
return json_response(False,
error="This username is not available")
def delete(self, request):
try:
student = models.StudentModel.objects.get(id=request.POST["id"])
student.delete()
json_response(200)
except models.StudentModel.DoesNotExist:
json_response(404, error={
"summary": "Student not found"
})
def create(self, request):
student = forms.StudentModelForm(request.POST)
if student.is_valid():
student.save()
return json_response(201)
else:
return json_response(409, error={
"summary": "Invalid data",
"fields": student.errors
})
def change_password(self, request):
if authenticate(username=request.user._wrapped.__dict__[
request.user.USERNAME_FIELD],
password=request.POST["old_password"]):
request.user.set_password(request.POST["new_password"])
signals.password_changed.send(sender="change_password",
request=request,
user=request.user)
return json_response(200)
return json_response(401, error={"summary": "incorrect password"})
def get(self, request):
if models.TaskModel.objects.count() > 0:
latest_task = models.TaskModel.objects.all()[0]
return json_response(200, data={
**latest_task.dict,
"completed": request.user in latest_task.completed_by.all()
})
else:
return json_response(404, error={
"summary": "No tasks found"
})
def sign_in(self, request):
user = authenticate(request, **dictify(request.POST))
if user:
if request.GET.get("r", "false") == "false":
request.session.set_expiry(0)
login(request, user)
signals.signed_in.send(sender="sign_in",
request=request,
user=user)
return json_response(200)
return json_response(401,
error={"summary": "Invalid username or password"})
def delete_admin(request):
"""
deletes an account, only superuser admins can delete account.
"""
if not request.user.is_superuser:
return json_response(
False,
error="You are not authorized to carry out this operation.")
admin = models.Admin.objects.get(username=request.POST["username"])
for article in admin.article_set.all():
article.by = request.user
article.save()
admin.delete()
return json_response(True)
def update(self, request):
try:
student = models.StudentModel.objects.get(id=request.POST["id"])
student.first_name = request.POST.get("first_name", student.first_name)
student.last_name = request.POST.get("last_name", student.last_name)
student.email = request.POST.get("email", student.email)
student.department = request.POST.get("department", student.department)
student.reg_no = request.POST.get("reg_no", student.reg_no)
student.level = request.POST.get("level", student.level)
student.save()
return json_response(200)
except models.StudentModel.DoesNotExist:
return json_response(404, error={
"summary": "Student not found"
})
def update(self, request):
request.user.first_name = request.POST.get("first_name", request.user.first_name)
request.user.last_name = request.POST.get("last_name", request.user.last_name)
request.user.email = request.POST.get("email", request.user.email)
request.user.phone = request.POST.get("phone", request.user.phone)
request.user.save()
return json_response(200)
def sign_out(self, request):
try:
logout(request)
except:
pass
signals.signed_out.send(sender="sign_out")
return json_response(200)
def events(request):
events = []
query = request.GET.get("q", "")
from_date = request.GET.get("from")
to_date = request.GET.get("to")
if from_date and to_date:
from_date = from_date.split("-")
to_date = to_date.split("-")
for i in range(3):
from_date[i] = int(from_date[i])
to_date[i] = int(to_date[i])
events_query = models.Event.objects.filter(
name__contains=query,
date__gte=datetime(*from_date),
date__lte=datetime(*to_date))
else:
events_query = models.Event.objects.filter(name__contains=query)
for event in events_query:
events.append(event.values())
paginator = Paginator(events, 25)
page = paginator.get_page(request.GET.get("page", 1))
return json_response(True,
data={
"events": page.object_list,
"hasNextPage": page.has_next()
})
def admins(request):
"""
return the complete list of admin accounts
"""
admins_list = []
for admin in models.Admin.objects.all():
admins_list.append(admin.values())
return json_response(True, data={"admins": admins_list})
def ping(request):
"""
Returns necessary data for the current session
"""
data = request.user.blog_admin.get_dict()
data["articleCount"] = models.Article.objects.count()
data["eventCount"] = models.Event.objects.count()
data["galleryCount"] = models.GalleryImage.objects.count()
return json_response(True, data=data)
def get(self, request):
page = request.GET.get("page", 1)
data, previousPage, nextPage, numberOfPages = paginate(
[vendor.dict for vendor in models.VendorModel.objects.all()], page)
return json_response(200,
data=data,
number_of_pages=numberOfPages,
previous_page=previousPage,
next_page=nextPage)
def sign_up(self, request):
try:
user = UserModel(**dictify(request.POST))
user.set_password(request.POST["password"])
user.save()
if request.GET.get("r", "false") == "false":
request.session.set_expiry(0)
login(request, user)
signals.signed_up.send(sender="sign_up",
request=request,
user=user)
return json_response(201)
except IntegrityError as e:
print(e)
return json_response(401,
error={
"summary": "Failed to create account",
"fields": e.args
})
def complete(self, request):
try:
task = models.TaskModel.objects.get(id=request.POST["id"])
if(request.user not in task.completed_by.all()):
task.completed_by.add(request.user)
current_payment = request.user.payments.all()[0]
if not current_payment.dict["isActive"]:
return json_response(409, error={
"summary": "No active package found"
})
print(models.PaymentModel.PACKAGES_PRICES[current_payment.package][1])
request.user.balance += Decimal(models.PaymentModel.PACKAGES_PRICES[current_payment.package][1])
task.save()
request.user.save()
return json_response(200)
except models.TaskModel.DoesNotExist:
return json_response(404, error={
"summary": "Task not found"
})
def pay(self, request):
coupon_number = request.POST["coupon"]
try:
coupon = models.CouponModel.objects.get(number=coupon_number)
if coupon.used:
return json_response(401, error={
"summary": "Coupon already used"
})
current_payments = models.PaymentModel.objects.filter()
models.PaymentModel.objects.create(
user=request.user,
package=coupon.package
)
coupon.used = True
coupon.save()
return json_response(201)
except models.CouponModel.DoesNotExist:
return json_response(404, error={
"summary": "Invalid coupon number"
})
def join(request):
models.Customer(name=request.POST["name"],
email=request.POST["email"],
skills=request.POST["skills"],
reference=request.POST["reference"]).save()
Thread(target=lambda: send_mail(
"Welcome to Ctrl-X Hub",
"Hello %s, \n Thank you for joining our community. Feel free to stop by the hub within our work hours.\n Regards, Ctrl-X Hub Management."
% request.POST["name"], "*****@*****.**", [request.POST["email"]])
).start()
return json_response(True)
def verify_code(self, request):
try:
verification = models.VerificationModel.objects.get(
**{
"user__%s" % UserModel.USERNAME_FIELD:
request.POST["username"],
"code": request.POST["code"]
})
if not verification.recovery:
return json_response(
404, error={"summary": "Incorrect verification code."})
verification.verified = True
verification.save()
signals.code_verified.send(sender="verify_code",
request=request,
verification=verification)
return json_response(200)
except models.VerificationModel.DoesNotExist:
return json_response(
404, error={"summary": "Incorrect verification code."})
def get(self, request):
page = request.GET.get("page", 1)
data, previousPage, nextPage, numberOfPages = paginate([
withdrawalRequest.dict for withdrawalRequest in
models.WithdrawalRequestModel.objects.filter(user=request.user)
], page)
return json_response(200,
data=data,
number_of_pages=numberOfPages,
previous_page=previousPage,
next_page=nextPage)
def remove_profile_picture(request):
"""
removes the admin's profile picture
"""
if bool(request.user.admin.profile_picture):
try:
os.remove(request.user.admin.profile_picture.path)
except:
pass
request.user.admin.profile_picture = None
request.user.admin.save()
return json_response(True)
def change_profile_picture(request):
"""
changes the admin's profile picture
"""
if request.user.admin.profile_picture:
try:
os.remove(request.user.admin.profile_picture.path)
except:
pass
request.user.admin.profile_picture = request.FILES["picture"]
request.user.admin.save()
return json_response(True)
def reset_password(self, request):
try:
verification = models.VerificationModel.objects.get(
**{
"user__%s" % UserModel.USERNAME_FIELD:
request.POST["username"],
"code": request.POST["code"]
})
if not verification.recovery:
return json_response(
404, error={"summary": "Incorrect verification code."})
verification.recovery = False
verification.user.set_password(request.POST["new_password"])
verification.user.save()
signals.password_reset.send(sender="reset_password",
request=request,
verification=verification)
except models.VerificationModel.DoesNotExist:
return json_response(
404, error={"summary": "Incorrect verification code."})
return json_response(200)
def get(self, request):
page = request.GET.get("page", 1)
data, previousPage, nextPage, numberOfPages = paginate([
payment.dict for payment in request.user.payments.all()
], page)
return json_response(
200,
data=data,
number_of_pages=numberOfPages,
previous_page=previousPage,
next_page=nextPage
)
def update_profile(request):
"""
Update the user's profile
"""
name = request.POST["name"]
request.user.first_name = name[:name.rindex(" ")]
request.user.last_name = name[name.rindex(" ") + 1:]
request.user.__dict__[
models.User.get_email_field_name()] = request.POST["email"]
request.user.admin.description = request.POST["description"]
request.user.admin.save()
request.user.save()
return json_response(True)
def get_active(self, request):
if request.user.payments.count() > 0:
current_payment = request.user.payments.all()[0]
if current_payment.dict["isActive"]:
return json_response(
200,
data=current_payment.dict,
)
else:
return json_response(
404,
error={
"summary": "No active package found"
}
)
else:
return json_response(
404,
error={
"summary": "No active package found"
}
)
def get(self, request):
department = request.GET.get("department", "")
level = request.GET.get("level", "")
query = request.GET.get("query", "")
queryset = models.StudentModel.objects.filter(
Q(first_name__contains=query) |
Q(last_name__contains=query) |
Q(email__contains=query),
department__contains=department,
level__contains=level
)
return json_response(200, data=[
student.dict for student in queryset
])
def send_verification_code(self, request):
verification = services.create_verification(request)
if type(verification) is not models.VerificationModel:
return verification
message = "Your verification code is %s" % (verification.code)
verification.recovery = True
verification.save()
error = "Failed to send verification code to %s <%s> by email\n %s" % (
verification.user.__dict__[UserModel.USERNAME_FIELD],
verification.user.__dict__[UserModel.get_email_field_name()], "%s")
Thread(target=lambda: services.send_verification_mail(
verification, "Account VerificationModel", message, error)).start(
)
signals.verification_code_sent.send(sender="send_verification_code",
request=request,
verification=verification)
return json_response(200)
def save_event(request):
if request.POST.get("pk"):
event = models.Event.objects.get(pk=request.POST["pk"])
else:
event = models.Event()
date = request.POST["date"].split("-")
for i in range(3):
date[i] = int(date[i])
event.name = request.POST["name"]
event.notes = request.POST["notes"]
event.date = datetime.datetime(*date)
if request.POST["picture"].isnumeric():
event.picture = models.FileLikeObject.objects.get(
pk=request.POST["picture"])
else:
event.picture = None
event.save()
return json_response(True,
data={"eventCount": models.Event.objects.count()})
def create_verification(request):
"""
creates a verification object and attaches it to the user
"""
username = request.POST.get("username")
if username:
try:
user = UserModel.objects.get(**{
UserModel.USERNAME_FIELD: username
})
except UserModel.DoesNotExist:
return json_response(404, error={
"summary": "Account not found"
})
else:
user = request.user
verification, created = models.VerificationModel.objects.get_or_create(user=user)
if created or not verification.username_signature:
verification.username_signature = signing.Signer().signature(user.get_username())
if request.POST.get("mode", "") == "send":
verification.code = code_generator.generate_number_code(settings.ACCOUNTS_APP["code_length"])
verification.code_signature = signing.Signer().signature(verification.code)
verification.save()
return verification
