示例#1
0
def signup(request):
    if request.method == 'POST':
        print(request.POST)
        # username = request.POST.get('username')
        first_name = request.POST.get('firstname')
        last_name = request.POST.get('lastname')
        email = request.POST.get('email')
        phonenumber = request.POST.get('phonenumber')
        confirm_pass = request.POST.get('confirmpwd')
        password = request.POST.get('pwd')
        if password == confirm_pass:
            if User().objects.filter(email=email).exists():
                messages.info(request, 'Email Taken, Please try again')
                return redirect('app:signup')
            else:
                user = User()(email=email)
                user.first_name = first_name
                user.last_name = last_name
                user.phonenumber = phonenumber
                user.set_password(password)
                # user.password = password
                user.save()
                print(f"user saved. Instance is :{user}")
                return redirect('app:login')
        else:
            messages.error(request, 'Password mismatch')
            return redirect("app:signup")
    return render(request, "app/signup.html")
示例#2
0
 def setUp(self):
     user = User().objects.create_user(email="*****@*****.**",
                                       password="******",
                                       first_name='userfromT')
     user.save()
     user1 = User().objects.create_user(email="*****@*****.**",
                                        password="******",
                                        first_name='seconduserfromT')
     user1.save()
示例#3
0
 def setUp(self):
     super(ArticleTests, self).setUp()
     app = "organization_magazine"
     model = "article"
     self.url = urlresolvers.reverse("admin:%s_%s_add" % (app, model))
     organization = Organization.objects.create()
     User().objects.create_user(username="******", password='******')
     self.department = Department.objects.create(organization=organization)
     self.user = User().objects.create_user(username="******", password="******")
     self.article = Article.objects.create(
         department=self.department,
         user=self.user
     )
示例#4
0
    def setUp(self):
        self.client = Client()
        self.admin_user = User().objects.create_superuser(
            email='*****@*****.**',
            password='******'
        )

        self.client.force_login(self.admin_user)
        self.user = User().objects.create_user(
            email='*****@*****.**',
            password='******',
            name='Test 010010 2020'
        )
示例#5
0
class Profile(models.Model):
    user = models.OneToOneField(User(),
                                on_delete=models.CASCADE,
                                primary_key=True)
    email_confirmed = models.BooleanField(default=False)

    objects = ProfileManager()

    def __str__(self):
        return f'{self.user}'

    @receiver(post_save, sender=User())
    def update_user_profile(sender, instance, created, **kwargs):
        if created:
            Profile.objects.create(user=instance)
        instance.profile.save()
示例#6
0
 def setUp(self):
     super(URLTests, self).setUp()
     self.basic_user = User().objects.create_user(username="******",
                                                  password='******')
     """
     This simulate an event creation on front,
     a keyword is created when keywords field is filled
     """
     keyword = Keyword.objects.create(title="scientific event")
     self.event_tagged = Event.objects.create(
         title="mon-evenement",
         start=datetime.date.today() + datetime.timedelta(days=1),
         user=self.basic_user,
         keywords_string="scientific event")
     AssignedKeyword.objects.create(keyword_id=keyword.id,
                                    content_object=self.event_tagged)
     Season.objects.create(
         title="s1",
         start=datetime.datetime.strptime("2016-06-01", "%Y-%m-%d"),
         end=datetime.datetime.strptime("2016-05-31", "%Y-%m-%d"))
     Season.objects.create(
         title="s2",
         start=datetime.datetime.strptime("2017-06-01", "%Y-%m-%d"),
         end=datetime.datetime.strptime("2017-05-31", "%Y-%m-%d"))
     Season.objects.create(
         title="s3",
         start=datetime.datetime.strptime("2018-06-01", "%Y-%m-%d"),
         end=datetime.datetime.strptime("2018-05-31", "%Y-%m-%d"))
     self.event_archive = Event.objects.create(
         title="past_event",
         start=datetime.datetime.strptime("2017-04-02", "%Y-%m-%d"),
         user=self.basic_user)
