Example #1
0
def run():

    from django.contrib.auth.models import User

    auth_user_1 = User()
    auth_user_1.username = u"dmsadmin"
    auth_user_1.first_name = u""
    auth_user_1.last_name = u""
    auth_user_1.email = u""
    auth_user_1.set_password("dmsadmin")
    auth_user_1.is_staff = True
    auth_user_1.is_active = True
    auth_user_1.is_superuser = True
    auth_user_1.date_joined = datetime.datetime.now()
    auth_user_1.save()

    auth_user_2 = User()
    auth_user_2.username = u"dmsuser"
    auth_user_2.first_name = u""
    auth_user_2.last_name = u""
    auth_user_2.email = u""
    auth_user_1.set_password("dmsuser")
    auth_user_2.is_staff = False
    auth_user_2.is_active = True
    auth_user_2.is_superuser = False
    auth_user_2.date_joined = datetime.datetime.now()
    auth_user_2.save()

    from django.contrib.sites.models import Site

    django_site_1 = Site()
    django_site_1.domain = u"localhost:8000"
    django_site_1.name = u"Development Server"
    django_site_1.save()
    def get_update_user(username, fields):
        try:
            user = User.objects.get(username=username)
        except User.DoesNotExist:
            # Generate random password (we won't be using it anyway)
            pw = base64.b64encode(os.urandom(20))
            user = User(username=username, password=pw)

        # Get firstname, last name
        names = fields[REALNAME].split(" ")
        user.first_name = ""
        user.last_name = ""
        if len(names) == 1:
            user.first_name = names[0]
        elif len(names) > 1:
            user.first_name = " ".join(names[0:-1])
            user.last_name = names[-1]

        user.email = fields[EMAIL]

        user.is_active = True
        user.is_staff = True

        user.save()
        return user
Example #3
0
    def save(self, commit=True):
        if not self.edit:
            persona = super(PersonaForm, self).save(commit=False)

            nUsuario = User()
            nUsuario.username = persona.identificacion
            nUsuario.first_name = persona.nombre
            nUsuario.last_name = persona.apellido
            nUsuario.email = persona.email
            contrase = Util.contrasena_aleatoria()
            nUsuario.set_password(contrase)
            nUsuario.save()
            persona.usuario = nUsuario

            persona.edad = Util.getEdad(persona.fechaNacimiento)

            self.personaServicio.insert(persona)
            correoUtil=CorreoUtil()
            correoUtil.correoCreacionEmpleado(persona.identificacion, contrase, persona)
        else:
            persona = super(PersonaForm, self).save(commit=False)
            persona.edad = Util.getEdad(persona.fechaNacimiento)

            nUsuario = persona.usuario

            nUsuario.first_name = persona.nombre
            nUsuario.last_name = persona.apellido
            nUsuario.email = persona.email

            self.personaServicio.update(persona)
Example #4
0
def get_or_create_user(first_name=None, last_name=None, always_new=True):
    if always_new == False:
        # if it's false, we will randomly decide whether we want to make a new case or not.
        if random.random() > CREATE_NEW_PERCENTAGE:
            # let's do a 25/75 create/existing split
            print "Returning existing user"
            return User.objects.all()[random.randrange(0, User.objects.all().count())]
        else:
            print "Creating new user"

    user = User()

    if first_name == None:
        user.first_name = uuid.uuid1().hex[0:20]
    else:
        user.first_name = first_name

    if last_name == None:
        user.last_name = uuid.uuid1().hex[0:20]
    else:
        user.last_name = last_name

    username = "******" % (user.first_name.replace("'", ""), user.last_name.replace("'", ""))
    user.username = username[0:30].lower()
    try:
        exists = User.objects.get(username=user.username)
        return exists
    except:
        user.save()
    return user
Example #5
0
def run():
    from django.contrib.sites.models import Site

    django_site_1 = Site.objects.all()[0]
    django_site_1.domain = u'localhost:8000'
    django_site_1.name = u'localhost:8000'
    django_site_1.save()

    from corehq.apps.domain.models import Domain

    domain_domain_1 = Domain()
    domain_domain_1.name = u'test'
    domain_domain_1.is_active = True
    domain_domain_1.save()

    from django.contrib.auth.models import User

    auth_user_1 = User()
    auth_user_1.username = u'admin'
    auth_user_1.first_name = u''
    auth_user_1.last_name = u''
    auth_user_1.email = u'*****@*****.**'
    auth_user_1.password = u'sha1$f8d4b$b6d2f6431c423687c227ad261caa46faaf16917d'
    auth_user_1.is_staff = True
    auth_user_1.is_active = True
    auth_user_1.is_superuser = True
    auth_user_1.last_login = datetime.datetime(2010, 9, 10, 14, 40, 30, 501416)
    auth_user_1.date_joined = datetime.datetime(2010, 9, 10, 14, 37, 22, 677987)
    auth_user_1.save()

    auth_user_2 = User()
    auth_user_2.username = u'test'
    auth_user_2.first_name = u'test'
    auth_user_2.last_name = u'test'
    auth_user_2.email = u'*****@*****.**'
    auth_user_2.password = u'sha1$f09cf$551ac80804020ad3e1d9943a583ee1ea52284797'
    auth_user_2.is_staff = False
    auth_user_2.is_active = True
    auth_user_2.is_superuser = False
    auth_user_2.last_login = datetime.datetime(2010, 9, 10, 14, 40, 53, 818764)
    auth_user_2.date_joined = datetime.datetime(2010, 9, 10, 19, 40, 6, 159442)
    auth_user_2.save()

    couch_user = auth_user_2.get_profile().get_couch_user()
    couch_user.add_domain_membership(domain_domain_1.name)
    couch_user.save()

    from corehq.apps.domain.models import RegistrationRequest

    domain_registration_request_1 = RegistrationRequest()
    domain_registration_request_1.tos_confirmed = True
    domain_registration_request_1.request_time = datetime.datetime(2010, 9, 10, 19, 40, 6, 159442)
    domain_registration_request_1.request_ip = '127.0.0.1'
    domain_registration_request_1.activation_guid = u'368ce6b8bd1311df932c5cff350164a3'
    domain_registration_request_1.confirm_time = datetime.datetime(2010, 9, 10, 14, 40, 25, 219783)
    domain_registration_request_1.confirm_ip = '127.0.0.1'
    domain_registration_request_1.domain = domain_domain_1
    domain_registration_request_1.new_user = auth_user_2
    domain_registration_request_1.requesting_user = None
    domain_registration_request_1.save()
Example #6
0
def callback_view(request):
    if request.GET.has_key('bounceback'):
        request.session['bounceback'] = request.GET['bounceback']

    if request.GET.has_key("code"):        
        code = request.GET.get('code')
        api = TroveAPI(TROVE['ID'], TROVE['SECRET'], TROVE['CALLBACK_URL'])
        oauth_token = api.get_access_token(code)        
    else: 
        # this might be a /add callback response (instead of a loginwith)
        if request.user.is_authenticated():
            return __bounceback__(request)
        else:
            return redirect('trove-login')

    try:
        at = TroveAccessToken.objects.get(oauth_token_as_string=oauth_token)
    except TroveAccessToken.DoesNotExist:
        # we have to create one!  -- although this does run into issues with users having different access tokens
        user_info = api.get_user_info() 
        try:
            u = User.objects.get(username=user_info['trove_internal_id'])
        except User.DoesNotExist:            
            u = User() 
            u.username = user_info['trove_internal_id']
            try:
                if user_info['first_name'] is not None:
                    u.first_name = to_unicode_or_bust(user_info['first_name'])
                else:
                    u.first_name = " "
            except:
                u.first_name = " "
            try:
                if user_info['last_name'] is not None:
                    u.last_name = to_unicode_or_bust(user_info['last_name'])
                else:
                    u.last_name = ""
            except:
                u.last_name = ""
            u.set_unusable_password()
            u.email = ""
            u.is_active = True
            u.save()
        at = TroveAccessToken()
        at.user = u
        at.oauth_token_as_string = oauth_token
        at.save()

        
    user = authenticate(access_token=oauth_token)
    
    if user is not None:
        if user.is_active:
            login(request, user)
            return __bounceback__(request)
        else:        
            return redirect('trove-login')
    else:        
        return redirect('trove-login')
Example #7
0
 def _createUser(self):
     usr = User()
     usr.username = "******" % (User.objects.all().count())
     usr.first_name = "TestUser"
     usr.first_name = "Test%d" % (User.objects.all().count())
     usr.set_password("testtest")
     usr.save()
     return usr
Example #8
0
 def setUp(self):
     # Delete all previous
     ModelActionLog.objects.all().delete()
     user = User()
     user.username = "******"
     user.first_name = "first_name"
     user.last_name = "last_name"
     user.email = "*****@*****.**"
     user.save()
     self.user_id = user.id
     user.first_name = "changed_first_name"
     user.save()
     user.delete()
Example #9
0
File: manager.py Project: boar/boar
 def create_from_name(self, name):
     u = User()
     try:
         u.first_name, u.last_name = name.split(None, 1)
     except ValueError:
         u.first_name, u.last_name = name, ''
     unique_slugify(u,
         re.sub(r'[^a-z0-9\.]', '', '.'.join(name.lower().split())),
         slug_field_name='username',
         slug_separator='.',
         slugify=False)
     u.set_unusable_password()
     u.save()
     return self.create(user=u)
Example #10
0
def run():
    from django.contrib.auth.models import User

    auth_user_1 = User()
    auth_user_1.username = u'alice'
    auth_user_1.first_name = u''
    auth_user_1.last_name = u''
    auth_user_1.email = u''
    auth_user_1.password = u'sha1$9235f$5e8d6d4d61224eec4020f9ff627f41de2dab0d1b'
    auth_user_1.is_staff = False
    auth_user_1.is_active = True
    auth_user_1.is_superuser = False
    auth_user_1.last_login = datetime.datetime(2012, 11, 7, 18, 11, 56, 627668)
    auth_user_1.date_joined = datetime.datetime(2012, 10, 19, 4, 33, 45, 501602)
    try:
        auth_user_1.save()
    except:
        pass

    auth_user_2 = User()
    auth_user_2.username = u'admin'
    auth_user_2.first_name = u''
    auth_user_2.last_name = u''
    auth_user_2.email = u'*****@*****.**'
    auth_user_2.password = u'sha1$509de$45ec22f10561e8d3a3e2a89c71b6ec19f472bec8'
    auth_user_2.is_staff = True
    auth_user_2.is_active = True
    auth_user_2.is_superuser = True
    auth_user_2.last_login = datetime.datetime(2012, 11, 7, 20, 24, 35, 821631)
    auth_user_2.date_joined = datetime.datetime(2011, 7, 30, 12, 14, 49)
    try:
        auth_user_2.save()
    except:
        pass

    auth_user_3 = User()
    auth_user_3.username = u'steph'
    auth_user_3.first_name = u''
    auth_user_3.last_name = u''
    auth_user_3.email = u''
    auth_user_3.password = u'sha1$457c2$d1ca65eae410788ab8839166f08153cb89f6366d'
    auth_user_3.is_staff = False
    auth_user_3.is_active = True
    auth_user_3.is_superuser = False
    auth_user_3.last_login = datetime.datetime(2012, 11, 7, 20, 25, 23, 952727)
    auth_user_3.date_joined = datetime.datetime(2012, 10, 19, 2, 49, 44, 681549)
    try:
        auth_user_3.save()
    except:
        pass
Example #11
0
   def authenticate(self,username,password):
      # Login as fakeroot if in development
      if settings.DEBUG:
         try:
            user = User.objects.get(username='******')
            return user
         except User.DoesNotExist:
            user = User(username='******', password='******')
            user.is_staff = True
            user.is_superuser = True
            user.first_name = 'fakeroot'
            user.email = '*****@*****.**'
            user.save()
         return user
      else:
         try:
            l = ldap.open("ad.unsw.edu.au")
            l.protocol_version = ldap.VERSION3

            upn = username + '@ad.unsw.edu.au'

            l.bind_s(upn, password)

            baseDN = "OU=IDM_People,OU=IDM,DC=ad,DC=unsw,DC=edu,DC=au"
            searchScope = ldap.SCOPE_SUBTREE
            retrieveAttributes = ['cn', 'displayNamePrintable', 'givenName', 'sn', 'mail']
            searchFilter = "cn=" + username

            ldap_result = l.search(baseDN, searchScope, searchFilter, retrieveAttributes)
            result_type, result_data = l.result(ldap_result, 0)

            user_dn,attr_results = result_data[0]

            try:
               user = User.objects.get(username=attr_results['cn'][0])
               return user
            except User.DoesNotExist:
               user = User(username=username, password='******')
               user.is_staff = False
               user.is_superuser = False
               user.first_name = attr_results['givenName'][0]
               user.last_name = attr_results['sn'][0]
               user.email = attr_results['mail'][0]
               user.save()
               return user

         except ldap.LDAPError, e:
            print e
            return None
Example #12
0
    def handle(self, *args, **options):
        self.stdout.write('Creating user\n')
        user = User()
        username = raw_input("Username (default: %s): " % getuser()) if options["username"] is None else options["username"]
        if not username:
            username = getuser()
        user.username = username
        password = getpass("Password (default: 'test'): ") if options["password"] is None else options["password"]
        if not password:
            password = '******'
        first_name = raw_input("Firstname (default: John): ") if options["first_name"] is None else options["first_name"]
        if not first_name:
            first_name = "John"
        last_name = raw_input("Lastname (default: Smith): ") if options["last_name"] is None else options["last_name"]
        if not last_name:
            last_name = "Smith"
        user.first_name = first_name
        user.last_name = last_name
        user.set_password(password)
        user.save()
        profile = user.get_profile()
        profile.name = first_name + " " + last_name
        profile.email = '*****@*****.**'
        profile.photo = '/static/images/gaston.gif'
        profile.save()
        
        #Second user for tests
        user2 = User()
        user2.username="******"
        user2.first_name="Bertrand"
        user2.last_name="Labévue"
        user2.set_password(password)
        user2.save()
        profile2 = user2.get_profile()
        profile2.name = user2.first_name + " " + user2.last_name
        profile2.email = '*****@*****.**'
        profile2.photo = '/static/images/labevue.gif'
        profile2.save()
        self.stdout.write("Second user {} with password {} created\n".format(
            user2.username, password
        ))

        tree = json.load(open('parsing/tree.json'))
        self.courseList = json.load(open('parsing/cours.json'))
        self.USER = profile
        Root = Category.objects.create(name='P402', description='Bring back real student cooperation !')
        self.walk(tree, Root)
        self.stdout.write("\n")
Example #13
0
def user_signup(request):
	context = RequestContext(request)
	registered = False
	user = User(username = '')
	next_link = ""
	if request.GET:
		next_link = request.GET['next']	
	
	if request.method == 'POST':
		next_link = request.POST['signup_next']
		user.first_name = request.POST['user[full_name]']
		user.last_name = request.POST['user[sur_name]']
		user.username = request.POST['user[email]']
		user.email = request.POST['user[email]']
		user.password = request.POST['user[password]']
		user.set_password(user.password)
		user.save()
		patron = Patron(user = user)
		account = PatronAccount(balance = 0,  frozen = False, valid = True )
		account.save()
		patron.account = account
		patron.save()
		user = authenticate(username = request.POST['user[email]'], password = request.POST['user[password]'])
                if user is not None:
                        if user.is_active:
                                login(request, user)

		if next_link == "":
			return HttpResponseRedirect('/giftcards')
		else:
			return HttpResponseRedirect(next_link)
	
	else:
		return render_to_response('login.html', {'next':next_link}, context)		
	return 
    def authenticate(self, linkedin_access_token, user=None):
        linkedin = LinkedIn(LINKEDIN_CONSUMER_KEY, LINKEDIN_CONSUMER_SECRET)
        # get their profile

        profile = ProfileApi(linkedin).getMyProfile(access_token=linkedin_access_token)

        try:
            user_profile = LinkedInUserProfile.objects.get(linkedin_uid=profile.id)
            user = user_profile.user
            return user
        except LinkedInUserProfile.DoesNotExist:
            # Create a new user
            username = "******" % profile.id

            if not user:
                user = User(username=username)
                user.first_name, user.last_name = (profile.firstname, profile.lastname)
                user.email = "%s@socialauth" % (username)
                user.save()

            userprofile = LinkedInUserProfile(user=user, linkedin_uid=profile.id)
            userprofile.save()

            auth_meta = AuthMeta(user=user, provider="LinkedIn").save()
            return user
    def authenticate(self, access_token):
        '''authenticates the token by requesting user information from twitter
        '''
        twitter = oauthtwitter.OAuthApi(TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET, access_token)
        try:
            userinfo = twitter.GetUserInfo()
        except:
            # If we cannot get the user information, user cannot be authenticated
            raise

        screen_name = userinfo.screen_name
        
        try:
            user = User.objects.get(username = '******'%screen_name )
            return user
        except User.DoesNotExist:
            user = User(username = '******'%screen_name)
            temp_password = User.objects.make_random_password(length=12)
            user.set_password(temp_password)
            user.first_name = userinfo.name
            user.email = '%s@twitteruser.%s.com'%(userinfo.screen_name, settings.SITE_NAME)
            user.save()
            userprofile = TwitterUserProfile(user = user)
            userprofile.access_token = access_token.key
            userprofile.url = userinfo.url
            userprofile.location = userinfo.location
            userprofile.description = userinfo.description
            userprofile.profile_image_url = userinfo.profile_image_url
            userprofile.save()
            auth_meta = AuthMeta(user=user, provider='Twitter').save()
            return user
Example #16
0
def admin_reader_add(request):
    if request.method == 'POST':
        # Handle form submission.
        form = ReaderForm(request.POST) # Initialize form with data.
        if form.is_valid():
            
            # First create a new User object.
            user = User()
            # Process the data in form.cleaned_data
            user.email = form.cleaned_data['email']
            user.first_name = form.cleaned_data['first_name']
            user.last_name = form.cleaned_data['last_name']
            user.username = form.cleaned_data['username']
            user.password = make_password(form.cleaned_data['password'])
            user.save()
            # New create a reader object.
            reader = Reader()
            reader.user = user
            reader.address = form.cleaned_data['address']
            reader.phone_number = form.cleaned_data['phone_number']
            reader.save()
            
            return HttpResponseRedirect(reverse('admin_reader')) # Redirect after POST
    else:
        form = ReaderForm() # An unbound form

    return render(request, 'library/admin_reader_add.html', {
        'form': form,
    })
