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
Beispiel #2
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
Beispiel #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)
Beispiel #4
0
    def test_normalusage(self):
        """
        Tests that ldaplib works correctly or not.
        """
        user=User()
        user.username="******"
        user.first_name="first"
        user.last_name="last"
        user.email="*****@*****.**"
        user.is_active=True
        ldaplib.save(user)

        ld=ldaplib.init_bind()
        result=ldaplib.search(user.username,ld)
        self.assertEqual(1,len(result))

        self.assertEqual(False,ldaplib.searchDenylist(user.username,ld))
        ld.unbind()

        password="******"
        ldaplib.changePassword(user,password)
        user.last_name="lastmod"
        user.email="*****@*****.**"
        ldaplib.save(user)
        user.is_active=False
        ldaplib.save(user)

        ld=ldaplib.init_bind()
        #result=ldaplib.search(user.username,ld)
        #print(result)
        self.assertEqual(True,ldaplib.searchDenylist(user.username,ld))
        ld.unbind()

        ldaplib.delete(user)
Beispiel #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()
Beispiel #6
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()
Beispiel #7
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')
Beispiel #8
0
def students():
	'''sets up students'''
	filepath=os.path.join(os.getcwd(),SETUP_SUPPORT_FOLDER,'student_photos','college_studentlist')
	if os.path.exists(os.path.join(filepath,'student_list_clean')):
		f=file(os.path.join(filepath,'student_list_clean'),'r')
		import pickle
		data=pickle.load(f)
		f.close()
		#default picture
		picpath=os.path.join(filepath,'default.jpg')
		f=file(picpath)
		#add students
		for course in data.keys():
			name=course.strip().strip('III')
			name=name.strip('II').strip('I').replace('YEAR','')
			name=name.replace('-SEC A','').replace('-SEC B','')
			crs=office.models.course.objects.get(name=name)
			for sem in data[course].keys():
				for stu in data[course][sem]:
					if 'Student Name' in stu:
						continue
					u=User()
					u.username=str(stu).lower().replace(' ','')
					u.first_name=str(stu.split(' ')[0]).lower()
					u.last_name=str(stu.split(' ')[-1]).lower()
					if u.last_name==u.first_name:
						u.last_name=''
					u.set_password('asd')
					try:
						u.save()	
					except Exception as e:
						print '----------'
						print e
						print '----------'
						print u.username
						uname=random.sample(u.username,len(u.username))
						u.username=''.join(uname)
						print u.username
						u.save()
						print '----------'
					a=office.models.student()
					a.user=u
					a.picture=File(f)
					a.nickname=random_fill(stu.replace(' ',''),10)
					#a.course=office.models.course.objects.first()
					a.course=crs
					a.current_semester=(2*sem)-1
					a.save()
		f.close()#close picture file
	
	else:
		import student_scraper as stsc
		stsc.scrape()
		students()
Beispiel #9
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
Beispiel #10
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")
Beispiel #11
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)
Beispiel #12
0
def signup(request):
	context = {}
	context['title'] = _('Register')
	user = User()
	if request.user.is_authenticated():
		return redirect('accounts_accounts')
	userProfile = UserProfile()
	if request.method == 'POST':
		userForm = UserForm(request.POST, instance=user)
		userProfileForm = UserProfileForm(request.POST, instance=userProfile)
		if userForm.is_valid() and userProfileForm.is_valid():
			userData = userForm.cleaned_data
			user.username = userData['username']
			user.first_name = userData['first_name']
			user.last_name = userData['last_name']
			user.email = userData['email']
			user.set_password(userData['password'])
			user.save()

			userProfile = user.get_profile()
			userProfileData = userProfileForm.cleaned_data
			userProfile.gender = userProfileData['gender']
			userProfile.birthday = userProfileData['birthday']
			userProfile.save()

			user = authenticate(username=userData['username'], password=userData['password'])
			login(request, user)
			return redirect('accounts_accounts')
	else:
		userForm = UserForm(instance=user)
		userProfileForm = UserProfileForm(instance=userProfile)
	context['userForm'] = userForm
	context['userProfileForm'] = userProfileForm
	return render_to_response('accounts/register.html', context, context_instance=RequestContext(request))