示例#7
0
 def setUp(self):
     super(EventTests, self).setUp()
     app = "mezzanine_agenda"
     model = "event"
     self.url = urlresolvers.reverse("admin:%s_%s_add" % (app, model))
     self.user = User().objects.create_user(username="******",
                                            password='******')
     self.parent_event = Event.objects.create(
         start=datetime.datetime.today(),
         title="parent_event",
         user=self._user)
     self.category = EventCategory.objects.create(name="category")
     self.shop = ExternalShop.objects.create()
     file = tempfile.NamedTemporaryFile(suffix='.png')
     img = ImageFile(file, name=file.name)
     self.event = Event.objects.create(
         title="mon-evenement",
         start=datetime.datetime.strptime("2018-01-13", "%Y-%m-%d").date(),
         end=datetime.datetime.strptime("2018-01-18", "%Y-%m-%d").date(),
         user=self.user,
         status=CONTENT_STATUS_PUBLISHED,
         category=self.category,
         facebook_event=10,
         shop=self.shop,
         external_id=12,
         is_full=True,
         brochure=img,
         no_price_comments="no_price_comments",
         mentions="mentions",
         allow_comments=True,
         rank=2)
示例#8
0
 def setUp(self):
     super(PlaylistTests, self).setUp()
     self.user = User().objects.create_user(username="******",
                                            password='******')
     self.playlist = Playlist.objects.create(type="audio")
     app = "organization_media"
     model = "playlist"
     self.url = urlresolvers.reverse("admin:%s_%s_add" % (app, model))
示例#9
0
    def test_create_user_with_email_successful(self):
        """Test creating a new user with an email is successful"""
        email = "*****@*****.**"
        password = '******'

        user = User().objects.create_user(email=email, password=password)

        self.assertEqual(user.email, email)
        self.assertTrue(user.check_password, password)
示例#10
0
 class Meta:
     model = User()
     fields = ('email', 'password', 'name')
     extra_kwargs = {
         'password': {
             'write_only': True,
             'min_length': 5
         },
     }
示例#11
0
    def authenticate(self, request, **kwargs):
        try:
            if request.GET.get('next') == '/admin/' and request.POST.get(
                    "username"):
                print("we are here now")
                email = request.POST.get("username")
                password = request.POST.get("password")
                try:
                    print("getting here now")
                    user = User().objects.get(email=email)
                    print(user)
                    if user.is_superuser:
                        print("A Super User is logging in")
                        return user
                except User().DoesNotExist:
                    print("User does not exist or user is not a super user")
                    return None
        except:
            pass

        email = kwargs['email']
        password = kwargs['password']
        if email and password:
            # try:
            #     user = User().objects.get(email=email)
            #     print(f"the user password {user.password}")
            #     print(f"the user login password {password}")
            #     if user.check_password(password, user.password):
            #         return user
            #     # check = user.check_password(password)
            #     # print(check)
            #     # if check:
            #     # if password == user.password:
            #     #     return user
            # except User().DoesNotExist:
            #     return None
            try:
                user = User().objects.get(email=email)
            except User().DoesNotExist:
                return None
            else:
                if user.check_password(password):
                    return user
            return None
示例#12
0
 def test_sign_up(self):
     url = reverse("signup")
     data = {
         'email': '*****@*****.**',
         'password': '******',
         'first_name': 'userfromT'
     }
     # resp = self.client.post(path=url, data=data, format='json')
     # self.assertEqual(resp.status_code,status.HTTP_201_CREATED)
     self.assertEqual(User().objects.count(), 1)
示例#13
0
class Votable(models.Model):
    UP = 1
    DOWN = -1
    VALUE_CHOICES = ((UP, '👍'), (DOWN, '👎'))
    value = models.SmallIntegerField(choices=VALUE_CHOICES)
    user = models.ForeignKey(User(), on_delete=models.CASCADE)
    voten_on = models.DateTimeField(auto_now=True)

    class Meta:
        abstract = True
示例#14
0
def profile(request, user_pk):
    """
    1. 내가 쓴 모든 글 출력
    2. 내가 쓴 댓글들 출력
    3. 작성자를 눌렀을때 프로필로 이동
    """
    user = get_object_or_404(User(), pk=user_pk)
    ctx = {
        'profile_user': user,
    }
    return render(request, 'accounts/profile.html', ctx)
示例#15
0
def activate(request, uidb64, token):
    try:
        uid = force_text(urlsafe_base64_decode(uidb64))
        user = User().objects.get(pk=uid)
    except (TypeError, ValueError, OverflowError, User.DoesNotExist):
        user = None

    if user is not None and account_activation_token.check_token(user, token):
        user.is_active = True
        user.profile.email_confirmed = True
        user.save()
        login(request, user)
        return redirect('qanda:home')
    else:
        return render(request, 'qanda/account_activation_invalid.html')