Example #17
0
    def createsuperuser():
        team = Team()
        team.name = "CSGO_Admin"
        team.university = "UQUAM"
        team.token = "ADMINTOKEN"
        team.score = 0
        team.hidden = True
        team.save()

        univ_mail = "uqam.qc.ca"

        user = User()
        user.email = "player@" + univ_mail
        user.username = "******"
        user.first_name = "The"
        user.last_name = "Spear"
        user.is_staff = True
        user.is_superuser = True
        user.set_password("12qwaszx")
        user.save()

        player = Player()
        user.player = player
        player.last_name = "Spear"
        player.first_name = "The"
        player.display_name = "Klammydia"
        player.team = team

        player.save()
Example #18
0
    def setUp(self):
        user = User()
        user.is_superuser = 1
        user.username = '******'
        user.set_password('password2')
        user.email = '*****@*****.**'
        user.first_name = 'aa'
        user.is_active = 1
        user.save()
        self.user = user

        c = Client()
        self.c = c
        self.c.login( username='******', password='******')

        product = Products()
        product.name = '123123'
        product.price = 123
        product.price_type = 1
        product.total_price = 1*2
        product.order_time = datetime.datetime.strptime('2014-03-20','%Y-%m-%d')
        product.trip_start_time = datetime.datetime.strptime('2014-06-20','%Y-%m-%d')
        product.trip_end_time = datetime.datetime.strptime('2014-09-09','%Y-%m-%d')
        product.key_desc = '123'
        product.start_city = '123'
        product.end_city = '123'
        product.pics = ''
        product.trips = ''
        product.date_count = 4
        product.user = self.user
        product.save()

        self.product = product
Example #19
0
    def authenticate(self, username=None, password=None):
        if pam.authenticate(username, password, settings.PAM_SERVICE):
            try:
                user = User.objects.get(username=username)
                user.set_password(password)
                user.save()
            except User.DoesNotExist:
                user = User(username=username, password=password)
                user.save()

                if settings.USE_LDAP:
                    import ldap

                    l = ldap.initialize(settings.LDAP_HOST)
                    l.set_option(ldap.OPT_REFERRALS, 0)
                    l.set_option(ldap.OPT_PROTOCOL_VERSION, 3)
                    l.simple_bind_s(settings.LDAP_BIND_DN, settings.LDAP_BIND_PASS)
                    r = l.search(settings.LDAP_SEARCH_PATH, ldap.SCOPE_ONELEVEL, "(uid=%s)" % username,
                                 [settings.LDAP_FIRST_NAME, settings.LDAP_LAST_NAME, settings.LDAP_EMAIL,
                                  settings.LDAP_DATE_JOINED])
                    r = l.result(r)
                    user.first_name = r[1][0][1][settings.LDAP_FIRST_NAME][0]
                    user.last_name = r[1][0][1][settings.LDAP_LAST_NAME][0]
                    user.email = r[1][0][1][settings.LDAP_EMAIL][0]
                    date_joined = r[1][0][1][settings.LDAP_DATE_JOINED][0]
                    user.date_joined = datetime.strptime(date_joined[:-1], '%Y%m%d%H%M%S')
                    user.save()

            return user
        return None
Example #20
0
    def authenticate(self, username=None, password=None):

        t_user = services.t_login(username, password)
	#We are using the colections data to set group permissions... somehow

	if t_user:
           try:
                user = User.objects.get(username=t_user['userName'])
           except User.DoesNotExist:
                # Create a new user. password is not chekced so we don't store it here
#                user = User(username=t_user['userName'], password="******")
                user = User(username=t_user['userName'])
	   #Transkribus has authority here so update the user data each time...
	   user.email = t_user['email']
	   user.first_name = t_user['firstname']
	   user.last_name = t_user['lastname']
	   if t_user['isAdmin'] == 'true':
               user.is_superuser = True
	   user.save()
	   #Extend the user object with some extra data from transkribus
	   try:
	   	tsdata = TSData.objects.get(user=user)
	   except TSData.DoesNotExist:
   	   	tsdata = TSData.objects.create(user=user)
	   tsdata.gender=t_user['gender']
	   tsdata.affiliation=t_user['affiliation']
           tsdata.save()
	   #services.t_collections()
  
           return user
        return None
Example #21
0
def adduser_createpw_sendmail(email, group, firstname, lastname, group_id, is_groupsuperuser=False):
    if email == '':
        return False
    elif len(User.objects.filter(email=email)) != 0:
        return False
    new_user = User()
    new_user.username = email.split('@')[0]
    new_user.email = email
    new_user.first_name = firstname
    new_user.last_name = lastname
    new_user.set_password('dummy_password')
    new_user.save()
    
    new_user_detail = UserDetail()
    new_user_detail.user = new_user
    new_user_detail.full_name = lastname+firstname
    new_user_detail.save()
    
    new_user.userdetail = new_user_detail
    new_user.username = str(new_user.id)
    new_user.save()
    
    new_user_group_info = UserGroupInfo()
    new_user_group_info.user = new_user
    new_user_group_info.group = group
    new_user_group_info.is_groupsuperuser = is_groupsuperuser
    new_user_group_info.user_id_of_group = group_id
    new_user_group_info.save()
    
    if not createpassword_sendmail(email):
        return False
    
    return True
    def authenticate(self,username=None,password=None):
        logger.info("AD auth backend for %s" % username)
        aduser = ADUser(username)

        if not aduser.connect(password):
            return None

        user = None
        try:
            user = User.objects.get(username=username)
        except User.DoesNotExist:
            user = User(username=username, is_staff = False, is_superuser = False)

        if not aduser.get_data():
            logger.warning("AD auth backend failed when reading data for %s. User detail data won't be updated in User model." % username)
        else:
            # NOTE: update user data exchange to User model
            assert user.username==aduser.username
            user.first_name=aduser.first_name
            user.last_name=aduser.last_name
            user.email=aduser.email
            #user.set_password(password)
            logger.warning("AD auth backend overwriting auth.User data with data from ldap for %s." % username)
        user.save()
        logger.info("AD auth backend check passed for %s" % username)
        return user
def web_register(request):
    """This view handles the register requests on the web client."""
    form_class = UserReg
    register_form = form_class(request.POST)
    
    if request.method == 'POST':
        if register_form.is_valid():
            new_user = User()
            username = register_form.cleaned_data['usermail']
            password = register_form.cleaned_data['password']
            name = register_form.cleaned_data['name']
            try:
                duplicate_check = User.objects.get(username = username)
                return render(request, 
                    'portal/welcome.html', {'error': 'Username already registered'})
            except User.DoesNotExist:
                new_user.username = username
                new_user.set_password(password)
                new_user.first_name = name
                new_user.save()
                new_owner = Owner(owner = new_user)
                new_owner.save()
                user = authenticate(username=username, password=password)
                login(request, user)
                return redirect('portal:home')
        else:
            return render(request, 'portal/welcome.html', {'error': 'Invalid register form'})
    else:
        return render(request, 'portal/forbidden.html', {})
Example #24
0
    def handle(self, *args, **options):

        csv_filepathname = args[0]
        sys.path.append(PROJECT_ROOT)
        dataReader = csv.reader(open(csv_filepathname), delimiter=';', quotechar='"')
        i = 0
        index = {}
        for row in dataReader:
            if i==0:
                index = self.comprovaCamps(row)
            else:
                usuari = User()
                name = row[index.get('Name')]
                surname = row[index.get('Surname')]
                email = row[index.get('E-mail')]

                username = self.comprovaUser(name, surname, email, usuari)
                if(username!=False):
                    usuari.email = row[index.get('E-mail')]
                    usuari.username = username
                    usuari.first_name = row[index.get('Name')]
                    usuari.last_name = row[index.get('Surname')]
                    usuari.groups.add("teachers")
                    usuari.save()
                    usuari.fsuser.classroom = row[index.get('Classroom')]



            i += 1
Example #25
0
    def getOrCreateUser(cls, username, email, first_name, last_name, picture):
        """
        find user associated with username and updates its data or create a user

        :param username:
        :param email:
        :param first_name:
        :param last_name:
        :param picture:
        :return: User
        """
        try:
            user = User.objects.get(username=username)
            profile = user.userprofile
            credential = profile.credential
        except ObjectDoesNotExist:
            user = User()
            user.email = email
            user.username = username
            profile = UserProfile()
            credential = profile.generate_credential()

        user.first_name = first_name
        user.last_name = last_name
        user.save()

        profile.credential = credential
        profile.picture = picture
        profile.user = user
        profile.save()
        return user
Example #26
0
    def save(self):
        data = self.cleaned_data
        password = data.get('password1')
        u = User()

        u.username = data.get('username')
        u.password = make_password(password)
        u.email = data.get('email')
        u.first_name = data.get('first_name')
        u.last_name = data.get('last_name')
        u.is_active = True
        u.is_superuser = False
        u.save()

        up = Profile()
        up.user = u
        up.info = data.get('info')

        if data.get('avatar') is None:
            image_url = 'http://api.adorable.io/avatars/100/%s.png' % u.username
            content = urllib.urlretrieve(image_url)
            up.avatar.save('%s.png' % u.username, File(open(content[0])), save=True)
        else:
            avatar = data.get('avatar')
            up.avatar.save('%s_%s' % (u.username, avatar.name), avatar, save=True)

        up.save()

        return authenticate(username=u.username, password=password)
Example #27
0
  def create_user(self, request=None, random_password=False):
    """
    Given a validated form, return a new User.
    Takes care of referrals too (if an HttpRequest object is passed).
    """
    cd = self.cleaned_data

    # Create user
    user = User()
    user.username = cd['username']
    user.first_name = cd['first_name']
    user.last_name = cd['last_name']
    user.email = cd['email']
    user.save()

    if random_password:
      user.random_password = "".join(random.sample(string.lowercase, 8))
      user.set_password(user.random_password)
    else:
      user.set_password(cd['password'])
    user.save()

    if request is not None:
      # If we have a referral code, set the profile's 'referral' field to it.
      # Note: there *should* be a profile here, as a signal will have created it automatically.
      name = request.session.get('referral', '').strip()
      if name:
        referral, _ = enginemodels.Referral.objects.get_or_create(name__iexact=name)
        profile = user.get_profile()
        profile.referral = referral
        profile.save()

    return user
Example #28
0
 def authenticate(self, identifier, user_info):
     user = None
     
     if isinstance(identifier, str) and isinstance(user_info, dict):
         try:
             user = User.objects.get(profile__openid=identifier)
         except User.DoesNotExist:
             # creating a new user with the user info
             if user_info.has_key("nickname") and user_info.has_key("email"):
                 username = user_info["nickname"]
                 email = user_info["email"]
                 user = User(username=username, email=email)
                 if user_info.has_key("fullname"):
                     user.first_name, user.last_name = self._parse_fullname(user_info["fullname"])
                 # if there's already a user with that username, simply
                 # redirect to the login page informing the user
                 try:
                     user.save()
                     # creating user profile.. in order to create a profile
                     # the user must be already created..
                     user.profile.create()
                     # associating openid identifier with the user
                     profile = user.get_profile()
                     profile.openid = identifier
                     profile.save()
                 except IntegrityError:
                     raise OpenIDUsernameExistsError
     return user
Example #29
0
File: tests.py Project: crs4/ACTIVE
def create_user():
    user = User()
    user.first_name = 'Ciccio'
    user.last_name = 'Panda'
    user.username = '******'
    user.password = make_password('ciccio')
    return user
Example #30
0
def newaccount_view(request):
    if request.method == 'POST':
        form = NewAccountForm(request.POST)
        info = "Inicializando"
        if form.is_valid():
            first_name = form.cleaned_data['first_name']
            last_name = form.cleaned_data['last_name']
            email = form.cleaned_data['email']
            username = form.cleaned_data['username']
            password = form.cleaned_data['password']
            n = User()
            n.first_name = first_name;
            n.last_name = last_name;
            n.email = email;
            n.username = username;
            n.set_password(password);
            n.save();
            info = "new account :)"
            form = NewAccountForm()
            ctx = {'form': form, 'info': info}
            return render_to_response('home/newaccount.html', ctx, context_instance=RequestContext(request))
        else:
            info = ":( no save... grown data"
            form = NewAccountForm()
            ctx = {'form': form, 'info': info}
            return render_to_response('home/newaccount.html', ctx, context_instance=RequestContext(request))
    else:
        form = NewAccountForm()
        ctx = {'form': form}
        return render_to_response('home/newaccount.html', ctx, context_instance=RequestContext(request))
Example #31
0
def api_add_rp(data):
    """Create a recurrring payment account. Accepted format: json

    Input fields:
        email - required
        description - required
        payment_amount - required
        billing_period - optional, default to 'month'
        billing_frequency - optional, default to 1
        billing_start_dt - optional, default to today
        num_days - optional, default to 0
        has_trial_period - optional, default to False
        trial_period_start_dt - optional, default to today
        trial_period_end_dt - optional, default to today
        trial_amount - optional, default to 0

    Output:
        rp_id - a recurring payment id
        result_code
    """
    ALLOWED_FIELES = ('email',
                      'description',
                      'payment_amount',
                      'billing_period',
                      'billing_frequency',
                      'billing_start_dt',
                      'num_days',
                      'has_trial_period',
                      'trial_period_start_dt',
                      'trial_period_end_dt',
                      'trial_amount',
                      )
    from tendenci.apps.base.utils import validate_email
    import dateutil.parser as dparser
    from tendenci.apps.imports.utils import get_unique_username

    email = data.get('email', '')
    payment_amount = data.get('payment_amount', '')
    try:
        payment_amount = Decimal(payment_amount)
    except:
        payment_amount = 0

    if not all([validate_email(email),
                'description' in data,
                payment_amount>0]):
        return False, {}

    rp = RecurringPayment()
    for key, value in data.items():
        if key in ALLOWED_FIELES:
            if hasattr(rp, key):
                setattr(rp, key, value)

    if rp.billing_start_dt:
        try:
            rp.billing_start_dt = dparser.parse(rp.billing_start_dt)
        except:
            rp.billing_start_dt = datetime.now()
    else:
        rp.billing_start_dt = datetime.now()
    if rp.trial_period_start_dt:
        try:
            rp.trial_period_start_dt = dparser.parse(rp.trial_period_start_dt)
        except:
            rp.trial_period_start_dt = datetime.now()

    if rp.trial_period_end_dt:
        try:
            rp.trial_period_end_dt = dparser.parse(rp.trial_period_end_dt)
        except:
            rp.trial_period_end_dt = datetime.now()

    rp.payment_amount = Decimal(rp.payment_amount)

    try:
        rp.billing_frequency = int(rp.billing_frequency)
    except:
        rp.billing_frequency = 1
    try:
        rp.num_days = int(rp.num_days)
    except:
        rp.num_days = 1
    if rp.has_trial_period in ['True', '1',  True, 1] and all([rp.trial_period_start_dt,
                                                              rp.trial_period_end_dt]):
        rp.has_trial_period = True
    else:
        rp.has_trial_period = False

    # start the real work

#    # get or create a user account with this email
#    users = User.objects.filter(email=email)
#    if users:
#        u = users[0]
#    else:

    # always create a new user account - This is very important!
    # it is to prevent hacker from trying to use somebody else's account.
    u = User()
    u.email=email
    u.username = data.get('username', '')
    if not u.username:
        u.username = email.split('@')[0]
    u.username = get_unique_username(u)
    raw_password = data.get('password', '')
    if not raw_password:
        raw_password = User.objects.make_random_password(length=8)
    u.set_password(raw_password)
    u.first_name = data.get('first_name', '')
    u.last_name = data.get('last_name', '')
    u.is_staff = False
    u.is_superuser = False
    u.save()

#    profile = Profile.objects.create(
#           user=u,
#           creator=u,
#           creator_username=u.username,
#           owner=u,
#           owner_username=u.username,
#           email=u.email
#        )

    # add a recurring payment entry for this user
    rp.user = u
    # activate it when payment info is received
    rp.status_detail = 'inactive'
    rp.save()

    return True, {'rp_id': rp.id}
Example #32
0
def register(request):
    """
        Register a new user and create their UserProfile
    """
    data = request.data

    try:

        # Email input check
        email = str(data['email_id'])
        if not re.match(r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)",
                        email):
            return Response({'message': 'Please enter a valid email address.'},
                            status=403)

        # Unique username check
        username = str(data["username"])
        try:
            user = User.objects.get(username=username)
            return Response({"message": "Username taken"}, status=412)
        except User.DoesNotExist:
            pass

        # Already registered email check
        if UserProfile.objects.filter(auth_user__email=email).exists():
            return Response({"message": "Email already registered"},
                            status=412)

        else:
            first_name = str(data['first_name'])
            last_name = data['last_name']
            password = str(data["password"])
            confirm_pass = str(data["confirm_pass"])
            if password != confirm_pass:
                return Response({"message": "Passwords don't match"},
                                status=412)

            if last_name == None:
                last_name = ''

            if (hasNumbers(first_name) or hasNumbers(last_name)):
                return Response({"message": "Invalid first/last name format"},
                                status=412)

            gender = str(data['gender'])  # M/F/O
            valid_values = ["M", "F", "O"]
            if gender not in valid_values:
                return Response({"message": "Invalid gender value"},
                                status=412)

            age = int(data["age"])

            if not age > 0:
                return Response({"message": "Invalid age value"}, status=412)

            location = str(data["location"])
            if location == "":
                return Response({"message": "Please enter a location"},
                                status=412)

            income = int(data['income'])
            if income < 0:
                return Response({"message": "Invalid income value"},
                                status=412)

            try:
                # Create django User
                user = User()
                user.username = username
                user.email = email
                user.set_password(password)
                user.first_name = first_name
                user.last_name = last_name
                user.save()
                try:
                    # Create UserProfile
                    profile = UserProfile()
                    profile.auth_user = user
                    profile.gender = gender
                    profile.age = age
                    profile.income = income
                    profile.location = location
                    profile.save()
                    return Response({"message": "Registered!"}, status=201)
                except:
                    user.delete()
                    return Response(
                        {"message": "An error occurred. Please try again!"},
                        status=500)
            except:
                return Response(
                    {"message": "An error occurred. Please try again!"},
                    status=500)
    except KeyError as missing_data:
        return Response(
            {'message': 'Data is Missing: {}'.format(missing_data)},
            status=400)