Beispiel #13
0
def add_user(request):
    if not request.user.has_perm("auth.add_user"):
        return HttpResponseForbidden("You do not have permission to maintain users")
    if request.method == "POST":
        form = AddUserForm(request.POST)
        if request.POST.get("cancel"):
            return redirect("maintain_users")
        if form.is_valid():
            data = form.cleaned_data
            user = User()
            user.username = data["username"]
            user.first_name = data["first_name"]
            user.last_name = data["last_name"]
            user.email = data["email"]
            user.is_active = bool(data.get("is_active"))
            if data["mode_password"] == EditUserForm.PASSWD_MANUAL_RESET:
                user.set_password(data["password1"])
            user.save()
            for grp in data["groups"]:
                user.groups.add(grp)
            return redirect("maintain_users")
    else:
        form = AddUserForm()
    return render(request, "users/add_user.html", {
            'form': form,
            })
Beispiel #14
0
def create_user():
    user = User()
    user.first_name = 'Ciccio'
    user.last_name = 'Panda'
    user.username = '******'
    user.password = make_password('ciccio')
    return user
Beispiel #15
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,
    })
Beispiel #16
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))
    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()
Beispiel #18
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
Beispiel #19
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
Beispiel #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
Beispiel #21
0
def register_service(user_info, unique_id=None, access_token=None, impersonate=None):
    # FIXME: massive race condition potential here
    unique_id = unique_id or user_info['id']

    try:
        service = models.LinkedInService.objects.get(unique_id=unique_id)
    except models.LinkedInService.DoesNotExist:
        user = User(password=hashlib.md5(str(random.random())).hexdigest())
        service = models.LinkedInService()
    else:
        user = service.user

    screen_name = ''.join((user_info['firstName'], user_info['lastName']))
    if not user.username:
        user.username = get_unique_username(screen_name)
    if not user.first_name:
        user.first_name = user_info['firstName']
    if not user.last_name:
        user.last_name = user_info['lastName']
    user.save()

    # update service
    service.user = user
    service.unique_id = unique_id
    service.screen_name = screen_name[:20]
    service.impersonated_unique_id = impersonate or ''
    service.access_token = access_token
    service.save()
    post_register_service.send(sender=models.LinkedInService, instance=service, user_info=user_info)
    return service
Beispiel #22
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
Beispiel #23
0
def ldap_create_user_default(user_info, request):
    """takes the result returned by the :func:`ldap_authenticate`

    and returns a :class:`UserAssociation` object
    """
    # create new user in local db
    user = User()
    user.username = user_info.get('django_username', user_info['ldap_username'])
    user.set_unusable_password()
    user.first_name = user_info['first_name']
    user.last_name = user_info['last_name']
    user.email = user_info['email']
    user.is_staff = False
    user.is_superuser = False
    user.is_active = True
    user.save()
    user_registered.send(None, user=user, request=request)
    LOG.info('Created New User : [{0}]'.format(user_info['ldap_username']))

    assoc = UserAssociation()
    assoc.user = user
    assoc.openid_url = user_info['ldap_username'] + '@ldap'
    assoc.provider_name = 'ldap'
    assoc.save()
    return assoc
    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
Beispiel #25
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
Beispiel #26
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
Beispiel #27
0
    def handle(self, *args, **options):
        fake = Factory.create()
        fakeru = Factory.create('ru_RU')

        number = int(options['number'])
        
        for i in range(0, number):
            profile = fake.simple_profile()

            u = User()
            u.username = profile['username']
            u.first_name = fakeru.first_name()
            u.last_name = fakeru.last_name()
            u.email = profile['mail']
            u.password = make_password('tp2015')
            u.is_active = True
            u.is_superuser = False
            u.save()

            up = Profile()
            up.user = u
            up.info = '%s [%s]' % (fakeru.company(), fakeru.catch_phrase())

            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)
            up.save()

            self.stdout.write('[%d] added user %s' % (u.id, u.username))
