Exemple #1
0
 def post(self, request, *args, **kwargs):
     if self.valid:
         Profile.mark_valid_emails([self.profile.user.email])
     else:
         Profile.mark_invalid_emails([self.profile.user.email])
     if request.is_ajax():
         success_value = 'valid' if self.valid else 'invalid'
         return JsonResponse({'success': success_value})
     else:
         return TemplateResponse(request, self.template_name, context={'view': self})
Exemple #2
0
 def post(self, request, *args, **kwargs):
     if self.valid:
         Profile.mark_valid_emails([self.user.email])
     else:
         Profile.mark_invalid_emails([self.user.email])
     if request.is_ajax():
         success_value = 'valid' if self.valid else 'invalid'
         return JsonResponse({'success': success_value})
     else:
         return TemplateResponse(request, self.template_name)
Exemple #3
0
 def post(self, request, *args, **kwargs):
     # Spare the extra trip to the database to fetch the User object associated
     # with the profile, just to retrieve the email address in that record.
     email = User.objects.filter(
         pk=self.profile.user_id).values_list('email')
     if self.valid:
         Profile.mark_valid_emails(email)
     else:
         Profile.mark_invalid_emails(email)
     if request.is_ajax():
         success_value = 'valid' if self.valid else 'invalid'
         return JsonResponse({'success': success_value})
     else:
         return TemplateResponse(request,
                                 self.template_name,
                                 context={'view': self})
Exemple #4
0
 def get_owner(self, object):
     try:
         return self.user.profile
     except Profile.DoesNotExist:
         # For users without a profile, we must create a dummy one, because AuthMixin
         # expects all owners to be instances of Profile (which is not unreasonable).
         return Profile(user=copy(self.user))
Exemple #5
0
 def get_success_url(self, *args, **kwargs):
     try:
         if hasattr(self.object, self.object._meta.get_field('profile').get_cache_name()):
             profile = self.object.profile
         else:
             profile = Profile.get_basic_data(user=self.object)
         return profile.get_edit_url()
     except Profile.DoesNotExist:
         return reverse_lazy('profile_create')
Exemple #6
0
 def get_authenticated_redirect_url(self):
     redirect_to = sanitize_next(self.request)
     if redirect_to:
         return redirect_to
     try:
         # When user is already authenticated, redirect to profile's page.
         profile = Profile.get_basic_data(user=self.request.user)
         return profile.get_absolute_url()
     except Profile.DoesNotExist:
         # If profile does not exist yet, redirect to home.
         return reverse_lazy('home')
Exemple #7
0
 def get_authenticated_redirect_url(self):
     redirect_to = sanitize_next(self.request)
     if redirect_to:
         return redirect_to
     try:
         # When user is already authenticated, redirect to profile edit page.
         profile = Profile.get_basic_data(user=self.request.user)
         return profile.get_edit_url()
     except Profile.DoesNotExist:
         # If profile does not exist yet, redirect to profile creation page.
         return self.success_url
Exemple #8
0
 def get(self, request, *args, **kwargs):
     try:
         profile = Profile.get_basic_data(user=request.user)
         return HttpResponseRedirect(
             reverse_lazy('profile_settings',
                          kwargs={
                              'pk': profile.pk,
                              'slug': profile.autoslug
                          }))
     except Profile.DoesNotExist:
         # Cache the result for the reverse related descriptor, to spare further DB queries.
         setattr(request.user,
                 request.user._meta.fields_map['profile'].get_cache_name(),
                 None)
         return super().get(request, *args, **kwargs)
Exemple #9
0
 def get(self, request, *args, **kwargs):
     self.object = self.get_object()
     if not request.user.is_active:
         return HttpResponseRedirect(self.get_success_url())
     else:
         try:
             profile = Profile.get_basic_data(user=request.user)
         except Profile.DoesNotExist:
             return super().get(request, *args, **kwargs)
         else:
             return HttpResponseRedirect(
                 reverse_lazy('profile_delete',
                              kwargs={
                                  'pk': profile.pk,
                                  'slug': profile.autoslug
                              }))