Example #33
0
def createApp(request):
    response = {}
    if request.method == 'POST':

        emailid = request.POST['email']
        dept = Department.objects.get(deptID=request.POST['dept'])
        appPost = Post.objects.get(postID=request.POST['post'])
        if User.objects.filter(email=emailid).exists():
            existingUsers = User.objects.filter(email=emailid)
            for existingUser in existingUsers:
                if UserProfile.objects.filter(
                        user=existingUser,
                        postApplied=appPost.name,
                        departmentApplied=dept.name).exists():
                    return redirect('/register/signup/1')

        pass1 = request.POST['password1']
        pass2 = request.POST['password2']
        if len(pass1) < 8:
            return redirect('/register/signup/3')
        if pass1 != pass2:
            return redirect('/register/signup/2')
        else:
            #users table
            user = User()
            user.first_name = request.POST['firstName']
            user.last_name = request.POST['lastName']
            user.email = request.POST['email']

            #Application ID generation Logic
            year = datetime.datetime.now().year
            yy = str(year)
            p1 = yy[2:]
            p2 = str(dept.deptID).zfill(2)
            p3 = str(appPost.postID)
            dept.appCount = dept.appCount + 1
            dept.save()
            p4 = str(dept.appCount).zfill(5)

            try:
                collegeName = Constants.objects.get(key='college')
            except:
                collegeName = "NITW"

            applicationID = collegeName + p1 + p2 + p3 + p4
            #####

            user.username = applicationID
            user.set_password(pass1)
            user.save()
            #userProfile table

            userprofile = UserProfile()
            userprofile.user = user
            userprofile.postApplied = appPost.name
            userprofile.departmentApplied = dept.name
            userprofile.applicationID = applicationID
            userprofile.contact = request.POST['contact']
            userprofile.termsRead = False
            userprofile.save()
            #APPdata Table

            app_data = Appdata()
            app_data.user = user
            app_data.app_id = userprofile.applicationID
            app_data.post_for = userprofile.postApplied
            app_data.post_in = userprofile.departmentApplied
            nitw = request.POST.get('nitW', 'N')
            print request.POST
            if (nitw == 'Y'):
                app_data.is_nitw = True
                app_data.internal_id = request.POST.get('inID', 0)
            app_data.save()

            pay_data = PaymentDetails()
            pay_data.appID = applicationID
            #pay_data.transID = request.POST['transID']
            pay_data.save()

            response['appID'] = app_data.app_id
            #Mail application ID to applicant
            receiver = user.email
            sender = '*****@*****.**'
            content = 'Your Application ID is : ' + applicationID + "\n Thanks for Registering."
            rlist = []
            rlist.append(receiver)
            try:
                send_mail(
                    'Application Id for Faculty Registration',
                    content,
                    sender,
                    rlist,
                    fail_silently=False,
                )
            except BadHeaderError:
                return HttpResponse('Invalid header found.')
            return render(request, 'registration/regDone.djt', response)
            #return redirect('/register/success')

    return redirect('/register/signup')
Example #34
0
def test_domain_upload(db, requests_mock, current_path):
    # the first answer is cached indefinitely. So the first request has to be correct.

    requests_mock.get(
        "https://publicsuffix.org/list/public_suffix_list.dat",
        text=text(
            f"{current_path}/websecmap/api/tests/public_suffix_list.dat"),
    )

    u = Url()
    u.url = "arnhem.nl"
    u.save()

    # tldextract does not work correctly in tests. This is a workaround to make sure the computed fileds are set.
    # this is nonsense, since tldexcatct is also used in domain checks. This should work correctly.
    # u.computed_suffix = "nl"
    # u.computed_domain = "arnhem"
    # u.computed_subdomain = ""
    # super(Url, u).save()

    # make sure that the domain is fully present, and that things can be matched.
    # ExtractResult(subdomain='arnhem', domain='nl', suffix=''), suffix should be 'nl'
    new_url = Url.objects.all().get(url="arnhem.nl")
    assert new_url.computed_suffix == "nl"
    assert new_url.computed_domain == "arnhem"
    assert new_url.computed_subdomain == ""

    # mock all requests to arnhem.nl, act like they exist:
    requests_mock.get("", text="1")
    websecmap.scanners.scanner.http.resolves = lambda x: True

    # 0,arnhem.nl,www.ris.zeewolde.nl.,1 -> qname not matching 2ndlevel, results in qname domain, but no match in test
    # 334,zeewolde.nl,www.ris.arnhem.nl.,1 -> qname not matching 2ndlevel, results in qname domain, including match
    # Will be skipped as there is no new info: 335,arnhem.nl.,arnhem.nl.,1
    csv_data = """,2ndlevel,qname,distinct_asns
123,arnhem.nl.,*.arnhem.nl.,1
124,arnhem.nl.,01.arnhem.nl.,1
163,arnhem.nl.,01daf671c183434584727ff1c0c29af1.arnhem.nl.,1
2123,arnhem.nl.,www.arnhem.nl.,1
2123,arnhem.nl.,www.arnhem.nl.,1
2123,arnhem.nl.,www.arnhem.nl.,1
2123,arnhem.nl.,www.arnhem.nl.,1
2123,arnhem.nl.,www.arnhem.nl.,1
2123,arnhem.nl.,www.arnhem.nl.,1
2124,arnhem.nl.,www.h.arnhem.nl.,1
2124,arnhem.nl.,www.ris.arnhem.nl.,1
2124,arnhem.nl.,a.b.c.d.e.f.h.arnhem.nl.,1
2124,arnhem.nl.,a.bb.ccc.dddd.eeeee.ffffff.h.arnhem.nl.,1
2124,arnhem.nl.,a.*.ccc.dddd.eeeee.ffffff.h.arnhem.nl.,1
325,arnhem.nl.,14809963d1b7.arnhem.nl.,1
333,arnhem.nl,www.myris.zeewolde.nl.,1
334,zeewolde.nl,www.myris.arnhem.nl.,1
335,arnhem.nl.,arnhem.nl.,1
"""
    assert SIDNUpload.objects.all().count() == 0
    user = User()
    user.first_name = ""
    user.save()
    sidn_domain_upload(user.pk, csv_data)
    assert SIDNUpload.objects.all().count() == 1

    # Create a domain upload for arnhem:
    sidn_handle_domain_upload(1)

    first_upload = SIDNUpload.objects.first()
    assert first_upload.state == "done"
    assert sorted(first_upload.newly_added_domains) == sorted([
        "01.arnhem.nl",
        "01daf671c183434584727ff1c0c29af1.arnhem.nl",
        "www.h.arnhem.nl",
        "www.arnhem.nl",
        "14809963d1b7.arnhem.nl",
        "www.ris.arnhem.nl",
        "a.b.c.d.e.f.h.arnhem.nl",
        "a.bb.ccc.dddd.eeeee.ffffff.h.arnhem.nl",
        "www.myris.arnhem.nl",
    ])
    assert first_upload.amount_of_newly_added_domains == 9
Example #35
0
def return_add_referee(request):
    perm = general_methods.control_access(request)

    if not perm:
        logout(request)
        return redirect('accounts:login')
    user_form = UserForm()
    person_form = PersonForm()
    communication_form = CommunicationForm()

    if request.method == 'POST':

        user_form = UserForm(request.POST)
        person_form = PersonForm(request.POST, request.FILES)
        communication_form = CommunicationForm(request.POST)

        if user_form.is_valid() and person_form.is_valid(
        ) and communication_form.is_valid():
            user = User()
            user.username = user_form.cleaned_data['email']
            user.first_name = user_form.cleaned_data['first_name']
            user.last_name = user_form.cleaned_data['last_name']
            user.email = user_form.cleaned_data['email']
            group = Group.objects.get(name='Hakem')
            password = User.objects.make_random_password()
            user.set_password(password)
            user.is_active = False
            user.save()
            user.groups.add(group)
            user.save()

            person = person_form.save(commit=False)
            communication = communication_form.save(commit=False)
            person.save()
            communication.save()

            judge = Judge(user=user,
                          person=person,
                          communication=communication)

            judge.save()

            # subject, from_email, to = 'WUSHU - Hakem Bilgi Sistemi Kullanıcı Giriş Bilgileri', '[email protected]:81', user.email
            # text_content = 'Aşağıda ki bilgileri kullanarak sisteme giriş yapabilirsiniz.'
            # html_content = '<p> <strong>Site adresi: </strong> <a href="http://sbs.twf.gov.tr:81/"></a>sbs.twf.gov.tr<</p>'
            # html_content = html_content + '<p><strong>Kullanıcı Adı:  </strong>' + user.username + '</p>'
            # html_content = html_content + '<p><strong>Şifre: </strong>' + password + '</p>'
            # msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
            # msg.attach_alternative(html_content, "text/html")
            # msg.send()

            mesaj = str(judge.user.get_full_name()) + ' Hakem eklendi. '
            log = general_methods.logwrite(request, request.user, mesaj)
            messages.success(request, 'Hakem Başarıyla Kayıt Edilmiştir.')
            return redirect('wushu:hakemler')
        else:

            for x in user_form.errors.as_data():
                messages.warning(request, user_form.errors[x][0])

    return render(
        request, 'hakem/hakem-ekle.html', {
            'user_form': user_form,
            'person_form': person_form,
            'communication_form': communication_form
        })
Example #36
0
def main():
    from django.contrib.auth.models import User
    from course.models import Course, CourseInstance, CourseModule
    from course.models import Enrollment, StudentGroup, LearningObjectCategory
    from exercise.exercise_models import BaseExercise
    from exercise.submission_models import Submission

    now = timezone.now()
    year_later = now + timedelta(days=365)

    user0 = User(id=500)
    user0.username = '******'
    user0.first_name = 'Perry'
    user0.last_name = 'Cash'
    user0.email = '*****@*****.**'
    user0.set_password('percash0')
    user0.save()

    user1 = User(id=501)
    user1.username = '******'
    user1.first_name = 'Zorita'
    user1.last_name = 'Alston'
    user1.email = '*****@*****.**'
    user1.set_password('zoralst1')
    user1.save()

    user2 = User(id=502)
    user2.username = '******'
    user2.first_name = 'Cameron'
    user2.last_name = 'Stein'
    user2.email = '*****@*****.**'
    user2.set_password('camstei2')
    user2.save()

    user3 = User(id=503)
    user3.username = '******'
    user3.first_name = 'Brynne'
    user3.last_name = 'Pollard'
    user3.email = '*****@*****.**'
    user3.set_password('brypoll3')
    user3.save()

    user4 = User(id=504)
    user4.username = '******'
    user4.first_name = 'Allistair'
    user4.last_name = 'Blackburn'
    user4.email = '*****@*****.**'
    user4.set_password('allblac4')
    user4.save()

    user5 = User(id=505)
    user5.username = '******'
    user5.first_name = 'Zachary'
    user5.last_name = 'Bolton'
    user5.email = '*****@*****.**'
    user5.set_password('zacbolt5')
    user5.save()

    user6 = User(id=506)
    user6.username = '******'
    user6.first_name = 'Kelsie'
    user6.last_name = 'Wolf'
    user6.email = '*****@*****.**'
    user6.set_password('kelwolf6')
    user6.save()

    user7 = User(id=507)
    user7.username = '******'
    user7.first_name = 'John'
    user7.last_name = 'McCarty'
    user7.email = '*****@*****.**'
    user7.set_password('johmcca7')
    user7.save()

    user8 = User(id=508)
    user8.username = '******'
    user8.first_name = 'Sheila'
    user8.last_name = 'Rodriquez'
    user8.email = '*****@*****.**'
    user8.set_password('sherodr8')
    user8.save()

    user9 = User(id=509)
    user9.username = '******'
    user9.first_name = 'Cassady'
    user9.last_name = 'Stanley'
    user9.email = '*****@*****.**'
    user9.set_password('casstan9')
    user9.save()

    course0 = Course()
    course0.name = 'Test Course'
    course0.url = 'test-course'
    course0.save()

    instance0 = CourseInstance(id=100, course=course0)
    instance0.instance_name = 'Test Instance'
    instance0.url = 'test-instance'
    instance0.starting_time = now
    instance0.ending_time = year_later
    instance0.save()

    Enrollment.objects.create(course_instance=instance0, user_profile=user0.userprofile)
    Enrollment.objects.create(course_instance=instance0, user_profile=user1.userprofile)
    Enrollment.objects.create(course_instance=instance0, user_profile=user2.userprofile)
    Enrollment.objects.create(course_instance=instance0, user_profile=user3.userprofile)
    Enrollment.objects.create(course_instance=instance0, user_profile=user4.userprofile)
    Enrollment.objects.create(course_instance=instance0, user_profile=user5.userprofile)
    Enrollment.objects.create(course_instance=instance0, user_profile=user6.userprofile)
    Enrollment.objects.create(course_instance=instance0, user_profile=user7.userprofile)
    Enrollment.objects.create(course_instance=instance0, user_profile=user8.userprofile)
    Enrollment.objects.create(course_instance=instance0, user_profile=user9.userprofile)

    group0 = StudentGroup.objects.create(id=200, course_instance=instance0)
    group0.members.add(user0.userprofile)
    group0.members.add(user1.userprofile)
    group0.save()

    group1 = StudentGroup.objects.create(id=201, course_instance=instance0)
    group1.members.add(user0.userprofile)
    group1.members.add(user2.userprofile)
    group1.members.add(user3.userprofile)
    group1.save()

    group2 = StudentGroup.objects.create(id=202, course_instance=instance0)
    group2.members.add(user1.userprofile)
    group2.members.add(user4.userprofile)
    group2.save()

    group3 = StudentGroup.objects.create(id=203, course_instance=instance0)
    group3.members.add(user5.userprofile)
    group3.members.add(user6.userprofile)
    group3.members.add(user7.userprofile)
    group3.members.add(user8.userprofile)
    group3.save()

    module0 = CourseModule(course_instance=instance0)
    module0.name = "First module"
    module0.url = "first-module"
    module0.opening_time = now
    module0.closing_time = year_later
    module0.save()

    module1 = CourseModule(course_instance=instance0)
    module1.name = "Second module"
    module1.url = "second-module"
    module1.opening_time = now
    module1.closing_time = year_later
    module1.save()

    category0 = LearningObjectCategory(course_instance=instance0)
    category0.name = "Some category"
    category0.save()

    exercise0 = BaseExercise(id=300, course_module=module0, category=category0)
    exercise0.name = "Easy exercise"
    exercise0.url = 'easy-exercise'
    exercise0.max_submissions = 10
    exercise0.max_group_size = 4
    exercise0.max_points = 100
    exercise0.points_to_pass = 50
    exercise0.save()

    exercise1 = BaseExercise(id=301, course_module=module0, category=category0)
    exercise1.name = "Hard exercise"
    exercise1.url = 'hard-exercise'
    exercise1.max_submissions = 5
    exercise0.max_group_size = 2
    exercise1.max_points = 100
    exercise1.points_to_pass = 100
    exercise1.save()

    exercise2 = BaseExercise(id=302, course_module=module1, category=category0)
    exercise2.name = "Nice exercise"
    exercise2.url = 'nice-exercise'
    exercise2.max_submissions = 0
    exercise2.max_points = 10
    exercise2.points_to_pass = 0
    exercise2.save()

    submission0 = Submission.objects.create(id=400, exercise=exercise0)
    submission0.submitters.add(user0.userprofile)
    submission0.submitters.add(user1.userprofile)
    submission0.feedback = '<html><body>Not bad.</body></html>'
    submission0.set_points(40, 100)
    submission0.set_ready()
    submission0.save()

    submission1 = Submission.objects.create(id=401, exercise=exercise0)
    submission1.submitters.add(user0.userprofile)
    submission1.submitters.add(user1.userprofile)
    submission1.feedback = '<html><body>Good.</body></html>'
    submission1.set_points(60, 100)
    submission1.set_ready()
    submission1.save()

    submission2 = Submission.objects.create(id=402, exercise=exercise0)
    submission2.submitters.add(user1.userprofile)
    submission2.submitters.add(user4.userprofile)
    submission2.feedback = '<html><body>Good.</body></html>'
    submission2.set_points(50, 100)
    submission2.set_ready()
    submission2.save()

    submission3 = Submission.objects.create(id=403, exercise=exercise2)
    submission3.submitters.add(user0.userprofile)
    submission3.feedback = '<html><body>Excellent.</body></html>'
    submission3.set_points(10, 10)
    submission3.set_ready()
    submission3.save()
Example #37
0
def novo_usuario(request):

    id_codigo = request.GET.get("codigo")

    coordenador = False

    if id_codigo and id_codigo.isdigit() and CodigoCadastro.objects.filter(
            codigo=int(id_codigo)).count():
        codigo_cadastro = CodigoCadastro.objects.get(codigo=int(id_codigo))
        form = forms.NovoUsuario(
            initial={
                'nome': codigo_cadastro.nome,
                'email': codigo_cadastro.email,
                'codigo': codigo_cadastro.codigo
            })
        coordenador = codigo_cadastro.coordenador
        sys.stderr.write("Novo usuário é coordenador?" + str(coordenador) +
                         "\n")

    elif request.method == 'POST':
        form = forms.NovoUsuario(request.POST)
    else:
        messages.add_message(request, messages.ERROR,
                             u"É necessário um convite para se cadastrar.")
        return HttpResponseRedirect("/")

    if not id_codigo and form.is_valid():

        email = str(form.cleaned_data["email"])

        if User.objects.filter(email=email).count() == 1:
            usuario = User.objects.get(email=email)
            ja_existia = True
        else:
            usuario = User()
            ja_existia = False

        sys.stderr.write("O usuário já existia?" + str(ja_existia) + "\n")

        usuario.username = form.cleaned_data['login']
        usuario.set_password(form.cleaned_data['senha'])
        usuario.email = form.cleaned_data['email']

        nomes = form.cleaned_data['nome'].split(" ")

        usuario.first_name = nomes[0]
        usuario.last_name = " ".join(nomes[1:])

        codigo = CodigoCadastro.objects.get(codigo=form.cleaned_data['codigo'])

        usuario.save()

        if not codigo.coordenador or request.POST.get('confraternista'):
            if (codigo.juventude.limite_confraternistas -
                    codigo.juventude.codigos_cadastro.count() -
                    codigo.juventude.confraternistas.filter(
                        comebh=Comebh.comebh_vigente()).count()) < 0:
                if codigo.coordenador:
                    messages.error(
                        request,
                        u"O limite de cadastros de confraternistas desta Juventude Espírita foi atingido. Entre em contato com a coordenação geral."
                    )
                else:
                    messages.error(
                        request,
                        u"O limite de cadastros de confraternistas desta Juventude Espírita foi atingido. Entre em contato com a coordenação de sua Juventude Espírita."
                    )
                if not ja_existia:
                    usuario.delete()
                return HttpResponseRedirect("/")

            if ja_existia and Confraternista.objects.filter(
                    usuario=usuario).count():
                conf = Confraternista.objects.filter(
                    usuario=usuario).order_by("-comebh__data_evento")[0]
                conf.pagamento_inscricao = None
                conf.autorizado = False
                conf.tamanho_camisa = None
                conf.pk = None
                sys.stderr.write("O confraternista já existia.\n")
            else:
                conf = Confraternista()

            conf.comebh = Comebh.comebh_vigente()
            conf.usuario = usuario
            conf.juventude = codigo.juventude
            conf.save()

        if codigo.coordenador:
            coord = Coordenador()
            coord.comebh = Comebh.comebh_vigente()
            coord.usuario = usuario
            coord.juventude = codigo.juventude
            coord.save()

        codigo.delete()

        messages.add_message(
            request, messages.INFO,
            u"Seu cadastro foi realizado! Você pode fazer login agora.")
        return HttpResponseRedirect("/")

    return render_to_response("cadastro.html", {
        "form": form,
        "coordenador": coordenador
    },
                              context_instance=RequestContext(request))