Beispiel #28
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 
Beispiel #29
0
 def save(self):
     """ Save registration forms data into User and Staff.
         If any save operation fails, the others will be rolled back.
         @return: User instance
     """
     data = self.cleaned_data
     try:
         user = User(username=data["username"])
         user.email = data["email"]
         user.set_password(data["password"])
         user.first_name = data["firstname"]
         user.last_name = data["lastname"]
         user.is_active = True
         user.save()
         if data["team"]:
             try:
                 g = get_object_or_404(Group, pk=data["team"])
                 user.groups.add(g)
             except:
                 pass
         try:
             staff = Staff(user=user)
             staff.gender = data["gender"]
             staff.role = data["role"]
             staff.save()
             return user
         except Exception, e:
             logger.error("RegisterForm.save():%s" % e)
             user.delete()
             raise e
     except Exception, e:
         logger.error("RegisterForm.save():%s" % e)
         raise e
Beispiel #30
0
 def test_real_name(self):
   """Tests that users with names have display names including them"""
   user = User(username='******', password='******')
   user.first_name = 'Chuck'
   user.last_name = 'Bartowski'
   user.save()
   self.assertEqual('Chuck Bartowski', user.get_profile().get_display_name())
Beispiel #31
0
 def create(cls, person_data):
     user = User()
     user.username = person_data.get('email')
     user.email = person_data.get('email')
     user.first_name = person_data.get('first_name')
     user.last_name = person_data.get('last_name')
     user.set_password(person_data.get('password'))
     user.save()
     return cls(user=user,
                phone=person_data.get('phone'),
                cpf=person_data.get('cpf'))
Beispiel #32
0
 def clean_password(self):
     data = self.cleaned_data['password']
     user = User()
     if self.cleaned_data.get('first_name'):
         user.first_name = self.cleaned_data['first_name']
     if self.cleaned_data.get('last_name'):
         user.last_name = self.cleaned_data['last_name']
     if self.cleaned_data.get('email'):
         user.email = self.cleaned_data['email']
     password_validation.validate_password(password=data, user=user)
     return data
Beispiel #33
0
    def create(self, validated_data):

        user = User()
        user.username = validated_data.get('username', user.username)
        user.first_name = validated_data.get('first_name', user.first_name)
        user.last_name = validated_data.get('last_name', user.last_name)
        user.set_password(validated_data.get('password', user.password))
        user.email = validated_data.get('email', user.email)

        user.save()
        return user
Beispiel #34
0
 def userSignup(self, userInfo):
     print("INSIDE CONTROLLER")
     user = User()
     user.first_name = userInfo['fname']
     user.last_name = userInfo['lname']
     user.email = userInfo['email']
     user.username = userInfo['email']
     user.set_password(userInfo.get('pass'))
     user.is_active = False
     user.save()
     return user
Beispiel #35
0
 def testTeacherToStringInputteacherReturnteacher(self):
     uid = "teacher"
     teacher = Teacher()
     user = User()
     name = uid
     user.username = name
     user.first_name = name
     user.last_name = name
     user.email = "*****@*****.**"
     user.password = "******"
     teacher.user = user
     self.assertEqual(str(teacher), uid)
Beispiel #36
0
 def save(self):
     data = self.cleaned_data
     user = User()
     user.username = data['username']
     user.set_password(data['password'])
     user.email = data['email']
     user.first_name = data['first_name']
     user.last_name = data['last_name']
     user.is_active = True
     user.is_superuser = False
     user.save()
     return user
Beispiel #37
0
 def setUp(self):
     user = User()
     name = "test"
     user.username = name
     user.first_name = name
     user.last_name = name
     user.email = "*****@*****.**"
     user.password = "******"
     user.is_staff = 1
     user.is_active = 1
     user.is_superuser = 0
     user.save()
Beispiel #38
0
    def create_user(self, lti, username):
        # create the user if necessary
        user = User(username=username, password='******')
        user.set_unusable_password()
        user.email = lti.user_email()

        name = HumanName(lti.user_fullname())
        user.first_name = name.first[:30]
        user.last_name = name.last[:30]

        user.save()
        return user