Exemple #10
0
    def get(self, request, *args, **kwargs):
        try:
            profile = Profile.get_basic_data(user=request.user)
            settings_url = reverse_lazy('profile_settings',
                                        kwargs={
                                            'pk': profile.pk,
                                            'slug': profile.autoslug
                                        })
        except Profile.DoesNotExist:
            settings_url = reverse_lazy('account_settings')

        return HttpResponseRedirect(
            format_lazy(
                '{settings_url}#{section_email}',
                settings_url=settings_url,
                section_email=pgettext_lazy("URL", "email-addr"),
            ))
Exemple #11
0
    def test_mark_identical_emails(self):
        # Having two profiles with the same public email address is
        # permitted. The `mark_invalid_emails` and `mark_valid_emails`
        # methods are expected to update both profile objects.
        profile_two = ProfileSansAccountFactory(with_email=True)
        Profile.all_objects.filter(pk=self.profile.pk).update(
            email=profile_two.email)
        email = profile_two.email
        invalid_email = f'{settings.INVALID_PREFIX}{email}'

        result = Profile.mark_invalid_emails([email])
        self.profile.refresh_from_db()
        profile_two.refresh_from_db()
        self.assertEqual(self.profile.email, profile_two.email)
        self.assertTrue(self.profile.email.startswith(settings.INVALID_PREFIX))
        self.assertEqual(result[Profile], 2)
        # When one of the profiles has its email already marked as
        # invalid, only the other one is expected to be updated.
        Profile.all_objects.filter(pk=self.profile.pk).update(email=email)
        result = Profile.mark_invalid_emails([email])
        self.profile.refresh_from_db()
        profile_two.refresh_from_db()
        self.assertTrue(self.profile.email.startswith(settings.INVALID_PREFIX))
        self.assertEqual(self.profile.email.count(settings.INVALID_PREFIX), 1)
        self.assertTrue(profile_two.email.startswith(settings.INVALID_PREFIX))
        self.assertEqual(profile_two.email.count(settings.INVALID_PREFIX), 1)
        self.assertEqual(result[Profile], 1)
        # Repeating the operation is not expected to update anything.
        result = Profile.mark_invalid_emails([email])
        self.assertEqual(result[Profile], 0)

        # Both profile objects' emails are expected to have the
        # marker prefix removed.
        result = Profile.mark_valid_emails([invalid_email])
        self.profile.refresh_from_db()
        profile_two.refresh_from_db()
        self.assertEqual(self.profile.email, profile_two.email)
        self.assertEqual(self.profile.email.count(settings.INVALID_PREFIX), 0)
        self.assertEqual(result[Profile], 2)
        # When one of the profiles has its email already marked as
        # valid, only the other one is expected to be updated.
        Profile.all_objects.filter(pk=self.profile.pk).update(
            email=invalid_email)
        result = Profile.mark_valid_emails([invalid_email])
        self.profile.refresh_from_db()
        profile_two.refresh_from_db()
        self.assertEqual(self.profile.email.count(settings.INVALID_PREFIX), 0)
        self.assertEqual(profile_two.email.count(settings.INVALID_PREFIX), 0)
        self.assertEqual(result[Profile], 1)
        # Repeating the operation is not expected to update anything.
        result = Profile.mark_valid_emails([email])
        self.assertEqual(result[Profile], 0)
Exemple #12
0
 def action(self, file_name, emails):
     results = Profile.mark_valid_emails(emails=emails)
     for model, updated in results.items():
         print(updated, model.__name__, "emails marked as valid from", file_name)