Example #38
0
def import_csv():
    doc_root = settings.BASE_DIR + '/media/wushu_csv.csv'
    with open(doc_root) as csv_file:
        file_reader = csv.reader(csv_file, delimiter=';')
        next(file_reader, None)  # skip the headers
        for row in file_reader:
            club = SportsClub()
            club.name = row[14]
            club.shortName = row[15]
            club.foundingDate = row[16]

            club.save()

            comClub = Communication()
            comClub.city = City.objects.get(name__icontains=row[18].strip())
            comClub.phoneNumber = row[17]
            comClub.address = row[19]
            comClub.country = Country.objects.get(name__icontains="TÜRKİYE")
            comClub.save()

            club.comminication = comClub

            club.save()

            user = User()
            user.first_name = row[1]
            user.last_name = row[2]
            user.username = row[10]

            password = User.objects.make_random_password()
            user.set_password(password)
            user.save()

            user.groups.add(Group.objects.get(name='KulupUye'))
            user.save()

            person = Person()
            person.tc = row[0]
            person.motherName = row[3]
            person.fatherName = row[4]
            person.gender = row[5]
            person.birthDate = row[7]
            person.birthplace = row[6]
            person.bloodType = row[8]
            person.save()

            comClubUser = Communication()
            comClubUser.city = City.objects.get(
                name__icontains=row[12].strip())
            comClubUser.phoneNumber = row[11]
            comClubUser.address = row[13]
            comClubUser.country = Country.objects.get(name="TÜRKİYE")
            comClubUser.save()

            sportClubUser = SportClubUser()
            sportClubUser.person = person
            sportClubUser.user = user
            sportClubUser.communication = comClubUser
            sportClubUser.sportClub = club
            sportClubUser.role = ClubRole.objects.get(
                name__icontains=row[9].strip())

            sportClubUser.save()

            print(row)
Example #39
0
def create(request):
    errors = []
    status = ''

    if 'submit' in request.POST:
        user = User()

        username = request.POST.get('username')
        if username:
            if User.objects.filter(username=username).count() < 1:
                user.username = username
            else:
                errors += ['username', 'username_already_taken']
        else:
            errors += ['username', 'invalid_username']

        from django.core.validators import validate_email
        from django.core.exceptions import ValidationError
        email = request.POST.get('email')
        try:
            validate_email(email)

            if User.objects.filter(email=email).count() < 1:
                user.email = email
            else:
                errors += ['email', 'email_already_taken']

        except ValidationError:
            errors += ['email', 'invalid_email']

        user.first_name = request.POST.get('first_name')
        user.last_name = request.POST.get('last_name')

        password = generate_password()
        user.set_password(password)

        if len(errors) < 1:
            user.save()

            user.profile.title = request.POST.get('title')
            user.profile.display_name = request.POST.get('display_name')
            user.profile.school = request.POST.get('school')
            user.profile.bio = request.POST.get('bio')
            user.profile.grade = request.POST.get('grade')
            user.profile.phone = request.POST.get('phone')
            user.profile.comment = request.POST.get('comment')
            user.profile.save()

            for group_id in request.POST.getlist('groups'):
                try:
                    user.groups.add(Group.objects.get(id=group_id))
                except Group.DoesNotExist:
                    pass

            user.save()  # Save the groups information

            if request.POST.get('send_welcome_letter'):
                context = {
                    'sender': request.user,
                    'receiver': user,
                    'password': password,
                    'groups': [g.name for g in user.groups.all()],
                }

                sender_address = format_address(request.user.profile.name,
                                                request.user.email)
                receiver_address = format_address(user.profile.name,
                                                  user.email)
                send_template_mail(sender_address, receiver_address,
                                   'mail/user_welcome.html', context)

            status = 'success'
        else:
            status = 'error'

    return render(request, 'users/create.html', {
        'categories': sorted_categories(),
        'errors': errors,
        'status': status,
    })
Example #40
0
def approve_preRegistration(request, pk):
    perm = general_methods.control_access(request)
    if not perm:
        logout(request)
        return redirect('accounts:login')
    basvuru = PreRegistration.objects.get(pk=pk)
    if basvuru.status != PreRegistration.APPROVED:
        if not (User.objects.filter(email=basvuru.email).exists()):
            # user kaydet
            try:
                user = User()
                user.username = basvuru.email
                user.first_name = basvuru.first_name
                user.last_name = basvuru.last_name
                user.email = basvuru.email
                user.is_active = basvuru.is_active
                user.is_staff = basvuru.is_staff
                group = Group.objects.get(name='KulupUye')
                password = User.objects.make_random_password()
                user.set_password(password)
                user.is_active = True
                user.save()
                user.groups.add(group)
                user.save()
            except:
                messages.warning(request, ' Kullanici eklenmedi ')

            try:
                # person kaydet
                person = Person()
                person.tc = basvuru.tc
                person.height = basvuru.height
                person.weight = basvuru.weight
                person.birthplace = basvuru.birthplace
                person.motherName = basvuru.motherName
                person.fatherName = basvuru.fatherName
                person.profileImage = basvuru.profileImage
                person.birthDate = basvuru.birthDate
                person.bloodType = basvuru.bloodType
                person.gender = basvuru.gender
                person.save()

            except:
                messages.warning(request, ' Kullanici eklenmedi ')

            try:
                # Communication kaydet
                com = Communication()
                com.postalCode = basvuru.postalCode
                com.phoneNumber = basvuru.phoneNumber
                com.phoneNumber2 = basvuru.phoneNumber2
                com.address = basvuru.address
                com.city = basvuru.city
                com.country = basvuru.country
                com.save()

                Sportclup = SportClubUser()
                Sportclup.user = user
                Sportclup.person = person
                Sportclup.communication = com
                Sportclup.role = basvuru.role
                Sportclup.save()

                comclup = Communication()
                comclup.postalCode = basvuru.clubpostalCode
                comclup.phoneNumber = basvuru.clubphoneNumber
                comclup.phoneNumber2 = basvuru.clubphoneNumber2
                comclup.address = basvuru.clubaddress
                comclup.city = basvuru.clubcity
                comclup.country = basvuru.clubcountry
                comclup.save()

                # SportClup
                clup = SportsClub()
                clup.name = basvuru.name
                clup.shortName = basvuru.shortName
                clup.foundingDate = basvuru.foundingDate
                clup.clubMail = basvuru.clubMail
                clup.logo = basvuru.logo
                clup.isFormal = basvuru.isFormal
                clup.communication = comclup
                clup.save()
                clup.clubUser.add(Sportclup)
                clup.save()

                basvuru.status = PreRegistration.APPROVED
                basvuru.save()

                mesaj = str(clup.name) + ' Klup basvurusu onaylandi  '
                log = general_methods.logwrite(request, request.user, mesaj)

            except:
                messages.success(request, 'Klüp ve iletisim kaydedilemedi')

            try:
                subject, from_email, to = 'WUSHU - Kulüp Üye Bilgi Sistemi Kullanıcı Giriş Bilgileri', '*****@*****.**', user.email
                text_content = 'Aşağıda ki bilgileri kullanarak sisteme giriş yapabilirsiniz.'
                html_content = '<p> <strong>Site adresi: </strong> <a href="http://sbs.twf.gov.tr/"></a>sbs.twf.gov.tr</p>'
                html_content = html_content + '<p><strong>Kullanıcı Adı:  </strong>' + user.username + '</p>'
                html_content = html_content + '<p><strong>Şifre: </strong>' + password + '</p>'
                msg = EmailMultiAlternatives(subject, text_content, from_email,
                                             [to])
                msg.attach_alternative(html_content, "text/html")
                msg.send()
                messages.success(
                    request, 'Kullanici kaydedildi ve şifresi  gönderildi.')
            except:
                messages.warning(request, 'mail gönderilemedi')

        else:
            messages.warning(request, 'Mail adresi sistem de kayıtlıdır. ')
    else:
        messages.warning(request, 'Bu basvuru sisteme kaydedilmistir.')

    prepegidtration = PreRegistration.objects.all()
    return render(request, 'kulup/kulupBasvuru.html',
                  {'prepegidtration': prepegidtration})
Example #41
0
def api_rp_setup(data):
    """Create a recurrring payment account. Accepted format: json

    Input fields:
        email - required
        description - required
        amount - required
        cp_id - customer profile id, required
        pp_id - customer payment profile id, required
        billing_cycle_start_dt - required
        billing_cycle_end_dt - required
        response_str - required
        login_name
        login_password
        url
        first_name
        last_name


        billing_period - optional, default to 'month'
        billing_frequency - optional, default to 1
        billing_start_dt - optional, default to today
        num_days - optional, default to 0
        has_trial_period - optional, default to False
        trial_period_start_dt - optional, default to today
        trial_period_end_dt - optional, default to today
        trial_amount - optional, default to 0

    Output:
        rp_id - a recurring payment id
        rp_url - url to rp
        username
        result_code
    """
    from tendenci.apps.base.utils import validate_email
    import dateutil.parser as dparser
    from tendenci.apps.imports.utils import get_unique_username

    email = data.get('email', '')
    description = data.get('description', '')
    url = data.get('url')
    payment_amount = data.get('amount', '')
    taxable = data.get('taxable', 0)
    if taxable in ('True', 'true', '1', 1):
        taxable = 1
    else:
        taxable = 0
    try:
        tax_rate = Decimal(data.get('tax_rate', 0))
        if tax_rate > 1: tax_rate = 0
    except:
        tax_rate = 0
    tax_exempt = data.get('tax_exempt', 0)
    if tax_exempt in ('True', 'true', '1', 1):
        tax_exempt = 1
    else:
        tax_exempt = 0
    try:
        payment_amount = Decimal(payment_amount)
    except:
        payment_amount = 0
    cp_id = data.get('cp_id')
    pp_id = data.get('pp_id')
    billing_cycle_start_dt = data.get('billing_cycle_start_dt')
    if billing_cycle_start_dt:
        billing_cycle_start_dt = dparser.parse(billing_cycle_start_dt)
    billing_cycle_end_dt = data.get('billing_cycle_end_dt')
    if billing_cycle_end_dt:
        billing_cycle_end_dt = dparser.parse(billing_cycle_end_dt)

    direct_response_str = data.get('response_str')

    if not all([
            validate_email(email), description, payment_amount > 0, cp_id,
            pp_id, billing_cycle_start_dt, billing_cycle_end_dt,
            direct_response_str
    ]):
        return False, {}

    # 1) get or create user
    username = data.get('login_name')

    # check if user already exists based on email and username
    users = User.objects.filter(email=email, username=username)
    if users:
        u = users[0]
    else:
        # create user account
        u = User()
        u.email = email
        u.username = username
        if not u.username:
            u.username = email.split('@')[0]
        u.username = get_unique_username(u)
        raw_password = data.get('login_password')
        if not raw_password:
            raw_password = User.objects.make_random_password(length=8)
        u.set_password(raw_password)
        u.first_name = data.get('first_name', '')
        u.last_name = data.get('last_name', '')
        u.is_staff = False
        u.is_superuser = False
        u.save()

        Profile.objects.create(user=u,
                               creator=u,
                               creator_username=u.username,
                               owner=u,
                               owner_username=u.username,
                               email=u.email)

    # 2) create a recurring payment account
    rp = RecurringPayment()
    rp.user = u
    rp.description = description
    rp.url = url
    rp.payment_amount = payment_amount
    rp.taxable = taxable
    rp.tax_rate = tax_rate
    rp.tax_exempt = tax_exempt
    rp.customer_profile_id = cp_id
    rp.billing_start_dt = billing_cycle_start_dt

    has_trial_period = data.get('has_trial_period')
    trial_period_start_dt = data.get('trial_period_start_dt')
    trial_period_end_dt = data.get('trial_period_end_dt')
    if has_trial_period in ['True', '1', True, 1] and all(
        [trial_period_start_dt, trial_period_end_dt]):
        rp.has_trial_period = True
        rp.trial_period_start_dt = dparser.parse(trial_period_start_dt)
        rp.trial_period_end_dt = dparser.parse(trial_period_end_dt)
    else:
        rp.has_trial_period = False

    rp.status_detail = 'active'
    rp.save()

    # 3) create a payment profile account
    payment_profile_exists = PaymentProfile.objects.filter(
        customer_profile_id=cp_id, payment_profile_id=pp_id).exists()
    if not payment_profile_exists:
        PaymentProfile.objects.create(customer_profile_id=cp_id,
                                      payment_profile_id=pp_id,
                                      owner=u,
                                      owner_username=u.username)

    # 4) create rp invoice
    billing_cycle = {
        'start': billing_cycle_start_dt,
        'end': billing_cycle_end_dt
    }
    rp_invoice = rp.create_invoice(billing_cycle, billing_cycle_start_dt)
    rp_invoice.invoice.tender(rp.user)

    # 5) create rp transaction
    now = datetime.now()
    payment = Payment()
    payment.payments_pop_by_invoice_user(rp.user, rp_invoice.invoice,
                                         rp_invoice.invoice.guid)
    payment_transaction = PaymentTransaction(
        recurring_payment=rp,
        recurring_payment_invoice=rp_invoice,
        payment_profile_id=pp_id,
        trans_type='auth_capture',
        amount=rp_invoice.invoice.total,
        status=True)
    payment = payment_update_from_response(payment, direct_response_str)
    payment.mark_as_paid()
    payment.save()
    rp_invoice.invoice.make_payment(rp.user, Decimal(payment.amount))
    rp_invoice.invoice.save()

    rp_invoice.payment_received_dt = now
    rp_invoice.save()
    rp.last_payment_received_dt = now
    rp.num_billing_cycle_completed += 1
    rp.save()

    payment_transaction.payment = payment
    payment_transaction.result_code = data.get('result_code')
    payment_transaction.message_code = data.get('message_code')
    payment_transaction.message_text = data.get('message_text')

    payment_transaction.save()

    site_url = get_setting('site', 'global', 'siteurl')

    return True, {
        'rp_id':
        rp.id,
        'rp_url':
        '%s%s' %
        (site_url, reverse('recurring_payment.view_account', args=[rp.id])),
        'username':
        rp.user.username
    }
Example #42
0
def _crear_usuario(datos_usuario):
    usuario = User(username=datos_usuario['rut'])
    usuario.first_name = datos_usuario['nombre']
    usuario.last_name = datos_usuario['apellido']
    usuario.save()
    return usuario
Example #43
0
def register_employee(csv_path: str) -> None:
    """
		Registers lecturers in the platform.
		Iterates over the rows of a CSV file
		collecting the information to be used
		for the account creation.
		Parameters
		----------
		csv_path: str
			String containing the path to the
			file.
		TODO
		----------
		1. Function do check the information
		used during creation is accurate.
	"""

    msg = ""
    columns = [
        'id', 'password', 'first_name', 'last_name', 'email', 'department',
        'position'
    ]
    with open(csv_path, 'r') as csv_file:
        rows = list(csv.reader(csv_file))

        if validate_header(columns, rows[0]) == False:
            msg = 'Headers are wrong, headers should be: {}'.format(columns)
            return False, msg

        # Check empty values
        for idx, row in enumerate(rows):
            if is_empty(row):
                msg = 'File has an empty cell at index: {}'.format(idx)
                return False, msg

        # Checks all cells exist
        for idx, row in enumerate(rows):
            if len(row) < len(columns):
                msg = 'File has missing cells at index: {}'.format(idx)
                return False, msg

    with open(csv_path, 'r') as csv_file:
        reader = csv.DictReader(csv_file, fieldnames=columns)

        for idx, row in enumerate(reader):  # For each row
            if idx != 0:  # If row isn't the header
                crt_dict = {}
                for column in columns:
                    crt_dict[column] = row[column]
                user1 = User.objects.filter(username=crt_dict['id'])
                if user1.exists() == False:
                    user = User()
                    user.set_password(crt_dict['password'])
                    user.username = crt_dict['id']
                    user.first_name = crt_dict['first_name']
                    user.last_name = crt_dict['last_name']
                    user.email = crt_dict['email']
                    user.save()
                    employee = Employee(user=user,
                                        dpt=crt_dict['department'],
                                        pstn=crt_dict['position'])
                    employee.save()
        return True, msg