示例#16
0
def add_admin(request):
    users = request.user
    if request.method == 'POST':
        first_name = request.POST.get('firstname')
        last_name = request.POST.get('lastname')
        email = request.POST.get('email')
        phonenumber = request.POST.get('phonenumber')
        pass1 = request.POST.get('pass1')
        pass2 = request.POST.get('pass2')
        if pass1 == pass2:
            password = pass1
            if User().objects.filter(email=email).exists():
                messages.info(request, 'Email already exists.')
            else:
                user = User()(email=email)
                user.first_name = first_name
                user.last_name = last_name
                user.phonenumber = phonenumber
                user.set_password(password)
                user.is_admin = True
                user.save(commit=False)
                admin = Admin.objects.create(user=user)
                user.save()
                admin.save()
                messages.success(request, "Admin successfully added")
            #check logged in user and render the current add-staff page for the proper user. I wouldn't want to redirect admin to staff signup page
            return render(request, "len_admin/add_admin.html")
        else:
            messages.error(request, 'Passwords do not match')
    elif request.method == 'GET':
        try:
            Admin.objects.get(
                user=users.id)  #checks if the logged in user is an Admin
            return render(request, "len_admin/add_admin.html")
        except ObjectDoesNotExist:
            return redirect(request.META.get('HTTP_REFERER', '/'))
示例#17
0
class Publishable(models.Model):
    user = models.ForeignKey(User(), on_delete=models.CASCADE)
    body = models.TextField()
    created = models.DateTimeField(editable=False)
    modified = models.DateTimeField()

    def save(self, *args, **kwargs):
        ''' On save, update timestamps '''
        if not self.id:
            self.created = timezone.now()
        self.modified = timezone.now()
        return super(Publishable, self).save(*args, **kwargs)

    class Meta:
        abstract = True
示例#18
0
    def test_login_refresh_access(self):
        url = reverse("token_obtain_pair")
        data = {'email': '*****@*****.**', 'password': '******'}
        resp = self.client.post(path=url, data=data, format='json')
        refresh = resp.data["refresh"]
        # print(resp.data)
        self.assertIn('refresh', resp.data)
        self.assertIn('access', resp.data)
        self.assertEqual(resp.status_code, status.HTTP_200_OK)
        self.assertEqual(User().objects.count(), 1)

        url = reverse("token_refresh")
        data = {"refresh": refresh}
        resp = self.client.post(path=url, data=data)
        # print(resp.data)
        self.assertIn('access', resp.data)
示例#19
0
    def get_context_data(self, **kwargs):
        user = User().objects.get(username=self.kwargs['username'])
        ctx = super(UserDetail, self).get_context_data(**kwargs)
        tab = self.request.GET.get('tab', None)

        ctx['answers'] = Answer.objects.all_with_score() \
            .filter(user=user).order_by('-score')
        ctx['questions'] = \
            Question.objects.all_with_relations_and_score() \
            .filter(user=user).order_by('-score')

        # User entered no tab query or invalid quer
        if (tab == 'None' or (tab != 'questions' and tab != 'answers')):
            ctx['answers'] = ctx['answers'][:5]
            ctx['questions'] = ctx['questions'][:5]

        return ctx
示例#20
0
 def setUp(self):
     super(JobResponseTests, self).setUp()
     app = "organization_job"
     model = "joboffer"
     self.user = User().objects.create_user(username="******",
                                            password='******')
     self.file = SimpleUploadedFile('letter.txt'.encode(),
                                    'content'.encode())
     self.job_offer = JobOffer.objects.create(email="*****@*****.**",
                                              type="internship")
     self.job_response = JobResponse.objects.create(
         first_name="jean",
         last_name="dupont",
         email="*****@*****.**",
         message="I want this job",
         curriculum_vitae=self.file,
         cover_letter=self.file,
         job_offer=self.job_offer)
     self.url = urlresolvers.reverse("admin:%s_%s_change" % (app, model),
                                     args=(self.job_offer.id, ))