def migrate():
    # Connect to an existing database
    passwd = getpass("MySQL password for 'root': ")
    dr = mdb.connect('localhost',
                     'root',
                     passwd,
                     'pasportaservo',
                     charset='utf8')

    users = dr.cursor(mdb.cursors.DictCursor)
    users.execute("""
        SELECT *,
            GROUP_CONCAT(DISTINCT content_field_kondicxoj.field_kondicxoj_value) conditions,
            GROUP_CONCAT(DISTINCT content_field_telefono1estas.field_telefono1estas_value) tel1_type,
            GROUP_CONCAT(DISTINCT content_field_telefono2estas.field_telefono2estas_value) tel2_type
        FROM users u
        INNER JOIN node n ON n.uid=u.uid AND n.type='profilo'
        INNER JOIN content_type_profilo p ON p.nid=n.nid
        LEFT JOIN location_instance
            ON u.uid = location_instance.uid
        LEFT JOIN location
            ON location_instance.lid = location.lid
        LEFT JOIN content_field_kondicxoj
            ON n.nid = content_field_kondicxoj.nid
        LEFT JOIN content_field_telefono1estas
            ON n.nid = content_field_telefono1estas.nid
        LEFT JOIN content_field_telefono2estas
            ON n.nid = content_field_telefono2estas.nid
        WHERE u.uid > 1
            AND u.name <> 'testuser'
            AND ( (field_lando_value = 'Albanio' AND field_urbo_value is not NULL)
                OR (field_lando_value <> 'Albanio'))
            AND field_familia_nomo_value <> 12
        GROUP BY u.uid
    """)

    user = users.fetchone()

    from django.contrib.auth.models import User
    from hosting.utils import title_with_particule
    from hosting.models import Profile, Place, Phone, Condition, Website

    django.setup()

    # Starting...
    print('Ignoring:')

    # Condition objects
    sleeping_bag = Condition(
        name=_("Sleeping bag"),
        abbr=_("sleeping bag"),
        slug="sleeping-bag",
    )
    sleeping_bag.save()

    one_room = Condition(
        name=_("One room"),
        abbr=_("one room"),
        slug="one-room",
    )
    one_room.save()

    dont_smoke = Condition(
        name=_("Don't smoke"),
        abbr=_("dont smoke"),
        slug="dont-smoke",
    )
    dont_smoke.save()

    while user is not None:

        # User
        new_user = User(id=user['uid'],
                        password=user['pass'],
                        last_login=u2dt(user['login']),
                        is_superuser=False,
                        username=g.get_username(user['name'], user['mail']),
                        email=user['mail'],
                        is_staff=False,
                        is_active=True,
                        date_joined=u2dt(user['created']))
        new_user.save()

        # Profile
        new_profile = Profile(
            id=user['uid'],
            user=new_user,
            title=g.get_title(user['field_sekso_value']),
            first_name=title_with_particule(user['field_persona_nomo_value']),
            last_name=title_with_particule(user['field_familia_nomo_value']),
            birth_date=g.get_birth_date(user['field_naskijaro_value']),
            description=user['field_pri_mi_value'],
            avatar=g.get_avatar(user['picture']),
        )
        new_profile.save()

        # Place
        address = user['field_adreso_value']
        details = user['field_detaloj_kaj_rimarkoj_value']
        closest_city = user['field_proksima_granda_urbo_value']
        city = user['field_urbo_value']
        country = COUNTRIES.get(user['field_lando_value'], '')
        state_province = g.get_state_province(
            user['field_sxtato_provinco_value'], country)
        if address or user['latitude']:
            new_place = Place(
                id=user['uid'],
                owner=new_profile,
                address='' if not address else address.strip(),
                description='' if not details else details.strip(),
                city='' if not city else title_with_particule(city.strip()),
                closest_city='' if not closest_city else title_with_particule(
                    closest_city.strip()),
                postcode=g.get_postcode(
                    user['field_posxtokodo_logxadreso_value']),
                country=country,
                state_province=state_province,
                latitude=float(user['latitude']) if user['latitude'] else None,
                longitude=float(user['longitude'])
                if user['longitude'] else None,
                max_host=g.get_int_or_none(
                    user['field_maksimuma_gastoj_value']),
                max_night=g.get_int_or_none(
                    user['field_maksimuma_noktoj_value']),
                available=g.get_truefalse(
                    user['field_mi_pretas_gastigi_value']),
                tour_guide=g.get_truefalse(
                    user['field_mi_pretas_cxicxeroni_value']),
                have_a_drink=g.get_truefalse(
                    user['field_mi_pretas_cxicxeroni_value']),
                in_book=g.get_in_book(
                    user['field_mia_profilo_videbla_en_la_value']),
                contact_before=g.get_int_or_none(
                    user['field_bonvolu_kontakti_min_value']),
            )
            new_place.save()
            new_profile.places.add(new_place)

            # Conditions
            raw_conditions = user['conditions']
            if raw_conditions:
                if "Kunportu dormosakon" in raw_conditions:
                    new_place.conditions.add(sleeping_bag)
                if "Ne fumu" in raw_conditions:
                    new_place.conditions.add(dont_smoke)
                if "ambra lo" in raw_conditions:
                    new_place.conditions.add(one_room)

        # Phone number
        raw_number = user['field_telefono1_value']
        number = g.get_phone_number(raw_number, country) if raw_number else ''
        if number:
            new_number = Phone(
                profile=new_profile,
                number=number,
                country=country if country else PHONE_CODES.get(
                    number.country_code, ''),
                type=g.get_phone_type(user['tel1_type']),
            )
            new_number.save()

        # Phone number 2
        raw_number2 = user['field_telefono2_value']
        number2 = g.get_phone_number(raw_number2,
                                     country) if raw_number2 else ''
        if number2:
            new_number2 = Phone(
                profile=new_profile,
                number=number2,
                country=country if country else PHONE_CODES.get(
                    number2.country_code, ''),
                type=g.get_phone_type(user['tel2_type']),
            )
            new_number.save()

        # Websites
        websites = g.get_websites(user['field_mia_ttt_pagxo_value'])
        for website in websites:
            new_website = Website(
                profile=new_profile,
                url=website,
            )
            new_website.save()

        user = users.fetchone()

    users.close()
    dr.close()

    print(r'Success! \o/')