Example #44
0
def import_profile():
    call_command('reset', 'auth', interactive=False)
    OLD_USERPIC_PATH = os.path.join('userpic', 'large')
    fields = ['jos_users.id', 'jos_users.username', 'jos_users.email', \
        'jos_users.registerDate','jos_users.lastvisitDate',
        'jos_users.name', 'jos_comprofiler.lastname', \
        'jos_comprofiler.avatar', 'jos_comprofiler.cb_sex', \
        'jos_comprofiler.cb_dr', 'jos_comprofiler.country', \
        'jos_comprofiler.city', 'jos_comprofiler.website',
        'jos_comprofiler.location', 'jos_comprofiler.occupation', \
        'jos_comprofiler.company', 'jos_comprofiler.address', \
        'jos_comprofiler.phone', 'jos_comprofiler.cb_interest', \
        'jos_comprofiler.interests', 'jos_users.password']

    sql = "SELECT %s FROM jos_users JOIN jos_comprofiler\
            ON jos_users.id=jos_comprofiler.user_id" % ', '.join(fields)

    cursor = db.cursor()

    cursor.execute(sql)
    all_users = cursor.fetchall()
    count = 0
    bar = progressbar.ProgressBar(maxval=len(all_users),
                                  widgets=[
                                      'import profile: ',
                                      progressbar.SimpleProgress(),
                                  ]).start()

    decode = lambda x: unicode(x, 'utf8')

    for row in all_users:
        username = decode(row[1])
        cyrillic = sum(1 for char in username
                       if u'\u0400' <= char <= u'\u04FF')
        if cyrillic > 0:
            try:
                username = decode(pytils.translit.translify(username))
            except ValueError:
                username = str(datetime.now())

        username = re.sub(r'[^A-Za-z0-9_]', '_', username)

        username = check_username(username)
        if User.objects.filter(pk=row[0]):
            continue

        user = User(pk=row[0], username=username)

        try:
            user.last_login = datetime.strptime(str(row[4]), \
                '%Y-%m-%d %H:%M:%S')
        except ValueError:
            pass

        try:
            user.date_joined = datetime.strptime(str(row[3]), \
                '%Y-%m-%d %H:%M:%S')
        except ValueError:
            pass

        try:
            user.first_name = decode(row[5][:30])
        except:
            pass

        try:
            user.email = decode(row[2][:128])
        except:
            pass

        try:
            user.save()
        except:
            print user.id

        old_auth = OldAuth(user=user, password=row[20])
        old_auth.save()

        userpic = row[7]
        if userpic:
            path = os.path.join(OLD_USERPIC_PATH, userpic)
            user.profile.userpic = path

        if row[8] == 'женский':
            user.profile.sex = 'female'
        elif row[8] == 'мужской':
            user.profile.sex = 'male'
        user.profile.birthday = row[9]

        try:
            user.profile.country = decode(row[10][:50])
        except:
            pass
        try:
            user.profile.city = decode(row[11][:50])
        except:
            pass
        try:
            user.profile.web_site = row[12]
        except:
            pass
        try:
            user.profile.icq = decode(row[13][:15])
        except:
            pass
        try:
            user.profile.profession = decode(row[14])
        except:
            pass
        try:
            user.profile.company = decode(row[15])
        except:
            pass
        try:
            user.profile.address = decode(row[16])
        except:
            pass
        try:
            user.profile.phone_number = decode(row[17][:50])
        except:
            pass
        try:
            user.profile.interest = decode(str(row[18]))
        except:
            pass
        try:
            user.profile.about = decode(row[19])
        except:
            pass
        user.profile.save()

        count += 1
        bar.update(count)

    bar.finish()
    magog = User.objects.get(pk=1791)
    magog.is_staff, magog.is_superuser = True, True
    magog.save()
def update_profile(user: User, first_name: str, last_name: str, email: str):
    user.first_name = first_name
    user.last_name = last_name
    user.email = email

    user.save()
Example #46
0
def upload_view(request):
    if not request.user.is_superuser:
        raise exceptions.PermissionDenied

    if request.method == 'POST':  # if form submitted...
        form = UploadProfileForm(request.POST, request.FILES)
        if form.is_valid():
            request.FILES['upload_file'].open("rb")
            csv_file = csv.DictReader(request.FILES['upload_file'].file)
            required_fields = ['username', 'firstname', 'lastname', 'email']
            results = []
            try:
                for row in csv_file:
                    # check all required fields defined
                    all_defined = True
                    for rf in required_fields:
                        if rf not in row or row[rf].strip() == '':
                            result = {}
                            result['username'] = row['username']
                            result['created'] = False
                            result['message'] = _(u'No %s set' % rf)
                            results.append(result)
                            all_defined = False

                    if not all_defined:
                        continue

                    user = User()
                    user.username = row['username']
                    user.first_name = row['firstname']
                    user.last_name = row['lastname']
                    user.email = row['email']
                    auto_password = False
                    if 'password' in row:
                        user.set_password(row['password'])
                    else:
                        password = User.objects.make_random_password()
                        user.set_password(password)
                        auto_password = True
                    try:
                        user.save()
                        up = UserProfile()
                        up.user = user
                        for col_name in row:
                            setattr(up, col_name, row[col_name])
                        up.save()
                        result = {}
                        result['username'] = row['username']
                        result['created'] = True
                        if auto_password:
                            result['message'] = _(
                                u'User created with password: %s' % password)
                        else:
                            result['message'] = _(u'User created')
                        results.append(result)
                    except IntegrityError as ie:
                        result = {}
                        result['username'] = row['username']
                        result['created'] = False
                        result['message'] = _(u'User already exists')
                        results.append(result)
                        continue
            except:
                result = {}
                result['username'] = None
                result['created'] = False
                result['message'] = _(u'Could not parse file')
                results.append(result)

    else:
        results = []
        form = UploadProfileForm()

    return render(request, 'oppia/profile/upload.html', {
        'form': form,
        'results': results
    })
Example #47
0
def facebook_callback(request):
    """ This method is responsible for the facebook callback and generating the facebook user.
    """

    if 'error' in request.GET:
        return HttpResponseRedirect('/')

    code = request.GET["code"]

    args = dict(client_id=keys.FACEBOOK_APP_ID,
                redirect_uri='http://tini.ep.io/facebook/callback',
                client_secret=keys.FACEBOOK_APP_SECRET,
                code=code)

    token_url = 'https://graph.facebook.com/oauth/access_token?' + urllib.urlencode(
        args)
    data = urllib.urlopen(token_url)
    response = data.read()
    data.close()

    # print 'Token URL:' + token_url
    # print 'Response:'
    # print response

    try:
        split = response.split('=')
        access_token = split[1].strip('&expires')
        expires = split[2]

        # print 'Access Token: ' + access_token
        # print 'Expires: ' + expires
    except:
        error = json.loads(response)
        return HttpResponseRedirect('/error')

    profile = json.load(
        urllib.urlopen('https://graph.facebook.com/me?' +
                       urllib.urlencode(dict(access_token=access_token))))

    args = dict(access_token=access_token)

    graph_url = 'https://graph.facebook.com/me?' + urllib.urlencode(args)
    #print graph_url

    response = urllib.urlopen(graph_url)
    facebook_user = json.load(response)

    username = facebook_user.get('username', '')
    gender = facebook_user.get('gender', '')

    try:
        player = Player.objects.get(facebook_id=facebook_user.get('id', None))
    except ObjectDoesNotExist:
        user = User(username=username)
        user.set_password(access_token)
        user.first_name = facebook_user['first_name']
        user.last_name = facebook_user['last_name']
        user.email = facebook_user['email']

        player = Player()
        player.user = user
        player.gender = get_gender_initial(gender=gender)
        player.facebook_id = facebook_user['id']
        player.facebook_oauth_token = access_token
        request.session['facebook'] = player
        form = PlayerForm(
            initial={
                'username': player.user.username,
                'first_name': user.first_name,
                'last_name': user.last_name,
                'email': player.user.email,
                'gender': player.gender
            })
        return render(request, 'register.html', {'form': form})

    # player = Player.objects.get(user=user)
    # print player
    user = authenticate(username=player.user.username,
                        password=player.facebook_oauth_token)
    login(request, user)
    return HttpResponseRedirect('/')
Example #48
0
def add(request, form_class=DonationForm, template_name="donations/add.html"):
    use_captcha = get_setting('site', 'global', 'captcha')

    if request.method == "POST":
        form = form_class(request.POST, user=request.user)
        captcha_form = CaptchaForm(request.POST)
        if not use_captcha:
            del captcha_form.fields['captcha']

        if form.is_valid() and captcha_form.is_valid():
            donation = form.save(commit=False)
            donation.payment_method = donation.payment_method.lower()
            # we might need to create a user record if not exist
            if request.user.is_authenticated:
                user = request.user
            else:
                try:
                    user = User.objects.get(email=donation.email)
                except:
                    user = request.user

            if not user.is_anonymous:
                donation.user = user
                donation.creator = user
                donation.creator_username = user.username
            else:
                # this is anonymous user donating and we didn't find their user record in the system,
                # so add a new user
                user = User()
                user.first_name = donation.first_name
                user.last_name = donation.last_name
                user.email = donation.email
                user.username = get_unique_username(user)
                user.set_password(User.objects.make_random_password(length=8))
                user.is_active = 0
                user.save()

                profile_kwarg = {
                    'user': user,
                    'company': donation.company or '',
                    'address': donation.address or '',
                    'address2': donation.address2 or '',
                    'city': donation.city or '',
                    'state': donation.state or '',
                    'zipcode': donation.zip_code or '',
                    'country': donation.country or '',
                    'phone': donation.phone or ''
                }
                if request.user.is_anonymous:
                    profile_kwarg['creator'] = user
                    profile_kwarg['creator_username'] = user.username
                    profile_kwarg['owner'] = user
                    profile_kwarg['owner_username'] = user.username
                else:
                    profile_kwarg['creator'] = request.user
                    profile_kwarg['creator_username'] = request.user.username
                    profile_kwarg['owner'] = request.user
                    profile_kwarg['owner_username'] = request.user.username

                profile = Profile.objects.create(**profile_kwarg)
                profile.save()

            donation.save(user)

            # create invoice
            invoice = donation_inv_add(user, donation)
            # updated the invoice_id for mp, so save again
            donation.save(user)

            if request.user.profile.is_superuser:
                if donation.payment_method in ['paid - check', 'paid - cc']:
                    # the admin accepted payment - mark the invoice paid
                    invoice.tender(request.user)
                    invoice.make_payment(request.user,
                                         donation.donation_amount)

            # send notification to administrators
            # get admin notice recipients
            if not donation.payment_method.lower() in [
                    'cc', 'credit card', 'paypal'
            ]:
                # email to admin (if payment type is credit card email is not sent until payment confirmed)
                recipients = get_notice_recipients('module', 'donations',
                                                   'donationsrecipients')
                if recipients:
                    if notification:
                        extra_context = {
                            'donation': donation,
                            'invoice': invoice,
                            'request': request,
                        }
                        notification.send_emails(recipients, 'donation_added',
                                                 extra_context)

            # email to user
            email_receipt = form.cleaned_data['email_receipt']
            if email_receipt:
                donation_email_user(request, donation, invoice)

            EventLog.objects.log(instance=donation)

            # redirect to online payment or confirmation page
            if donation.payment_method.lower() in [
                    'cc', 'credit card', 'paypal'
            ]:
                return HttpResponseRedirect(
                    reverse('payment.pay_online',
                            args=[invoice.id, invoice.guid]))
            else:
                return HttpResponseRedirect(
                    reverse('donation.add_confirm', args=[donation.id]))
    else:
        form = form_class(user=request.user)
        captcha_form = CaptchaForm()

    currency_symbol = get_setting("site", "global", "currencysymbol")
    if not currency_symbol: currency_symbol = "$"

    return render_to_resp(request=request,
                          template_name=template_name,
                          context={
                              'form': form,
                              'captcha_form': captcha_form,
                              'use_captcha': use_captcha,
                              'currency_symbol': currency_symbol
                          })
Example #49
0
def motion_import(request):
    if request.method == 'POST':
        form = MotionImportForm(request.POST, request.FILES)
        if form.is_valid():
            import_permitted = form.cleaned_data['import_permitted']
            try:
                # check for valid encoding (will raise UnicodeDecodeError if not)
                request.FILES['csvfile'].read().decode('utf-8')
                request.FILES['csvfile'].seek(0)

                users_generated = 0
                motions_generated = 0
                motions_modified = 0
                groups_assigned = 0
                groups_generated = 0
                with transaction.commit_on_success():
                    dialect = csv.Sniffer().sniff(request.FILES['csvfile'].readline())
                    dialect = csv_ext.patchup(dialect)
                    request.FILES['csvfile'].seek(0)
                    for (lno, line) in enumerate(csv.reader(request.FILES['csvfile'], dialect=dialect)):
                        # basic input verification
                        if lno < 1:
                            continue
                        try:
                            (number, title, text, reason, first_name, last_name, is_group) = line[:7]
                            if is_group.strip().lower() in ['y', 'j', 't', 'yes', 'ja', 'true', '1', 1]:
                                is_group = True
                            else:
                                is_group = False
                        except ValueError:
                            messages.error(request, _('Ignoring malformed line %d in import file.') % (lno + 1))
                            continue
                        form = MotionForm({'title': title, 'text': text, 'reason': reason})
                        if not form.is_valid():
                            messages.error(request, _('Ignoring malformed line %d in import file.') % (lno + 1))
                            continue
                        if number:
                            try:
                                number = abs(long(number))
                                if number < 1:
                                    messages.error(request, _('Ignoring malformed line %d in import file.') % (lno + 1))
                                    continue
                            except ValueError:
                                messages.error(request, _('Ignoring malformed line %d in import file.') % (lno + 1))
                                continue
                        
                        if is_group:
                            # fetch existing groups or issue an error message
                            try:
                                user = Group.objects.get(name=last_name)
                                if user.group_as_person == False:
                                    messages.error(request, _('Ignoring line %d because the assigned group may not act as a person.') % (lno + 1))
                                    continue
                                else:
                                    user = get_person(user.person_id)

                                groups_assigned += 1
                            except Group.DoesNotExist:
                                group = Group()
                                group.group_as_person = True
                                group.description = _('Created by motion import.')
                                group.name = last_name
                                group.save()
                                groups_generated += 1

                                user = get_person(group.person_id)
                        else:
                            # fetch existing users or create new users as needed
                            try:
                                user = User.objects.get(first_name=first_name, last_name=last_name)
                            except User.DoesNotExist:
                                user = None
                            if user is None:
                                if not first_name or not last_name:
                                    messages.error(request, _('Ignoring line %d because it contains an incomplete first / last name pair.') % (lno + 1))
                                    continue

                                user = User()
                                user.last_name = last_name
                                user.first_name = first_name
                                user.username = gen_username(first_name, last_name)
                                user.structure_level = ''
                                user.committee = ''
                                user.gender = ''
                                user.type = ''
                                user.default_password = gen_password()
                                user.save()
                                user.reset_password()
                                users_generated += 1
                        # create / modify the motion
                        motion = None
                        if number:
                            try:
                                motion = Motion.objects.get(number=number)
                                motions_modified += 1
                            except Motion.DoesNotExist:
                                motion = None
                        if motion is None:
                            motion = Motion(submitter=user)
                            if number:
                                motion.number = number
                            motions_generated += 1

                        motion.title = form.cleaned_data['title']
                        motion.text = form.cleaned_data['text']
                        motion.reason = form.cleaned_data['reason']
                        if import_permitted:
                            motion.status = 'per'

                        motion.save(user, trivial_change=True)

                if motions_generated:
                    messages.success(request, ungettext('%d motion was successfully imported.',
                                                '%d motions were successfully imported.', motions_generated) % motions_generated)
                if motions_modified:
                    messages.success(request, ungettext('%d motion was successfully modified.',
                                                '%d motions were successfully modified.', motions_modified) % motions_modified)
                if users_generated:
                    messages.success(request, ungettext('%d new user was added.', '%d new users were added.', users_generated) % users_generated)

                if groups_generated:
                    messages.success(request, ungettext('%d new group was added.', '%d new groups were added.', groups_generated) % groups_generated)

                if groups_assigned:
                    messages.success(request, ungettext('%d group assigned to motions.', '%d groups assigned to motions.', groups_assigned) % groups_assigned)
                return redirect(reverse('motion_overview'))

            except csv.Error:
                message.error(request, _('Import aborted because of severe errors in the input file.'))
            except UnicodeDecodeError:
                messages.error(request, _('Import file has wrong character encoding, only UTF-8 is supported!'))
        else:
            messages.error(request, _('Please check the form for errors.'))
    else:
        messages.warning(request, _("Attention: Existing motions will be modified if you import new motions with the same number."))
        messages.warning(request, _("Attention: Importing an motions without a number multiple times will create duplicates."))
        form = MotionImportForm()
    return {
        'form': form,
    }
Example #50
0
def register(request):
    # A boolean value for telling the template whether the registration was successful.
    # Set to False initially. Code changes value to True when registration succeeds.

    # If it's a HTTP POST, we're interested in processing form data.
    if request.method == 'POST':
        # Attempt to grab information from the raw POST information.
        studentUser = Student()
        standardUser = User()
        message = []
        isregistered = False

        firstname = request.POST['firstname']
        lastname = request.POST['lastname']
        username = request.POST['email']
        email = request.POST['email']
        password1 = request.POST['password1']
        password2 = request.POST['password2']
        # studentID = request.POST['idnum']  # No ID number provided

        if username == "":
            message.append("Please enter a valid username")

        if password1 == "" or password2 == "":
            message.append("Please fill in both password blocks")

        if firstname == "" or lastname == "":
            message.append("Please fully fill in your name and last name")

        if email == "" or '@' not in str(email):
            message.append("Please fill in the email address block")

        # if studentID is None or len(studentID) > 8 or len(studentID) < 7:
        #     message.append("The ID Number provided is invalid")

        if (password1 == password2) and (message == []):
            # Everything checks out and is all working fine :)
            # Create the Standard User first and try storing it in the database
            standardUser.set_password(password1)
            standardUser.username = username
            standardUser.email = email
            standardUser.first_name = firstname
            standardUser.last_name = lastname
            standardUser.is_active = False
            standardUser.is_staff = False
            standardUser.is_superuser = False
            try:
                standardUser.save()  # Save the Django user in the Database.
                # Now let's try putting that Student user in the DB
                studentUser.user = standardUser
                newRecord = StudentRecord()
                newRecord.save()
                studentUser.academicRecord = newRecord
                only_option = AcademicProgram.objects.get(pk=5)  # SOEN!
                # # We need to create and save a main schedule as well to the student
                studentUser.save()
                isregistered = True
                # send an email with an SSH hash of the user as a confirmation link:
                # since it will cause errors on Windows and most development is being done on windows,
                # first check that we are on Linux before attempting to send email.
                # Else, just register with no confirmation.
                if "inux" in platform.system():
                    subject, from_email, to = 'Echelon Planner Confirmation', '*****@*****.**', str(standardUser.email)
                    hasheduser = str(hashlib.sha256(standardUser.email.encode()).hexdigest())
                    authLink = str(request.get_host()+"/confirm/" + hasheduser)
                    html_content = '<p>Please click on the following link to confirm your Echelon Planner account: </p><p><a href='+authLink+'>'+authLink+'</a></p>'
                    msg = EmailMultiAlternatives(subject, html_content, from_email, [standardUser.email])
                    msg.content_subtype = "html"
                    msg.send()
                else:
                    standardUser.is_active = True
                    standardUser.save()
            except IntegrityError as problem:
                # Student or auth_user was duplicate
                isregistered = False
                logger.warn(str(problem.args))
                message.append("User already Exists!")
        # end last If check

        if isregistered:
            if standardUser.is_active:
                return render(request,
                      'app/login.html',
                      {'hasMessage': True, 'message': ['Registration is successful.'], 'registered': isregistered})
            else:
                return render(request,
                      'app/login.html',
                      {'hasMessage': True, 'message': ['Registration is successful. Please check your email for a confirmation link before you login.'], 'registered': isregistered})

        else:  # User was not registered
            return render_to_response(
                      'app/register.html',
                      {'hasMessage': True, 'message': message, 'registered': isregistered},
                      context_instance=RequestContext(request))

        # end If Request==Post

    else:  # Request is not Post, just serve the damn page
        return render(request,
                  'app/register.html')