示例#21
0
class SignUp(viewsets.ModelViewSet):
    '''
    create: Register\n
    Uses the email and password provided to Register a User
    '''
    serializer_class = UsersSerializer
    queryset = User().objects.all()

    def perform_create(self, serializer):
        serializer = UsersSerializer(data=self.request.data)
        if serializer.is_valid():
            user = serializer.save()
            refresh = RefreshToken.for_user(user)
            data = {
                'refresh': str(refresh),
                'access': str(refresh.access_token),
            }
            data[id] = user.id
            return Response(data, status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
示例#22
0
class FreeAgentBid(models.Model):
    free_agent = models.ForeignKey(AvailableFreeAgent,
                                   on_delete=models.CASCADE)
    bid_time_stamp = models.DateTimeField()
    bid_team = models.ForeignKey(Franchise, on_delete=models.PROTECT)
    bid_length = models.IntegerField()
    bid_salary = models.IntegerField()
    user = models.ForeignKey(User(), on_delete=models.PROTECT)

    class Meta:
        ordering = ['free_agent', '-bid_time_stamp']

    def __str__(self):
        return '{}, {}-{}-Free Agent Bid'.format(self.free_agent.last_name,
                                                 self.free_agent.first_name,
                                                 self.bid_time_stamp)

    def is_high_bid(self):
        if self.bid_time_stamp == self.free_agent.bid_time_stamp:
            return True
        else:
            return False
示例#23
0
class UserDetail(CacheVaryOnCookieMixin, DetailView):
    model = User()
    slug_field = "username"
    slug_url_kwarg = "username"
    template_name = 'qanda/user_detail.html'

    def get_context_data(self, **kwargs):
        user = User().objects.get(username=self.kwargs['username'])
        ctx = super(UserDetail, self).get_context_data(**kwargs)
        tab = self.request.GET.get('tab', None)

        ctx['answers'] = Answer.objects.all_with_score() \
            .filter(user=user).order_by('-score')
        ctx['questions'] = \
            Question.objects.all_with_relations_and_score() \
            .filter(user=user).order_by('-score')

        # User entered no tab query or invalid quer
        if (tab == 'None' or (tab != 'questions' and tab != 'answers')):
            ctx['answers'] = ctx['answers'][:5]
            ctx['questions'] = ctx['questions'][:5]

        return ctx
示例#24
0
class QuestionSubscription(models.Model):
    user = models.ForeignKey(User(), on_delete=models.CASCADE)
    question = models.ForeignKey(Question, on_delete=models.CASCADE)

    objects = QuestionSubscriptionManager()

    ANSWER_EMAIL_TEMPLATE = 'email/new_answer.html'

    def email_new_answer(self):
        subject = f"New answer on '{self.question.title}'"
        message = render_to_string(
            self.ANSWER_EMAIL_TEMPLATE, {
                'domain': settings.EMAIL_HOST,
                'user': self.user,
                'question': self.question
            })
        tasks.send_email.delay(self.user.id, subject, message)

    def __str__(self):
        return f'{self.user} | {self.question.title}'

    class Meta:
        unique_together = ('user', 'question')
示例#25
0
def RegisterUser(request):
    if request.method == 'POST':
        body = json.loads(request.body.decode('utf-8'))
        print(body)

        if (len(User().objects.filter(email=body["email"])) != 0):
            return HttpResponse(json.dumps({"field": "email"}), status=300)

        if (len(User().objects.filter(username=body["username"])) != 0):
            return HttpResponse(json.dumps({"field": "username"}), status=300)

        if (body["type"] == "Patient"):
            if (len(Patient.objects.filter(cpf=body["cpf"])) != 0):
                return HttpResponse(json.dumps({"field": "cpf"}), status=300)

        elif (body["type"] == "Medic"):
            if (len(Medic.objects.filter(cpf=body["cpf"])) != 0):
                return HttpResponse(json.dumps({"field": "cpf"}), status=300)
            if (len(Medic.objects.filter(crm=body["crm"])) != 0):
                return HttpResponse(json.dumps({"field": "crm"}), status=300)
            if (len(
                    Medic.objects.filter(
                        metamaskAccount=body["metamaskAccount"])) != 0):
                return HttpResponse(json.dumps({"field": "Metamask Account"}),
                                    status=300)
        else:
            if (len(Pharmacy.objects.filter(cnpj=body["cnpj"])) != 0):
                return HttpResponse(json.dumps({"field": "cnpj"}), status=300)

        try:
            user = User().objects.create_user(email=body["email"],
                                              username=body["username"],
                                              password=body["password"],
                                              type=body["type"])
        except Exception as err:
            print("Error registering user on database:" + str(err))
            return HttpResponse(status=500)

        if (body["type"] == "Patient"):
            try:
                patient = Patient(user=user, cpf=body["cpf"])
                patient.save()
            except Exception as err:
                print("Error registering new patient in patient table:" +
                      str(err))
                user.delete()
                return HttpResponse(status=500)

        elif (body["type"] == "Medic"):
            try:
                medic = Medic(user=user,
                              cpf=body["cpf"],
                              crm=body["crm"],
                              metamaskAccount=body["metamaskAccount"])
                medic.save()
            except Exception as err:
                print("Error registering new medic in medic table:" + str(err))
                user.delete()
                return HttpResponse(status=500)

        else:
            try:
                pharmacy = Pharmacy(user=user, cnpj=body["cnpj"])
                pharmacy.save()
            except Exception as err:
                print("Error registering new pharmacy in pharmacy table:" +
                      str(err))
                user.delete()
                return HttpResponse(status=500)

        login(request, user)

        success_url = reverse_lazy('home')
        return redirect(success_url)  #return user
示例#26
0
 def test_create_new_super_user(self):
     """Test create  new super user"""
     user = User().objects.create_superuser('*****@*****.**', 'test123')
     self.assertTrue(user.is_superuser)
     self.assertTrue(user.is_staff)
示例#27
0
 def test_new_user_invalid_email(self):
     """New User Email Validation Test"""
     with self.assertRaises(ValueError):
         User().objects.create_user(None, 'test@123')
示例#28
0
    def test_new_user_email_nomalized(self):
        """New user email is normalized"""
        email = '*****@*****.**'
        user = User().objects.create_user(email, 'test123')

        self.assertEqual(user.email, email.lower())
示例#29
0
    def test_exam_livetime_process(self):

        #Logging in the user created in the setup method
        new_user = User().objects.get(email="*****@*****.**")
        url = reverse("token_obtain_pair")
        data = {"email": "*****@*****.**", "password": "******"}
        resp = self.client.post(path=url, data=data, format='json')
        self.assertIn('refresh', resp.data)
        self.assertNotIn('token', resp.data)
        self.assertEqual(resp.status_code, status.HTTP_200_OK)

        # THE following requests are made without Authentication
        #POST: create an exam for the cuurent user without Authentication ie Authorization Header
        access = resp.data["access"]
        url = reverse("all_exams")
        user = UserSerializer(new_user)
        data = {
            "user": user.data,
            "instructions": "Test instructions for test exam",
            "title": "Test title for test exam",
            "exam_time": "18:00:00"
        }
        resp = self.client.post(path=url, data=data, format='json')
        self.assertEqual(resp.status_code, status.HTTP_401_UNAUTHORIZED)

        resp = self.client.get(path=url)
        self.assertEqual(resp.status_code, status.HTTP_401_UNAUTHORIZED)

        # POST: create an exam for the cuurent user with wrong authentication( wrong access token )
        client = APIClient()
        client.credentials(HTTP_AUTHORIZATION='Bearer ' +
                           'incorrect credentials')
        resp = client.get(url, data=data)
        self.assertEqual(resp.status_code, status.HTTP_401_UNAUTHORIZED)

        #POST: create an exam for the cuurent user with the earlier generated access token
        client.credentials(HTTP_AUTHORIZATION=f'Bearer {access}')
        resp = client.post(path=url, data=data, format='json')
        self.assertEqual(resp.status_code, status.HTTP_201_CREATED)

        resp = client.get(path=url)
        self.assertEqual(resp.status_code, status.HTTP_200_OK)
        self.assertEqual(Exam.objects.count(), 1)
        self.assertEqual(Exam.objects.filter(user=new_user).count(), 1)

        # PERMISSIONS
        # we need to create a second user and try to update/retrive/delete the old users exam
        # This user will be used to check for object level permissions
        second_user = User().objects.get(email="*****@*****.**")
        url = reverse("token_obtain_pair")
        data = {"email": "*****@*****.**", "password": "******"}
        resp = self.client.post(path=url, data=data, format='json')
        second_user_access = resp.data["access"]
        self.assertIn('refresh', resp.data)
        self.assertNotIn('token', resp.data)
        self.assertEqual(resp.status_code, status.HTTP_200_OK)

        url = reverse("all_exams")
        client.credentials(HTTP_AUTHORIZATION=f'Bearer {second_user_access}')

        resp = client.get(path=url)
        # ***********************
        #Issue: this get request above is returning all exams in the db instead of only the users exams
        # ***********************
        self.assertEqual(resp.status_code, status.HTTP_200_OK)
        print(resp.data)
示例#30
0
 class Meta:
     model = User()
     extra_kwargs = {'password': {'write_only': True}}
     fields = ["id", "email", "password"]