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