Example #51
0
def deal_checkout(request, slug):
    '''
    FIXME: Clean this mess
    
    @param request:
    @param slug: deal slug
    '''
    try:
        deal = Deal.objects.get(slug=slug)
    except:
        messages.error(request, _('Cannot load requested deal.'))
        return HttpResponseRedirect('/')

    must_login_error = False
    must_login_email = None
    user = None
    form = None

    if request.method == 'POST':  # If the form has been submitted...
        # try create user
        if request.user.is_authenticated():
            user = request.user
        else:
            form = DealCheckoutForm(request.POST)
            if form.is_valid():
                try:
                    # FIXME: use form's cleaned_data not raw POST
                    user = User.objects.get(email=form.cleaned_data['email'])
                    must_login_error = True
                    must_login_email = request.POST['email']
                    form = DealCheckoutForm(initial={})
                    user_msg = 'An account already exists for ' + user.email + '. Please sign in first.'

                    user = User()
                    user.username = form.cleaned_data[
                        'email']  #str(uuid.uuid4())[:30]
                    user.first_name = form.cleaned_data['full_name']
                    user.email = form.cleaned_data['email']
                    user.set_password(form.cleaned_data['password'])
                    user.save()

                    user = authenticate(username=user.username,
                                        password=form.cleaned_data['password'])
                    if user is not None:
                        if user.is_active:
                            login(request, user)
                        else:
                            messages.add_message(
                                request, messages.ERROR,
                                "Unable to login with these credentails.")
                            user = None
                            # Return a 'disabled account' error message
                    else:
                        messages.add_message(request, messages.ERROR,
                                             "Cannot create/auth user.")
                        # Return an 'invalid login' error message.
                        pass
                except Exception, e:
                    logging.warning("Exception: %s" % e)
                    user = None
            else:
                user = None
                logging.warning("Invalid form")
def approve_preRegistration(request, pk):
    perm = general_methods.control_access(request)
    if not perm:
        logout(request)
        return redirect('accounts:login')
    basvuru = PreRegistration.objects.get(pk=pk)
    if basvuru.status != PreRegistration.APPROVED:
        mail = basvuru.email
        if not (User.objects.filter(email=mail) or ReferenceCoach.objects.exclude(status=ReferenceCoach.DENIED).filter(
                email=mail) or ReferenceReferee.objects.exclude(status=ReferenceReferee.DENIED).filter(email=mail)):

            user = User()
            user.username = basvuru.email
            user.first_name = unicode_tr(basvuru.first_name).upper()
            user.last_name = unicode_tr(basvuru.last_name).upper()
            user.email = basvuru.email
            user.is_active = True
            user.is_staff = basvuru.is_staff
            group = Group.objects.get(name='KlupUye')
            password = User.objects.make_random_password()
            user.set_password(password)
            user.save()
            user.groups.add(group)
            user.save()

            # person kaydet
            person = Person()
            person.tc = basvuru.tc
            person.birthplace = basvuru.birthplace
            person.motherName = basvuru.motherName
            person.fatherName = basvuru.fatherName
            person.profileImage = basvuru.profileImage
            person.birthDate = basvuru.birthDate
            person.bloodType = basvuru.bloodType
            if basvuru.gender == 'Erkek':
                person.gender = Person.MALE
            else:
                person.gender = Person.FEMALE
            person.save()

            # Communication kaydet
            com = Communication()
            com.postalCode = basvuru.postalCode
            com.phoneNumber = basvuru.phoneNumber
            com.phoneNumber2 = basvuru.phoneNumber2
            com.address = basvuru.address
            com.city = basvuru.city
            com.country = basvuru.country
            com.save()

            Sportclup = SportClubUser()
            Sportclup.user = user
            Sportclup.person = person
            Sportclup.communication = com
            Sportclup.role = basvuru.role
            Sportclup.save()

            comclup = Communication()
            comclup.postalCode = basvuru.clubpostalCode
            comclup.phoneNumber = basvuru.clubphoneNumber
            comclup.phoneNumber2 = basvuru.clubphoneNumber2
            comclup.address = basvuru.clubaddress
            comclup.city = basvuru.clubcity
            comclup.country = basvuru.clubcountry
            comclup.save()

            # SportClup
            clup = SportsClub()
            clup.name = basvuru.name
            clup.shortName = basvuru.shortName
            clup.foundingDate = basvuru.foundingDate
            clup.clubMail = basvuru.clubMail
            clup.logo = basvuru.logo
            clup.isFormal = basvuru.isFormal
            clup.petition = basvuru.petition
            clup.communication = comclup
            clup.save()
            clup.clubUser.add(Sportclup)
            clup.save()
            # burada kadik
            if basvuru.isCoach:

                coach = Coach()
                coach.user = user
                coach.person = person
                coach.communication = com
                coach.iban = basvuru.iban
                coach.save()
                group = Group.objects.get(name='Antrenor')
                user.groups.add(group)
                user.save()
                grade = Level(
                    startDate=basvuru.kademe_startDate,
                    dekont=basvuru.kademe_belge,
                    branch=EnumFields.HALTER.value)
                try:
                    grade.definition = CategoryItem.objects.get(name=basvuru.kademe_definition)
                except:
                    grade.definition = CategoryItem.objects.get(name='1.Kademe')

                grade.levelType = EnumFields.LEVELTYPE.GRADE
                grade.status = Level.APPROVED
                grade.isActive = True
                grade.save()
                coach.grades.add(grade)
                coach.save()

                clup.coachs.add(coach)
                clup.save()

            basvuru.status = PreRegistration.APPROVED
            basvuru.save()

            fdk = Forgot(user=user, status=False)
            fdk.save()

            html_content = ''
            subject, from_email, to = 'Bilgi Sistemi Kullanıcı Bilgileri', '*****@*****.**', user.email
            html_content = '<h2>TÜRKİYE BADMİNTON FEDERASYONU BİLGİ SİSTEMİ</h2>'
            html_content = html_content + '<p><strong>Kullanıcı Adınız :' + str(fdk.user.username) + '</strong></p>'
            html_content = html_content + '<p> <strong>Site adresi:</strong> <a href="http://sbs.badminton.gov.tr/newpassword?query=' + str(
                fdk.uuid) + '">http://sbs.badminton.gov.tr/sbs/profil-guncelle/?query=' + str(fdk.uuid) + '</p></a>'
            msg = EmailMultiAlternatives(subject, '', from_email, [to])
            msg.attach_alternative(html_content, "text/html")
            msg.send()
            messages.success(request, 'Başari ile kaydedildi')

            log = str(clup) + " Klup basvurusu onaylandi"
            log = general_methods.logwrite(request, request.user, log)

            # try:
            #     # user kaydet
            #     print()
            # except:
            #     messages.warning(request, 'Lütfen sistem yöneticisi ile görüşünüz ')
            #     log = str(basvuru.name) + " Klup basvurusu hata oldu"
            #     log = general_methods.logwrite(request, request.user, log)

        else:
            messages.warning(request, 'Mail adresi sistem de kayıtlıdır.')
    else:
        messages.warning(request, 'Bu basvuru sisteme kaydedilmistir.')

    prepegidtration = PreRegistration.objects.all()
    return render(request, 'kulup/kulupBasvuru.html',
                  {'prepegidtration': prepegidtration})
Example #53
0
def bind_email(request):
    open_id = request.GET.get('open_id')
    nickname = request.GET.get('nickname')
    oauth_type = request.GET.get('oauth_type')
    state = request.GET.get('state') or '/'
    data = {}

    # 判断oauth类型
    oauth_types = OAuth_type.objects.filter(type_name=oauth_type)
    if oauth_types.count() > 0:
        oauth_type = oauth_types[0]
        img_url = oauth_type.img
    else:
        data['goto_url'] = state
        data['goto_time'] = 3000
        data['goto_page'] = True
        data['message'] = u'错误的登录类型,请检查'
        return render_to_response('message.html', data)

    data['form_title'] = u'绑定用户'
    data['submit_name'] = u' 确定 '
    data['form_tip'] = u'Hi, <span class="label label-info"><img src="/%s">%s</span>!您已登录。请绑定用户,完成登录' % (
    img_url, nickname)

    if request.method == 'POST':
        # 表单提交
        form = BindEmail(request.POST)

        # 验证是否合法
        if form.is_valid():
            # 判断邮箱是否注册了
            openid = form.cleaned_data['openid']
            nickname = form.cleaned_data['nickname']
            email = form.cleaned_data['email']
            pwd = form.cleaned_data['pwd']

            users = User.objects.filter(email=email)
            if users:
                # 用户存在,则直接绑定
                user = users[0]
                if not user.first_name:
                    user.first_name = nickname  # 更新昵称
                    user.save()
                data['message'] = u'绑定账号成功,绑定到%s”' % email
            else:
                # 用户不存在,则注册,并发送激活邮件
                user = User(username=email, email=email)
                user.first_name = nickname  # 使用第三方账号昵称作为昵称
                user.set_password(pwd)
                user.is_active = True  # 激活,此处也可以不用先激活。发送一个邮件确认用户身份,再激活
                user.save()

                data['message'] = u'绑定账号成功'

            # 绑定用户
            oauth_ex = OAuth_ex(user=user, openid=openid, oauth_type=oauth_type)
            oauth_ex.save()

            # 登录用户
            user = authenticate(username=email, password=pwd)
            if user is not None:
                login(request, user)

            # 页面提示
            data['goto_url'] = state
            data['goto_time'] = 3000
            data['goto_page'] = True

            return render_to_response('message.html', data)
    else:
        # 正常加载
        form = BindEmail(initial={
            'openid': open_id,
            'nickname': nickname,
            'oauth_type_id': oauth_type.id,
        })
    data['form'] = form
    return render(request, 'oauth.html', data)