Beispiel #39
0
def add_sample_user_and_user_profile(user_sample_data):
    user = User()
    user.username = user_sample_data['username']
    user.set_password(user_sample_data['password'])
    user.first_name = user_sample_data['first_name']
    user.last_name = user_sample_data['last_name']
    user.email = user_sample_data['email']
    user.save()
    user_profile = UserProfile()
    user_profile.user = user
    user_profile.save()
    return user
Beispiel #40
0
    def test_user_fields(self):
        ''' Test the existence of the user in database.'''
        user = User()
        user.username = "******"
        user.last_name = "Last name test"
        user.first_name = "First name test"
        user.email = "*****@*****.**"
        user.password = "******"
        user.save()

        response = User.objects.get(email=user.email)
        self.assertEqual(response, user)
def create_jrs_user(sp_user):
    try:
        user = User(username=sp_user.username)
        user.email = sp_user.email
        user.first_name = sp_user.first_name
        user.last_name = sp_user.last_name
        user.is_active = True
        user.save()
    except Exception as e:
        print(e)
        return None
    return user
Beispiel #42
0
 def create_user_(self):
     user = User(
         username = self.username,
         email = self.details['email']
     )
     if 'first_name' in self.data:
         user.first_name = self.data['first_name']
     if 'last_name' in self.data:
         user.last_name = self.data['last_name']
     user.set_password(random_password())
     user.save()
     self.user = user
Beispiel #43
0
 def create(self, validated_data):
     username = validated_data['username']
     password = validated_data['password']
     new_user = User(username=username)
     new_user.set_password(password)
     new_user.first_name = validated_data['first_name']
     new_user.last_name = validated_data['last_name']
     new_user.email = validated_data['email']
     new_user.save()
     Profile.objects.create(user=new_user)
     Order.objects.create(user=new_user)
     return validated_data
Beispiel #44
0
    def save(self):
        print("IN SAVE USER METHOD")
        print(self.validated_data)

        err_codes = []
        email = self.validated_data.get("email")
        first_name = self.validated_data.get("first_name")
        last_name = self.validated_data.get("last_name")
        username = "******".format(first_name, last_name)

        is_email_unique = self.email_is_unique(email=email)
        if not is_email_unique:
            err_codes.append(4)
        is_username_unique = self.username_is_unique(username=username)
        new_username = None
        if not is_username_unique:
            new_username = self.create_username_from_existing(username)
            if not new_username:
                err_codes.append(8)
        password = self.validated_data.get("password")
        password_confirm = self.validated_data.get("password_confirm")
        is_password_match = self.passwords_are_matching(
            password1=password, password2=password_confirm)
        if not is_password_match:
            err_codes.append(15)
        if err_codes:
            return {"success": False, "err_codes": err_codes}

        try:
            user = User()
            user.first_name = first_name
            user.last_name = last_name
            user.email = email
            if not new_username:
                user.username = username
            else:
                user.username = new_username
            user.password = password
            user.is_active = False
            print("USER BEFORE SAVE")
            print(user.__dict__)
            user.set_password(password)
            user.save()
        except Exception:
            user = None
            exc_type, exc_value, exc_traceback = sys.exc_info()
            traceback.print_exception(exc_type, exc_value, exc_traceback)
        if user:
            result = {"success": True, "data": user}
        else:
            result = {"success": False, "err_codes": [7]}

        return result
Beispiel #45
0
    def create(self, validated_data):
        intance = User()
        intance.first_name = validated_data.get('first_name')

        intance.last_name = validated_data.get('last_name')

        intance.username = validated_data.get('username')

        intance.email = validated_data.get('email')
        intance.set_password(validated_data.get('password'))

        intance.save()
Beispiel #46
0
def user_register(request):
    context = {}
    if request.method == "POST":
        user = User()
        user.first_name = request.POST.get('firstname')
        user.last_name = request.POST.get('lastname')
        user.username = request.POST.get('username')
        user.email = request.POST.get('email')
        user.set_password(request.POST.get('password'))
        user.save()
        context['user_saved_successfully'] = True
    return render(request, 'useraccounts/register.html', context)