def migrate():
    # Connect to an existing database
    passwd = getpass("MySQL password for 'root': ")
    dr = mdb.connect('localhost',
                     'root',
                     passwd,
                     'pasportaservo',
                     charset='utf8')

    users = dr.cursor(mdb.cursors.DictCursor)
    users.execute("""
        SELECT u.uid id,
            field_nomo_kaj_familia_nomo_1_value name1,
            field_naskijaro_persono_1_value year1,
            field_sekso_persono_1_value sex1,
            field_nomo_kaj_familia_nomo_2_value name2,
            field_naskijaro_persono_2_value year2,
            field_sekso_persono_1_value sex2,
            field_nomo_kaj_familia_nomo_3_value name3,
            field_naskijaro_persono_3_value year3
            -- There is no field_sekso_persono_3_value in the source database
        FROM users u
        INNER JOIN node n ON n.uid=u.uid AND n.type='profilo'
        INNER JOIN content_type_profilo p ON p.nid=n.nid
        WHERE u.uid > 1
            AND u.name <> 'testuser'
            AND ( (field_lando_value = 'Albanio' AND field_urbo_value is not NULL)
                OR (field_lando_value <> 'Albanio'))
            AND field_familia_nomo_value <> 12
        GROUP BY u.uid
    """)

    user = users.fetchone()

    from django.contrib.auth.models import User
    from hosting.utils import title_with_particule
    from hosting.models import Profile, Place

    django.setup()

    # Starting...
    print('Ignoring:')

    while user is not None:

        data1 = {
            'first_name': title_with_particule(user['name1']),
            'birth_date': g.get_birth_date(user['year1']),
            'title': g.get_title(user['sex1'])
        }
        data2 = {
            'first_name': title_with_particule(user['name2']),
            'birth_date': g.get_birth_date(user['year2']),
            'title': g.get_title(user['sex2'])
        }
        data3 = {
            'first_name': title_with_particule(user['name3']),
            'birth_date': g.get_birth_date(user['year3'])
        }

        try:
            place = Place.objects.get(pk=user['id'])
        except Place.DoesNotExist:
            place = None

        print(user['id'], data1['first_name'], data3['birth_date'])

        if place and (data1['birth_date'] or data1['first_name']):
            profile1 = Profile(**data1)
            profile1.save()
            place.family_members.add(profile1)

        if place and (data2['birth_date'] or data2['first_name']):
            profile2 = Profile(**data2)
            profile2.save()
            place.family_members.add(profile2)

        if place and (data3['birth_date'] or data3['first_name']):
            profile3 = Profile(**data3)
            profile3.save()
            place.family_members.add(profile3)

        user = users.fetchone()

    users.close()
    dr.close()

    print('\n  Success! \\o/\n')
 def action(self, file_name, emails):
     results = Profile.mark_invalid_emails(emails=emails)
     for model, updated in results.items():
         print(updated, model.__name__, 'emails marked as invalid from',
               file_name)