Example #54
0
def import_data():
    # Initial Imports

    # Processing model: django.contrib.auth.models.Permission

    from django.contrib.auth.models import Permission

    # auth_permission_1 = Permission()
    # auth_permission_1.name = u'Can add log entry'
    # auth_permission_1.content_type = ContentType.objects.get(app_label="admin", model="logentry")
    # auth_permission_1.codename = u'add_logentry'
    # auth_permission_1 = importer.save_or_locate(auth_permission_1)

    # auth_permission_2 = Permission()
    # auth_permission_2.name = u'Can change log entry'
    # auth_permission_2.content_type = ContentType.objects.get(app_label="admin", model="logentry")
    # auth_permission_2.codename = u'change_logentry'
    # auth_permission_2 = importer.save_or_locate(auth_permission_2)

    # auth_permission_3 = Permission()
    # auth_permission_3.name = u'Can delete log entry'
    # auth_permission_3.content_type = ContentType.objects.get(app_label="admin", model="logentry")
    # auth_permission_3.codename = u'delete_logentry'
    # auth_permission_3 = importer.save_or_locate(auth_permission_3)

    # auth_permission_4 = Permission()
    # auth_permission_4.name = u'Can add group'
    # auth_permission_4.content_type = ContentType.objects.get(app_label="auth", model="group")
    # auth_permission_4.codename = u'add_group'
    # auth_permission_4 = importer.save_or_locate(auth_permission_4)

    # auth_permission_5 = Permission()
    # auth_permission_5.name = u'Can change group'
    # auth_permission_5.content_type = ContentType.objects.get(app_label="auth", model="group")
    # auth_permission_5.codename = u'change_group'
    # auth_permission_5 = importer.save_or_locate(auth_permission_5)

    # auth_permission_6 = Permission()
    # auth_permission_6.name = u'Can delete group'
    # auth_permission_6.content_type = ContentType.objects.get(app_label="auth", model="group")
    # auth_permission_6.codename = u'delete_group'
    # auth_permission_6 = importer.save_or_locate(auth_permission_6)

    # auth_permission_7 = Permission()
    # auth_permission_7.name = u'Can add permission'
    # auth_permission_7.content_type = ContentType.objects.get(app_label="auth", model="permission")
    # auth_permission_7.codename = u'add_permission'
    # auth_permission_7 = importer.save_or_locate(auth_permission_7)

    # auth_permission_8 = Permission()
    # auth_permission_8.name = u'Can change permission'
    # auth_permission_8.content_type = ContentType.objects.get(app_label="auth", model="permission")
    # auth_permission_8.codename = u'change_permission'
    # auth_permission_8 = importer.save_or_locate(auth_permission_8)

    # auth_permission_9 = Permission()
    # auth_permission_9.name = u'Can delete permission'
    # auth_permission_9.content_type = ContentType.objects.get(app_label="auth", model="permission")
    # auth_permission_9.codename = u'delete_permission'
    # auth_permission_9 = importer.save_or_locate(auth_permission_9)

    # auth_permission_10 = Permission()
    # auth_permission_10.name = u'Can add user'
    # auth_permission_10.content_type = ContentType.objects.get(app_label="auth", model="user")
    # auth_permission_10.codename = u'add_user'
    # auth_permission_10 = importer.save_or_locate(auth_permission_10)

    # auth_permission_11 = Permission()
    # auth_permission_11.name = u'Can change user'
    # auth_permission_11.content_type = ContentType.objects.get(app_label="auth", model="user")
    # auth_permission_11.codename = u'change_user'
    # auth_permission_11 = importer.save_or_locate(auth_permission_11)

    # auth_permission_12 = Permission()
    # auth_permission_12.name = u'Can delete user'
    # auth_permission_12.content_type = ContentType.objects.get(app_label="auth", model="user")
    # auth_permission_12.codename = u'delete_user'
    # auth_permission_12 = importer.save_or_locate(auth_permission_12)

    # auth_permission_13 = Permission()
    # auth_permission_13.name = u'Can add post'
    # auth_permission_13.content_type = ContentType.objects.get(app_label="blog", model="post")
    # auth_permission_13.codename = u'add_post'
    # auth_permission_13 = importer.save_or_locate(auth_permission_13)

    # auth_permission_14 = Permission()
    # auth_permission_14.name = u'Can change post'
    # auth_permission_14.content_type = ContentType.objects.get(app_label="blog", model="post")
    # auth_permission_14.codename = u'change_post'
    # auth_permission_14 = importer.save_or_locate(auth_permission_14)

    # auth_permission_15 = Permission()
    # auth_permission_15.name = u'Can delete post'
    # auth_permission_15.content_type = ContentType.objects.get(app_label="blog", model="post")
    # auth_permission_15.codename = u'delete_post'
    # auth_permission_15 = importer.save_or_locate(auth_permission_15)

    # auth_permission_16 = Permission()
    # auth_permission_16.name = u'Can add content type'
    # auth_permission_16.content_type = ContentType.objects.get(app_label="contenttypes", model="contenttype")
    # auth_permission_16.codename = u'add_contenttype'
    # auth_permission_16 = importer.save_or_locate(auth_permission_16)

    # auth_permission_17 = Permission()
    # auth_permission_17.name = u'Can change content type'
    # auth_permission_17.content_type = ContentType.objects.get(app_label="contenttypes", model="contenttype")
    # auth_permission_17.codename = u'change_contenttype'
    # auth_permission_17 = importer.save_or_locate(auth_permission_17)

    # auth_permission_18 = Permission()
    # auth_permission_18.name = u'Can delete content type'
    # auth_permission_18.content_type = ContentType.objects.get(app_label="contenttypes", model="contenttype")
    # auth_permission_18.codename = u'delete_contenttype'
    # auth_permission_18 = importer.save_or_locate(auth_permission_18)

    # auth_permission_19 = Permission()
    # auth_permission_19.name = u'Can add registration profile'
    # auth_permission_19.content_type = ContentType.objects.get(app_label="registration", model="registrationprofile")
    # auth_permission_19.codename = u'add_registrationprofile'
    # auth_permission_19 = importer.save_or_locate(auth_permission_19)

    # auth_permission_20 = Permission()
    # auth_permission_20.name = u'Can change registration profile'
    # auth_permission_20.content_type = ContentType.objects.get(app_label="registration", model="registrationprofile")
    # auth_permission_20.codename = u'change_registrationprofile'
    # auth_permission_20 = importer.save_or_locate(auth_permission_20)

    # auth_permission_21 = Permission()
    # auth_permission_21.name = u'Can delete registration profile'
    # auth_permission_21.content_type = ContentType.objects.get(app_label="registration", model="registrationprofile")
    # auth_permission_21.codename = u'delete_registrationprofile'
    # auth_permission_21 = importer.save_or_locate(auth_permission_21)

    # auth_permission_22 = Permission()
    # auth_permission_22.name = u'Can add supervised registration profile'
    # auth_permission_22.content_type = ContentType.objects.get(app_label="registration", model="supervisedregistrationprofile")
    # auth_permission_22.codename = u'add_supervisedregistrationprofile'
    # auth_permission_22 = importer.save_or_locate(auth_permission_22)

    # auth_permission_23 = Permission()
    # auth_permission_23.name = u'Can change supervised registration profile'
    # auth_permission_23.content_type = ContentType.objects.get(app_label="registration", model="supervisedregistrationprofile")
    # auth_permission_23.codename = u'change_supervisedregistrationprofile'
    # auth_permission_23 = importer.save_or_locate(auth_permission_23)

    # auth_permission_24 = Permission()
    # auth_permission_24.name = u'Can delete supervised registration profile'
    # auth_permission_24.content_type = ContentType.objects.get(app_label="registration", model="supervisedregistrationprofile")
    # auth_permission_24.codename = u'delete_supervisedregistrationprofile'
    # auth_permission_24 = importer.save_or_locate(auth_permission_24)

    # auth_permission_25 = Permission()
    # auth_permission_25.name = u'Can add session'
    # auth_permission_25.content_type = ContentType.objects.get(app_label="sessions", model="session")
    # auth_permission_25.codename = u'add_session'
    # auth_permission_25 = importer.save_or_locate(auth_permission_25)

    # auth_permission_26 = Permission()
    # auth_permission_26.name = u'Can change session'
    # auth_permission_26.content_type = ContentType.objects.get(app_label="sessions", model="session")
    # auth_permission_26.codename = u'change_session'
    # auth_permission_26 = importer.save_or_locate(auth_permission_26)

    # auth_permission_27 = Permission()
    # auth_permission_27.name = u'Can delete session'
    # auth_permission_27.content_type = ContentType.objects.get(app_label="sessions", model="session")
    # auth_permission_27.codename = u'delete_session'
    # auth_permission_27 = importer.save_or_locate(auth_permission_27)

    # auth_permission_28 = Permission()
    # auth_permission_28.name = u'Can add article'
    # auth_permission_28.content_type = ContentType.objects.get(app_label="test_app", model="article")
    # auth_permission_28.codename = u'add_article'
    # auth_permission_28 = importer.save_or_locate(auth_permission_28)

    # auth_permission_29 = Permission()
    # auth_permission_29.name = u'Can change article'
    # auth_permission_29.content_type = ContentType.objects.get(app_label="test_app", model="article")
    # auth_permission_29.codename = u'change_article'
    # auth_permission_29 = importer.save_or_locate(auth_permission_29)

    # auth_permission_30 = Permission()
    # auth_permission_30.name = u'Can delete article'
    # auth_permission_30.content_type = ContentType.objects.get(app_label="test_app", model="article")
    # auth_permission_30.codename = u'delete_article'
    # auth_permission_30 = importer.save_or_locate(auth_permission_30)

    # auth_permission_31 = Permission()
    # auth_permission_31.name = u'Can add articles'
    # auth_permission_31.content_type = ContentType.objects.get(app_label="test_app", model="articles")
    # auth_permission_31.codename = u'add_articles'
    # auth_permission_31 = importer.save_or_locate(auth_permission_31)

    # auth_permission_32 = Permission()
    # auth_permission_32.name = u'Can change articles'
    # auth_permission_32.content_type = ContentType.objects.get(app_label="test_app", model="articles")
    # auth_permission_32.codename = u'change_articles'
    # auth_permission_32 = importer.save_or_locate(auth_permission_32)

    # auth_permission_33 = Permission()
    # auth_permission_33.name = u'Can delete articles'
    # auth_permission_33.content_type = ContentType.objects.get(app_label="test_app", model="articles")
    # auth_permission_33.codename = u'delete_articles'
    # auth_permission_33 = importer.save_or_locate(auth_permission_33)

    # auth_permission_34 = Permission()
    # auth_permission_34.name = u'Can add group'
    # auth_permission_34.content_type = ContentType.objects.get(app_label="test_app", model="group")
    # auth_permission_34.codename = u'add_group'
    # auth_permission_34 = importer.save_or_locate(auth_permission_34)

    # auth_permission_35 = Permission()
    # auth_permission_35.name = u'Can change group'
    # auth_permission_35.content_type = ContentType.objects.get(app_label="test_app", model="group")
    # auth_permission_35.codename = u'change_group'
    # auth_permission_35 = importer.save_or_locate(auth_permission_35)

    # auth_permission_36 = Permission()
    # auth_permission_36.name = u'Can delete group'
    # auth_permission_36.content_type = ContentType.objects.get(app_label="test_app", model="group")
    # auth_permission_36.codename = u'delete_group'
    # auth_permission_36 = importer.save_or_locate(auth_permission_36)

    # auth_permission_37 = Permission()
    # auth_permission_37.name = u'Can add membership'
    # auth_permission_37.content_type = ContentType.objects.get(app_label="test_app", model="membership")
    # auth_permission_37.codename = u'add_membership'
    # auth_permission_37 = importer.save_or_locate(auth_permission_37)

    # auth_permission_38 = Permission()
    # auth_permission_38.name = u'Can change membership'
    # auth_permission_38.content_type = ContentType.objects.get(app_label="test_app", model="membership")
    # auth_permission_38.codename = u'change_membership'
    # auth_permission_38 = importer.save_or_locate(auth_permission_38)

    # auth_permission_39 = Permission()
    # auth_permission_39.name = u'Can delete membership'
    # auth_permission_39.content_type = ContentType.objects.get(app_label="test_app", model="membership")
    # auth_permission_39.codename = u'delete_membership'
    # auth_permission_39 = importer.save_or_locate(auth_permission_39)

    # auth_permission_40 = Permission()
    # auth_permission_40.name = u'Can add person'
    # auth_permission_40.content_type = ContentType.objects.get(app_label="test_app", model="person")
    # auth_permission_40.codename = u'add_person'
    # auth_permission_40 = importer.save_or_locate(auth_permission_40)

    # auth_permission_41 = Permission()
    # auth_permission_41.name = u'Can change person'
    # auth_permission_41.content_type = ContentType.objects.get(app_label="test_app", model="person")
    # auth_permission_41.codename = u'change_person'
    # auth_permission_41 = importer.save_or_locate(auth_permission_41)

    # auth_permission_42 = Permission()
    # auth_permission_42.name = u'Can delete person'
    # auth_permission_42.content_type = ContentType.objects.get(app_label="test_app", model="person")
    # auth_permission_42.codename = u'delete_person'
    # auth_permission_42 = importer.save_or_locate(auth_permission_42)

    # auth_permission_43 = Permission()
    # auth_permission_43.name = u'Can add place'
    # auth_permission_43.content_type = ContentType.objects.get(app_label="test_app", model="place")
    # auth_permission_43.codename = u'add_place'
    # auth_permission_43 = importer.save_or_locate(auth_permission_43)

    # auth_permission_44 = Permission()
    # auth_permission_44.name = u'Can change place'
    # auth_permission_44.content_type = ContentType.objects.get(app_label="test_app", model="place")
    # auth_permission_44.codename = u'change_place'
    # auth_permission_44 = importer.save_or_locate(auth_permission_44)

    # auth_permission_45 = Permission()
    # auth_permission_45.name = u'Can delete place'
    # auth_permission_45.content_type = ContentType.objects.get(app_label="test_app", model="place")
    # auth_permission_45.codename = u'delete_place'
    # auth_permission_45 = importer.save_or_locate(auth_permission_45)

    # auth_permission_46 = Permission()
    # auth_permission_46.name = u'Can add publication'
    # auth_permission_46.content_type = ContentType.objects.get(app_label="test_app", model="publication")
    # auth_permission_46.codename = u'add_publication'
    # auth_permission_46 = importer.save_or_locate(auth_permission_46)

    # auth_permission_47 = Permission()
    # auth_permission_47.name = u'Can change publication'
    # auth_permission_47.content_type = ContentType.objects.get(app_label="test_app", model="publication")
    # auth_permission_47.codename = u'change_publication'
    # auth_permission_47 = importer.save_or_locate(auth_permission_47)

    # auth_permission_48 = Permission()
    # auth_permission_48.name = u'Can delete publication'
    # auth_permission_48.content_type = ContentType.objects.get(app_label="test_app", model="publication")
    # auth_permission_48.codename = u'delete_publication'
    # auth_permission_48 = importer.save_or_locate(auth_permission_48)

    # auth_permission_49 = Permission()
    # auth_permission_49.name = u'Can add reporter'
    # auth_permission_49.content_type = ContentType.objects.get(app_label="test_app", model="reporter")
    # auth_permission_49.codename = u'add_reporter'
    # auth_permission_49 = importer.save_or_locate(auth_permission_49)

    # auth_permission_50 = Permission()
    # auth_permission_50.name = u'Can change reporter'
    # auth_permission_50.content_type = ContentType.objects.get(app_label="test_app", model="reporter")
    # auth_permission_50.codename = u'change_reporter'
    # auth_permission_50 = importer.save_or_locate(auth_permission_50)

    # auth_permission_51 = Permission()
    # auth_permission_51.name = u'Can delete reporter'
    # auth_permission_51.content_type = ContentType.objects.get(app_label="test_app", model="reporter")
    # auth_permission_51.codename = u'delete_reporter'
    # auth_permission_51 = importer.save_or_locate(auth_permission_51)

    # auth_permission_52 = Permission()
    # auth_permission_52.name = u'Can add restaurant'
    # auth_permission_52.content_type = ContentType.objects.get(app_label="test_app", model="restaurant")
    # auth_permission_52.codename = u'add_restaurant'
    # auth_permission_52 = importer.save_or_locate(auth_permission_52)

    # auth_permission_53 = Permission()
    # auth_permission_53.name = u'Can change restaurant'
    # auth_permission_53.content_type = ContentType.objects.get(app_label="test_app", model="restaurant")
    # auth_permission_53.codename = u'change_restaurant'
    # auth_permission_53 = importer.save_or_locate(auth_permission_53)

    # auth_permission_54 = Permission()
    # auth_permission_54.name = u'Can delete restaurant'
    # auth_permission_54.content_type = ContentType.objects.get(app_label="test_app", model="restaurant")
    # auth_permission_54.codename = u'delete_restaurant'
    # auth_permission_54 = importer.save_or_locate(auth_permission_54)

    # auth_permission_55 = Permission()
    # auth_permission_55.name = u'Can add waiter'
    # auth_permission_55.content_type = ContentType.objects.get(app_label="test_app", model="waiter")
    # auth_permission_55.codename = u'add_waiter'
    # auth_permission_55 = importer.save_or_locate(auth_permission_55)

    # auth_permission_56 = Permission()
    # auth_permission_56.name = u'Can change waiter'
    # auth_permission_56.content_type = ContentType.objects.get(app_label="test_app", model="waiter")
    # auth_permission_56.codename = u'change_waiter'
    # auth_permission_56 = importer.save_or_locate(auth_permission_56)

    # auth_permission_57 = Permission()
    # auth_permission_57.name = u'Can delete waiter'
    # auth_permission_57.content_type = ContentType.objects.get(app_label="test_app", model="waiter")
    # auth_permission_57.codename = u'delete_waiter'
    # auth_permission_57 = importer.save_or_locate(auth_permission_57)

    # Processing model: django.contrib.auth.models.Group

    from django.contrib.auth.models import Group

    # Processing model: django.contrib.auth.models.User

    from django.contrib.auth.models import User

    # auth_user_1 = User()
    # auth_user_1.password = u'pbkdf2_sha256$20000$XrOrz28Gh0GP$Tg/d6pT86wBOzJOF33Nh6EXuiGTbSIW/XK7dlHw4gpI='
    # auth_user_1.last_login = dateutil.parser.parse("2017-08-08T01:47:22.848098+00:00")
    # auth_user_1.is_superuser = True
    # auth_user_1.username = u'admin'
    # auth_user_1.first_name = u''
    # auth_user_1.last_name = u''
    # auth_user_1.email = u'*****@*****.**'
    # auth_user_1.is_staff = True
    # auth_user_1.is_active = True
    # auth_user_1.date_joined = dateutil.parser.parse("2017-07-13T02:03:07.418558+00:00")
    # auth_user_1 = importer.save_or_locate(auth_user_1)

    auth_user_2 = User()
    auth_user_2.password = u'pbkdf2_sha256$20000$SElIUk5eGT9u$eFK6Zksu6eqjL3y3TwlwQTl3HkK94+S2QGz0op9XHXE='
    auth_user_2.last_login = dateutil.parser.parse(
        "2017-08-07T02:05:12.883850+00:00")
    auth_user_2.is_superuser = True
    auth_user_2.username = u'arjouth'
    auth_user_2.first_name = u''
    auth_user_2.last_name = u''
    auth_user_2.email = u''
    auth_user_2.is_staff = True
    auth_user_2.is_active = True
    auth_user_2.date_joined = dateutil.parser.parse(
        "2017-07-18T01:57:17+00:00")
    auth_user_2 = importer.save_or_locate(auth_user_2)

    auth_user_3 = User()
    auth_user_3.password = u'pbkdf2_sha256$20000$4zyBBcbOdEoq$Yjwou5b5dT/QvG1yzfph9+Lf9Y8dJsPWcq0PAofW/iI='
    auth_user_3.last_login = None
    auth_user_3.is_superuser = True
    auth_user_3.username = u'deepthi'
    auth_user_3.first_name = u''
    auth_user_3.last_name = u''
    auth_user_3.email = u'*****@*****.**'
    auth_user_3.is_staff = True
    auth_user_3.is_active = True
    auth_user_3.date_joined = dateutil.parser.parse(
        "2017-07-18T02:33:32+00:00")
    auth_user_3 = importer.save_or_locate(auth_user_3)

    auth_user_4 = User()
    auth_user_4.password = u'pbkdf2_sha256$20000$BY1tDskzSfBt$UzwjG+pDjxW03WzTdGXv4KRpKdxYi0vrFvhttY4tDHI='
    auth_user_4.last_login = None
    auth_user_4.is_superuser = False
    auth_user_4.username = u'manpreeth'
    auth_user_4.first_name = u''
    auth_user_4.last_name = u''
    auth_user_4.email = u''
    auth_user_4.is_staff = False
    auth_user_4.is_active = True
    auth_user_4.date_joined = dateutil.parser.parse(
        "2017-07-19T01:53:00.269986+00:00")
    auth_user_4 = importer.save_or_locate(auth_user_4)

    auth_user_5 = User()
    auth_user_5.password = u'pbkdf2_sha256$20000$LRs1kcRyw7T2$khqfkfKwFoY13dmmAQAIqz89Tjl5VZYLgJm1v/J7CWg='
    auth_user_5.last_login = None
    auth_user_5.is_superuser = False
    auth_user_5.username = u'naresh'
    auth_user_5.first_name = u''
    auth_user_5.last_name = u''
    auth_user_5.email = u''
    auth_user_5.is_staff = False
    auth_user_5.is_active = True
    auth_user_5.date_joined = dateutil.parser.parse(
        "2017-07-19T01:53:23.563210+00:00")
    auth_user_5 = importer.save_or_locate(auth_user_5)

    auth_user_6 = User()
    auth_user_6.password = u'pbkdf2_sha256$20000$mjfxeOfEMpeb$sbCx1Of2+HkX6k5LBB3aHyv3BfFkI/OhUQR2pLKFQWs='
    auth_user_6.last_login = None
    auth_user_6.is_superuser = False
    auth_user_6.username = u'sivaram'
    auth_user_6.first_name = u''
    auth_user_6.last_name = u''
    auth_user_6.email = u''
    auth_user_6.is_staff = False
    auth_user_6.is_active = True
    auth_user_6.date_joined = dateutil.parser.parse(
        "2017-07-19T02:02:19+00:00")
    auth_user_6 = importer.save_or_locate(auth_user_6)

    auth_user_7 = User()
    auth_user_7.password = u'pbkdf2_sha256$20000$Gggh2BsdVNf4$R/FLei9D3H7kdLeysBO5HQ/6CwXv7d/zyg86j+6HPIY='
    auth_user_7.last_login = None
    auth_user_7.is_superuser = True
    auth_user_7.username = u'govardhan'
    auth_user_7.first_name = u''
    auth_user_7.last_name = u''
    auth_user_7.email = u''
    auth_user_7.is_staff = False
    auth_user_7.is_active = True
    auth_user_7.date_joined = dateutil.parser.parse(
        "2017-07-25T02:18:16+00:00")
    auth_user_7 = importer.save_or_locate(auth_user_7)

    auth_user_8 = User()
    auth_user_8.password = u'pbkdf2_sha256$20000$Ks2x3Utlvvci$i0VY89tKZmVMynfxk/hFwNVqyTORWoRjFtEnvjTsN8o='
    auth_user_8.last_login = None
    auth_user_8.is_superuser = False
    auth_user_8.username = u'ramanji'
    auth_user_8.first_name = u''
    auth_user_8.last_name = u''
    auth_user_8.email = u''
    auth_user_8.is_staff = False
    auth_user_8.is_active = True
    auth_user_8.date_joined = dateutil.parser.parse(
        "2017-07-28T02:10:34.721453+00:00")
    auth_user_8 = importer.save_or_locate(auth_user_8)

    auth_user_9 = User()
    auth_user_9.password = u'pbkdf2_sha256$20000$kWNufiqcbDsF$ksnpz6m5jPTrsO9+vle6+tlm1GVcXArkYWx9RbNb38A='
    auth_user_9.last_login = dateutil.parser.parse(
        "2017-08-03T02:39:47.269684+00:00")
    auth_user_9.is_superuser = False
    auth_user_9.username = u'kumar'
    auth_user_9.first_name = u''
    auth_user_9.last_name = u''
    auth_user_9.email = u'*****@*****.**'
    auth_user_9.is_staff = False
    auth_user_9.is_active = True
    auth_user_9.date_joined = dateutil.parser.parse(
        "2017-08-03T02:30:53.902518+00:00")
    auth_user_9 = importer.save_or_locate(auth_user_9)