Beispiel #47
0
 def signup(self, request, user: User):
     p, _ = Profile.objects.get_or_create(user=user)
     user.first_name = self.cleaned_data['first_name']
     user.last_name = self.cleaned_data['last_name']
     p.preferred_name = self.cleaned_data['preferred_name']
     p.phone_number = self.cleaned_data['phone_number']
     p.perm_address = self.cleaned_data['perm_address']
     p.full_clean()
     p.save()
     user.profile = p
     user.save()
     return user
Beispiel #48
0
    def save(self):

        logger.debug('Saving employer')
        logger.debug('self.instance.pk=' + str(self.instance.pk))
        if self.instance.pk:
            user = User.objects.get(pk=self.instance.pk)
        else:
            user = User()

        user.is_active = False
        user.first_name = self.cleaned_data["first_name"]
        user.last_name = self.cleaned_data["last_name"]
        user.username = (self.cleaned_data["email"])
        user.email = self.cleaned_data["email"]
        user.set_password(self.cleaned_data["password1"])
        user.save()

        site = self.cleaned_data["website"]
        description = self.cleaned_data["description"]
        company_name = self.cleaned_data["company_name"]
        oncampus = self.cleaned_data["oncampus"]
        address1 = self.cleaned_data["address1"]
        address2 = self.cleaned_data["address2"]
        city = self.cleaned_data["city"]
        state = self.cleaned_data["state"]
        zipcode = self.cleaned_data["zipcode"]
        phone = self.cleaned_data["phone"]

        if len(site) > 2 and not site.startswith(
                "http://") and not site.startswith("https://"):
            site = "http://" + site

        newEmployer = Employer(website=site,
                               company_name=company_name,
                               oncampus=oncampus,
                               description=description,
                               address1=address1,
                               address2=address2,
                               city=city,
                               state=state,
                               zipcode=zipcode,
                               phone=phone)
        newEmployer.userprofile = user.userprofile
        newEmployer.save()

        user.userprofile.employer = newEmployer
        user.userprofile.save()

        employergroup = Group.objects.get_or_create(name=employergroupname)
        user.groups.add(employergroup[0])

        user.save()
        return user
def frespoUser():
    user = get_or_none(User, username='******')
    if (user):
        return user
    else:
        user = User()
        user.username = '******'
        user.email = '*****@*****.**'
        user.first_name = 'Freedom'
        user.last_name = 'Sponsors'
        user.save()
    return user
 def addUser(self, username, password, email, first_name, last_name):
     user = User()
     user.username = username
     user.password = password
     user.email = email
     user.first_name = first_name
     user.last_name = last_name
     try:
         user.save()
         return True
     except IntegrityError:
         return False
Beispiel #51
0
 def create(self, validated_data):
     # user
     userprofile_data = validated_data.pop('userprofile')
     user = User()
     user.username = validated_data.get('username')
     user.email = validated_data.get('email')
     user.first_name = validated_data.get('first_name')
     user.last_name = validated_data.get('last_name')
     user.set_password(validated_data.get('password'))
     user.save()
     userprofile = UserProfile.objects.create(user=user, **userprofile_data)
     return user
Beispiel #52
0
    def _update_local_user(self,
                           user,
                           username,
                           first_name,
                           last_name,
                           email,
                           in_groups=None):
        if in_groups is None:
            in_groups = []
        # Because the username field on model User is capped to 30
        # characters we need to assign a butchered username here.
        # It's not a problem because the user can be found by email
        # anyway.
        # 30 is the default max length of the username field for
        # django.contrib.auth.models.User
        if not user:
            django_username = username
            if email_re.match(django_username):
                if isinstance(username, unicode):
                    # md5 chokes on non-ascii characters
                    django_username = username.encode('ascii', 'ignore')
                django_username = (
                    md5_constructor(django_username).hexdigest()[:30])
            user = User(username=django_username,
                        first_name=first_name,
                        last_name=last_name,
                        email=email)
            user.set_unusable_password()
            user.save()
        else:
            changed = False
            if user.first_name != first_name:
                user.first_name = first_name
                changed = True
            if user.last_name != last_name:
                user.last_name = last_name
                changed = True
            if user.email != email:
                user.email = email
                changed = True
            if changed:
                user.save()

        for django_name, ldap_names in GROUP_MAPPINGS.items():
            ldap_names = set(flatten_group_names(ldap_names))
            if ldap_names & set(in_groups):
                # make sure the user is in this django group
                if not user.groups.filter(name=django_name).exists():
                    user.groups.add(Group.objects.get(name=django_name))
            else:
                user.groups.remove(Group.objects.get(name=django_name))

        return user