Exemple #16
0
 def save(self, commit=True):
     super().save(commit)
     if commit:
         Profile.mark_valid_emails([self.user.email])
     return self.user
def migrate():
    # Connect to an existing database
    passwd = getpass("MySQL password for 'root': ")
    dr = mdb.connect('localhost', 'root', passwd, 'pasportaservo', charset='utf8')

    users = dr.cursor(mdb.cursors.DictCursor)
    users.execute("""
        SELECT u.uid id,
            field_nomo_kaj_familia_nomo_1_value name1,
            field_naskijaro_persono_1_value year1,
            field_sekso_persono_1_value sex1,
            field_nomo_kaj_familia_nomo_2_value name2,
            field_naskijaro_persono_2_value year2,
            field_sekso_persono_1_value sex2,
            field_nomo_kaj_familia_nomo_3_value name3,
            field_naskijaro_persono_3_value year3
            -- There is no field_sekso_persono_3_value in the source database
        FROM users u
        INNER JOIN node n ON n.uid=u.uid AND n.type='profilo'
        INNER JOIN content_type_profilo p ON p.nid=n.nid
        WHERE u.uid > 1
            AND u.name <> 'testuser'
            AND ( (field_lando_value = 'Albanio' AND field_urbo_value is not NULL)
                OR (field_lando_value <> 'Albanio'))
            AND field_familia_nomo_value <> 12
        GROUP BY u.uid
    """)

    user = users.fetchone()

    from django.contrib.auth.models import User
    from hosting.utils import title_with_particule
    from hosting.models import Profile, Place

    django.setup()

    # Starting...
    print('Ignoring:')


    while user is not None:

        data1 = {'first_name': title_with_particule(user['name1']), 'birth_date': g.get_birth_date(user['year1']), 'title': g.get_title(user['sex1'])}
        data2 = {'first_name': title_with_particule(user['name2']), 'birth_date': g.get_birth_date(user['year2']), 'title': g.get_title(user['sex2'])}
        data3 = {'first_name': title_with_particule(user['name3']), 'birth_date': g.get_birth_date(user['year3'])}

        try:
            place = Place.objects.get(pk=user['id'])
        except Place.DoesNotExist:
            place = None

        print(user['id'], data1['first_name'], data3['birth_date'])

        if place and (data1['birth_date'] or data1['first_name']):
            profile1 = Profile(**data1)
            profile1.save()
            place.family_members.add(profile1)

        if place and (data2['birth_date'] or data2['first_name']):
            profile2 = Profile(**data2)
            profile2.save()
            place.family_members.add(profile2)

        if place and (data3['birth_date'] or data3['first_name']):
            profile3 = Profile(**data3)
            profile3.save()
            place.family_members.add(profile3)

        user = users.fetchone()

    users.close()
    dr.close()

    print('\n  Success! \\o/\n')