Example #55
0
def add_directory_member(request):
    perm = general_methods.control_access(request)

    if not perm:
        logout(request)
        return redirect('accounts:login')
    user_form = UserForm()
    person_form = PersonForm()
    communication_form = CommunicationForm()
    member_form = DirectoryForm()

    if request.method == 'POST':

        user_form = UserForm(request.POST)
        person_form = PersonForm(request.POST, request.FILES)
        communication_form = CommunicationForm(request.POST)
        member_form = DirectoryForm(request.POST)

        # controller tc email

        mail = request.POST.get('email')
        if User.objects.filter(email=mail) or ReferenceCoach.objects.exclude(
                status=ReferenceCoach.DENIED).filter(
                    email=mail) or ReferenceReferee.objects.exclude(
                        status=ReferenceReferee.DENIED).filter(
                            email=mail) or PreRegistration.objects.exclude(
                                status=PreRegistration.DENIED).filter(
                                    email=mail):
            messages.warning(
                request,
                'Mail adresi başka bir kullanici tarafından kullanilmaktadir.')
            return render(
                request, 'yonetim/kurul-uyesi-ekle.html', {
                    'user_form': user_form,
                    'person_form': person_form,
                    'communication_form': communication_form,
                    'member_form': member_form
                })

        tc = request.POST.get('tc')
        if Person.objects.filter(tc=tc) or ReferenceCoach.objects.exclude(
                status=ReferenceCoach.DENIED).filter(
                    tc=tc) or ReferenceReferee.objects.exclude(
                        status=ReferenceReferee.DENIED).filter(
                            tc=tc) or PreRegistration.objects.exclude(
                                status=PreRegistration.DENIED).filter(tc=tc):
            messages.warning(request,
                             'Tc kimlik numarasi sistemde kayıtlıdır. ')
            return render(
                request, 'yonetim/kurul-uyesi-ekle.html', {
                    'user_form': user_form,
                    'person_form': person_form,
                    'communication_form': communication_form,
                    'member_form': member_form
                })

        name = request.POST.get('first_name')
        surname = request.POST.get('last_name')
        year = request.POST.get('birthDate')
        year = year.split('/')

        client = Client(
            'https://tckimlik.nvi.gov.tr/Service/KPSPublic.asmx?WSDL')
        if not (client.service.TCKimlikNoDogrula(tc, name, surname, year[2])):
            messages.warning(
                request,
                'Tc kimlik numarasi ile isim  soyisim dogum yılı  bilgileri uyuşmamaktadır. '
            )
            return render(
                request, 'yonetim/kurul-uyesi-ekle.html', {
                    'user_form': user_form,
                    'person_form': person_form,
                    'communication_form': communication_form,
                    'member_form': member_form
                })

        if user_form.is_valid() and person_form.is_valid(
        ) and communication_form.is_valid() and member_form.is_valid():
            user = User()
            user.username = user_form.cleaned_data['email']
            user.first_name = user_form.cleaned_data['first_name']
            user.last_name = user_form.cleaned_data['last_name']
            user.email = user_form.cleaned_data['email']
            group = Group.objects.get(name='Yonetim')
            password = User.objects.make_random_password()
            user.set_password(password)
            user.save()
            user.groups.add(group)
            user.save()

            person = person_form.save(commit=False)
            communication = communication_form.save(commit=False)
            person.save()
            communication.save()

            directoryMember = DirectoryMember(user=user,
                                              person=person,
                                              communication=communication)
            directoryMember.role = member_form.cleaned_data['role']
            directoryMember.commission = member_form.cleaned_data['commission']

            directoryMember.save()

            # subject, from_email, to = 'Halter - Yönetim/Federasyon Bilgi Sistemi Kullanıcı Giriş Bilgileri', '*****@*****.**', user.email
            # text_content = 'Aşağıda ki bilgileri kullanarak sisteme giriş yapabilirsiniz.'
            # html_content = '<p> <strong>Site adresi: </strong> <a href="http://sbs.twf.gov.tr:81/"></a>sbs.twf.gov.tr:81</p>'
            # html_content = html_content + '<p><strong>Kullanıcı Adı:  </strong>' + user.username + '</p>'
            # html_content = html_content + '<p><strong>Şifre: </strong>' + password + '</p>'
            # msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
            # msg.attach_alternative(html_content, "text/html")
            # msg.send()

            log = str(user.get_full_name()) + " Kurul Uyesi kaydedildi"
            log = general_methods.logwrite(request, request.user, log)

            messages.success(request,
                             'Kurul Üyesi Başarıyla Kayıt Edilmiştir.')

            return redirect('sbs:kurul-uyeleri')

        else:

            for x in user_form.errors.as_data():
                messages.warning(request, user_form.errors[x][0])

    return render(
        request, 'yonetim/kurul-uyesi-ekle.html', {
            'user_form': user_form,
            'person_form': person_form,
            'communication_form': communication_form,
            'member_form': member_form
        })
Example #56
0
    def authenticate(self, twitter_access_token, user=None):
        '''
            authenticates the token by requesting user information
            from twitter
        '''
        # twitter = oauthtwitter.OAuthApi(TWITTER_CONSUMER_KEY,
        #                                  TWITTER_CONSUMER_SECRET,
        #                                  twitter_access_token)
        twitter = oauthtwitter.TwitterOAuthClient(
            settings.TWITTER_CONSUMER_KEY, settings.TWITTER_CONSUMER_SECRET)
        try:
            userinfo = twitter.get_user_info(twitter_access_token)
        except:
            # If we cannot get the user information,
            # user cannot be authenticated
            raise

        screen_name = userinfo.screen_name
        twitter_id = userinfo.id

        try:
            user_profile = (TwitterUserProfile.objects.get(
                screen_name=screen_name))

            # Update Twitter Profile
            user_profile.url = userinfo.url
            user_profile.location = userinfo.location
            user_profile.description = userinfo.description
            user_profile.profile_image_url = userinfo.profile_image_url
            user_profile.save()

            user = user_profile.user
            return user
        except TwitterUserProfile.DoesNotExist:
            # Create new user
            if not user:
                same_name_count = (User.objects.filter(
                    username__startswith=screen_name).count())
                if same_name_count:
                    username = '******' % (screen_name, same_name_count + 1)
                else:
                    username = screen_name
                user = User(username=username)
                name_data = userinfo.name.split()
                try:
                    first_name, last_name = (name_data[0],
                                             ' '.join(name_data[1:]))
                except:
                    first_name, last_name = screen_name, ''
                user.first_name, user.last_name = first_name, last_name
                #user.email = screen_name + "@socialauth"
                #user.email = '*****@*****.**'%(userinfo.screen_name)
                user.save()

            user_profile = TwitterUserProfile(user=user,
                                              screen_name=screen_name)
            user_profile.access_token = str(twitter_access_token)
            user_profile.url = userinfo.url
            user_profile.location = userinfo.location
            user_profile.description = userinfo.description
            user_profile.profile_image_url = userinfo.profile_image_url
            user_profile.save()

            auth_meta = AuthMeta(user=user, provider='Twitter').save()

            return user
Example #57
0
    def authenticate(self, username=None, password=None):
        user = None
        # ensure that username does not contains or contains only one '@'
        if username.count('@') > 1:
            return user

        # enforce_realm is set and username is not valid
        if self.enforce_realm and username.count('@') != 1:
            return user

        # realm is set and realm provided in username is not equals realm
        if self.realm and self.enforce_realm and self.realm != username.split(
                '@')[1]:
            return user

        # realm is set and username contains '@'
        if self.realm and '@' in username:
            # realm provided in username is not equals realm
            if self.realm != username.split('@')[1]:
                return user
            username = username.split('@')[0]

        try:
            r = requests.post(self.url,
                              verify=self.ssl_verify,
                              timeout=self.timeout,
                              data={
                                  'user': username,
                                  'pass': password,
                                  'realm': self.realm
                              })
            logger.debug("privacyidea %s get status_code %i" %
                         (self.url, r.status_code))
            if r.status_code == requests.codes.ok:
                response = r.json()
                logger.debug("privacyidea %s get response %s" %
                             (self.url, response))

                if (response.get('result', {}).get('status') == True
                        and (response.get('result', {}).get('value') == True
                             or response.get('result', {}).get(
                                 'value', {}).get('auth') == True)):
                    if self.realm and self.enforce_realm:
                        username += '@' + self.realm

                    user = User.objects.filter(username=username)
                    if len(user) == 0:
                        # The user was authenticated by PrivacyIDEA but does not exist!
                        logger.debug("User authenticated but does not exist")
                        if self.create_user:
                            # Create a new user. There's no need to set a password
                            user = User(username=username)
                            user.is_staff = False
                            user.is_superuser = False
                            user.save()
                        else:
                            return None
                    else:
                        user = user[0]

                    if self.update_attributes:
                        attributes = response.get('result', {}).get(
                            'value', {}).get('attributes', {})
                        surname = attributes.get('surname', None)
                        givenname = attributes.get('givenname', None)
                        email = attributes.get('email', None)
                        user.first_name = givenname
                        user.last_name = surname
                        user.email = email
                        user.save()

        except Exception as e:
            logger.exception("An error occurred: %s" % e)

        return user
Example #58
0
    except FacebookProfile.DoesNotExist, e:
        # not in the db, ok to continue
        pass

    #user submitted a form - which one?
    if request.method == "POST":
        log.debug('Submitted form')
        #lets setup a facebook only account. The user will have to use
        #facebook to login.
        if request.POST.get('facebook_only',False):
            log.debug('Facebook Only')
            profile = FacebookProfile(facebook_id=request.facebook.uid)
            user = User(username=request.facebook.uid,
                        email=profile.email)
            user.set_unusable_password()
            user.first_name = profile.first_name
            user.last_name = profile.last_name
            user.save()

            new_user_extra = UserProfile( user       = user
                                        , is_special = False
                                        , is_anon    = False
                                        , challenges = 0
                                        , challenges_answered = 0
                                        , supporters = 0
                                        )
            new_user_extra.save()


            profile.user = user
            profile.save()
Example #59
0
def RegistrationView(request):

    if request.method == "POST":
        request.session
        #test
        print("WAS POST")
        form = RegistrationForm(request.POST)

        if form.is_valid():
            First_Name = request.POST.get('First_Name')
            Last_Name = request.POST.get('Last_Name')
            Username = request.POST.get('Username')
            Email = request.POST.get('Email', ' ')
            HomeAddress = request.POST.get('Address', ' ')
            City = request.POST.get('City', ' ')
            Zip_Code = request.POST.get('Zip_Code', ' ')
            psw = request.POST.get('psw')

            #Store Address
            print("creating Address...")
            HomeAddr = USER_HOME_ADDRESS()
            Addr = ADDRESS()
            Addr.Zip_Post = Zip_Code
            Addr.Address_1 = ""  #fill this in later when user can fill this in a seperate form
            Addr.Address_2 = ""  #fill this in later when user can fill this in a seperate form
            Addr.Country = ""  #fill this in later when user can fill this in a seperate form
            Addr.State = ""  #fill this in later when user can fill this in a seperate form
            Addr.City_Town = City
            Addr.Name = ""  #fill this in later when user can fill this in a seperate form

            print("saving address...")
            Addr.save()
            HomeAddr.Address_ID = Addr
            HomeAddr.save()

            #Store AuthUser
            print("creating AuthUser")
            AuthUser_ID = AuthUser()
            AuthUser_ID.first_name = First_Name
            AuthUser_ID.last_name = Last_Name
            AuthUser_ID.email = Email
            AuthUser_ID.set_password(psw)
            AuthUser_ID.username = Username
            print("saving AuthUser...")
            AuthUser_ID.save(
            )  #if error occurs later on, username will still be saved in db! fix later

            print("creating USER...")
            #Store USER
            user_obj = USER()
            user_obj.AuthUser_ID = AuthUser_ID
            user_obj.Home_address_ID
            user_obj.Preferred_credit_card_ID = None

            cart = CART(Cart_ID=utility.generate_Cart_ID())  #for now!
            cart.save()  #for now!
            user_obj.Cart_ID = cart  #for now!

            user_obj.Nick_name = ''
            print("Saving user_obj....")
            user_obj.save()

            print("Sucess!:)")

            return HttpResponseRedirect(reverse('homepage:index'))
        else:
            #test
            print("Form was invalid!!!")
            print(form.errors)
    else:
        #test
        print("NOT POST")
        form = RegistrationForm()

    #return render (request, 'register.html', {'form': form,})
    return render(request, 'prof/register.html', {
        'form': form,
    })
Example #60
0
def newlogin(request, pk):
    clup = SportsClub.objects.get(pk=pk)
    # clüp
    club_form = ClubForm(instance=clup)
    communication_formclup = CommunicationForm(instance=clup.communication)
    # klüp üyesi
    user_form = UserForm()
    person_form = PersonForm()
    communication_form = CommunicationForm()
    sportClubUser_form = SportClubUserForm()

    if request.method == 'POST':
        user_form = UserForm(request.POST)
        person_form = PersonForm(request.POST, request.FILES)
        communication_form = CommunicationForm(request.POST, request.FILES)
        sportClubUser_form = SportClubUserForm(request.POST)

        club_form = ClubForm(request.POST, request.FILES)
        communication_formclup = CommunicationForm(request.POST, request.FILES)

        if club_form.is_valid() and user_form.is_valid(
        ) and person_form.is_valid() and communication_form.is_valid(
        ) and sportClubUser_form.is_valid():

            tc = request.POST.get('tc')

            if Coach.objects.get(person__tc=tc):
                # print("Bu degerde elimde tc si olan bir antrenör var ")
                coach = Coach.objects.get(person__tc=tc)
                user = coach.user

                club_person = SportClubUser(
                    user=coach.user,
                    person=coach.person,
                    communication=coach.communication,
                    role=sportClubUser_form.cleaned_data['role'])
                club_person.save()

                group = Group.objects.get(name='KulupUye')
                coach.user.groups.add(group)
                coach.save()

                communication = communication_formclup.save(commit=False)
                communication.save()
                clup.communication = communication
                clup.coachs.add(coach)
                clup.save()
                messages.success(
                    request,
                    'Antrenör şifreniz ile sisteme giriş yapabilirsiniz')
                log = general_methods.logwrite(
                    request, user,
                    "Antrenör klup üyesi olarak giris yaptı new login ")

            else:

                mail = request.POST.get('email')
                if User.objects.filter(
                        email=mail) or ReferenceCoach.objects.filter(
                            email=mail) or ReferenceReferee.objects.filter(
                                email=mail) or PreRegistration.objects.filter(
                                    email=mail):
                    messages.warning(
                        request,
                        'Mail adresi başka bir kullanici tarafından kullanilmaktadir.'
                    )
                    return render(
                        request, 'registration/newlogin.html', {
                            'user_form': user_form,
                            'person_form': person_form,
                            'communication_form': communication_form,
                            'sportClubUser_form': sportClubUser_form,
                            'club_form': club_form,
                            'communication_formclup': communication_formclup
                        })

                tc = request.POST.get('tc')
                if Person.objects.filter(
                        tc=tc) or ReferenceCoach.objects.filter(
                            tc=tc) or ReferenceReferee.objects.filter(
                                tc=tc) or PreRegistration.objects.filter(
                                    tc=tc):
                    messages.warning(
                        request, 'Tc kimlik numarasi sistemde kayıtlıdır. ')
                    return render(
                        request, 'registration/newlogin.html', {
                            'user_form': user_form,
                            'person_form': person_form,
                            'communication_form': communication_form,
                            'sportClubUser_form': sportClubUser_form,
                            'club_form': club_form,
                            'communication_formclup': communication_formclup
                        })

                name = request.POST.get('first_name')
                surname = request.POST.get('last_name')
                year = request.POST.get('birthDate')
                year = year.split('/')

                client = Client(
                    'https://tckimlik.nvi.gov.tr/Service/KPSPublic.asmx?WSDL')
                if not (client.service.TCKimlikNoDogrula(
                        tc, name, surname, year[2])):
                    messages.warning(
                        request,
                        'Tc kimlik numarasi ile isim  soyisim dogum yılı  bilgileri uyuşmamaktadır. '
                    )
                    return render(
                        request, 'registration/newlogin.html', {
                            'user_form': user_form,
                            'person_form': person_form,
                            'communication_form': communication_form,
                            'sportClubUser_form': sportClubUser_form,
                            'club_form': club_form,
                            'communication_formclup': communication_formclup
                        })

                clup.name = request.POST.get('name')
                clup.shortName = request.POST.get('shortName')
                clup.foundingDate = request.POST.get('foundingDate')
                clup.logo = request.POST.get('logo')
                clup.clubMail = request.POST.get('clubMail')
                clup.petition = request.POST.get('petition')
                clup.isFormal = request.POST.get('isFormal')
                user = User()
                user.username = user_form.cleaned_data['email']
                user.first_name = user_form.cleaned_data['first_name']
                user.last_name = user_form.cleaned_data['last_name']
                user.email = user_form.cleaned_data['email']
                group = Group.objects.get(name='KulupUye')
                user.save()
                user.groups.add(group)
                user.save()

                communication = communication_formclup.save(commit=False)
                communication.save()
                clup.communication = communication
                clup.save()

                person = person_form.save(commit=False)
                communication = communication_form.save(commit=False)
                person.save()
                communication.save()

                club_person = SportClubUser(
                    user=user,
                    person=person,
                    communication=communication,
                    role=sportClubUser_form.cleaned_data['role'],
                )

                club_person.save()
                fdk = Forgot(user=user, status=False)
                fdk.save()

                html_content = ''
                subject, from_email, to = 'TWF Bilgi Sistemi Kullanıcı Bilgileri', '*****@*****.**', user.email
                html_content = '<h2>TÜRKİYE HALTER FEDERASYONU BİLGİ SİSTEMİ</h2>'
                html_content = html_content + '<p><strong>Kullanıcı Adınız :' + str(
                    fdk.user.username) + '</strong></p>'
                # html_content = html_content + '<p> <strong>Site adresi:</strong> <a href="http://127.0.0.1:8000/newpassword?query=' + str(
                #     fdk.uuid) + '">http://127.0.0.1:8000/sbs/profil-guncelle/?query=' + str(fdk.uuid) + '</p></a>'
                html_content = html_content + '<p> <strong>Site adresi:</strong> <a href="https://sbs.halter.gov.tr:9443/newpassword?query=' + str(
                    fdk.uuid
                ) + '">https://sbs.halter.gov.tr:9443/sbs/profil-guncelle/?query=' + str(
                    fdk.uuid) + '</p></a>'

                msg = EmailMultiAlternatives(subject, '', from_email, [to])
                msg.attach_alternative(html_content, "text/html")
                msg.send()

                messages.success(
                    request,
                    'Mail adresinize gelen link ile sistemde giriş yapabilirsiniz.'
                )

            clup.clubUser.add(club_person)
            clup.dataAccessControl = False
            clup.isRegister = True

            clup.save()
            log = general_methods.logwrite(request, user,
                                           "Eski sifre ile giris yapildi")

            return redirect("accounts:login")

    return render(
        request, 'registration/newlogin.html', {
            'user_form': user_form,
            'person_form': person_form,
            'communication_form': communication_form,
            'sportClubUser_form': sportClubUser_form,
            'club_form': club_form,
            'communication_formclup': communication_formclup
        })