Beispiel #53
0
 def update(self, instance: User, validated_data: dict):
     instance.username = validated_data.get('username', instance.username)
     password = validated_data.get('password', None)
     if password is not None:
         instance.set_password(password)
     instance.email = validated_data.get('email', instance.email)
     instance.first_name = validated_data.get('first_name', instance.first_name)
     instance.last_name = validated_data.get('last_name', instance.last_name)
     instance.is_staff = validated_data.get('is_staff', instance.is_staff)
     instance.is_superuser = validated_data.get('is_superuser', instance.is_superuser)
     instance.save()
     return instance
Beispiel #54
0
 def clean_password(self):
     """clean password field"""
     data = self.cleaned_data["password"]
     user = User()
     if self.cleaned_data.get("first_name"):
         user.first_name = self.cleaned_data["first_name"]
     if self.cleaned_data.get("last_name"):
         user.last_name = self.cleaned_data["last_name"]
     if self.cleaned_data.get("email"):
         user.email = self.cleaned_data["email"]
     password_validation.validate_password(password=data, user=user)
     return data
Beispiel #55
0
 def create(self, validated_data):
     """
     create a user an validate the data
     """
     instance = User()
     instance.first_name = validated_data.get('first_name')
     instance.last_name = validated_data.get('last_name')
     instance.username = validated_data.get('username')
     instance.email = validated_data.get('email')
     instance.set_password(validated_data.get('password'))
     instance.save()
     return instance
Beispiel #56
0
 def restore_object(self, attrs, instance=None):
     restored = super(ExtendedUserSerializerBase,
                      self).restore_object(attrs, instance=instance)
     user = User()
     user.username = attrs['user.username']
     user.first_name = attrs['user.first_name']
     user.last_name = attrs['user.last_name']
     user.email = attrs['user.email']
     user.set_password(attrs['user.password'])
     user.save()
     restored.user = user
     return restored
Beispiel #57
0
 def save(self):
     user = User()
     data = self.cleaned_data
     user.username = data.get('username')
     user.password = make_password(data.get('password'))
     user.email = data.get('email')
     user.first_name = data.get('first_name')
     user.last_name = data.get('last_name')
     user.is_active = True
     user.is_superuser = False
     user.save()
     return authenticate(username=user.username, password=user.password)
Beispiel #58
0
def import_users(data_file, reject_file, save=False):
    json_file = open(data_file)
    user_data = json.load(json_file)
    json_file.close()

    reject_file = open(reject_file, "w")
    reject_file.write("[")

    users = 0
    matches = 0
    for u in user_data:
        users = users + 1
        username = u['fields']['username']
        user = User.objects.filter(username=username).first()
        if user:
            matches = matches + 1
            print "Match (%d) on username %s = %s" % (matches, username,
                                                      user.get_full_name())
            reject_file.write(json.dumps(u))
        else:
            email = u['fields']['email']
            user = User.objects.filter(email=email).first()
            if user:
                matches = matches + 1
                print "Match (%d) on email %s = %s" % (matches, email,
                                                       user.get_full_name())
                reject_file.write(json.dumps(u))
            else:
                #{"pk": 100, "model": "auth.user", "fields": {"username": "******", "first_name": "Conni",
                #"last_name": "Biesalski", "is_active": true, "is_superuser": false, "is_staff": false,
                #"last_login": "******", "groups": [], "user_permissions": [],
                #"password": "******",
                #"email": "*****@*****.**", "date_joined": "2014-07-01T20:30:41.137Z"}}

                new_user = User(username=username, email=email)
                new_user.first_name = u['fields']['first_name']
                new_user.last_name = u['fields']['last_name']
                new_user.is_active = u['fields']['is_active']
                new_user.is_superuser = u['fields']['is_superuser']
                new_user.is_staff = u['fields']['is_staff']
                new_user.last_login = u['fields']['last_login']
                new_user.date_joined = u['fields']['date_joined']
                new_user.password = u['fields']['password']
                new_user.save()

                for g in u['fields']['groups']:
                    group = Group.objects.get(name=g[0])
                    new_user.groups.add(group)
                new_user.save()

    reject_file.write("]")
    reject_file.close()
    print "Users: %d, Matches: %d" % (users, matches)
Beispiel #59
0
Datei: views.py Projekt: slmnt/mp
    def post(self, request):
        #check username
        #try:
        uname = request.data['uid']
        pwd = request.data['pwd']
        email = request.data['email']
        new_user = User(username=uname, email=email)
        # new_user.is_active = False
        new_user.set_password(pwd)

        #check first name
        new_user.first_name = request.data['fname']
        #check last name
        new_user.last_name = request.data['lname']

        new_user.save()
        u = User.objects.get(username=uname)
        h = SHA256.new()
        h.update(uname.encode('utf-8'))
        #print(uname)
        code = h.hexdigest()
        c = CertiList(name=u, code=str(code))
        c.save()
        #print(u)

        # create user info
        queryset = UserInfo(root=new_user)
        queryset.save()

        v_user = authenticate(username=uname, password=pwd)
        if v_user is not None:
            login(request, v_user)
            #check live user moedls
            #cookie login expiry set
            #86400sec / 1day
            request.session.set_expiry(86400 * 5)

        data = {}
        data['uid'] = uname

        # send email
        body = HOSTNAME + "/checkmail/" + code + "/"
        """
            send_mail(
                'mail check',
                str(body),
                '*****@*****.**',
                [str(email)],
                fail_silently=False,
            )
            """
        return Response(data=data, status=status.HTTP_200_OK)
Beispiel #60
0
def guardarOperario(request):
    if request.method == 'POST':
        if User.objects.filter(pk=request.user.id,
                               groups__name=GRUPO1).exists():
            usu = User()
            usu.username = request.POST['nombres'] + time.strftime("%H:%M:%S")
            usu.first_name = request.POST['nombres']
            usu.last_name = request.POST['apellidos']
            usu.email = request.POST['email']
            usu.password = make_password("icbf2017")
            usu.is_active = True
            perfil = Group.objects.get(id=2)
            usu.save()
            usu.groups.add(perfil)

            operario = Operario()
            operario.id_id = usu.id
            operario.uds_id = request.POST['uds']
            operario.genero = request.POST['genero']
            operario.intentos = 5
            operario.estado = "A"

            if request.POST['bandera_foto'] == "CAMBIO":
                operario.foto = request.FILES['archivo']
            else:
                operario.foto = "media/operarios/no_photo.png"

            operario.direccion = request.POST['direccion']
            operario.telefono = request.POST['telefono']
            operario.celular = request.POST['celular']
            operario.save()

            e = Eventos()
            e.uds = operario.uds
            e.detalle = "CREACIÓN DEL OPERARIO " + usu.first_name + " " + usu.last_name
            e.f_inicio = '1997-02-21'
            e.f_fin = '2017-02-21'
            e.tipo = "TAREAS"
            e.allday = True
            e.estado = "REALIZADA"
            e.save()

            registrarLogs(
                request.user.first_name + " " + request.user.last_name,
                'GUARDAR', 'Operarios', 'Operario Creado Exitosamente',
                usu.first_name + " " + usu.last_name)
            messages.success(request, 'Creado')
            return HttpResponseRedirect('/operarios')
        else:
            return HttpResponseRedirect('/')
    else:
        return HttpResponseRedirect("/")