def user_submit(request):
if not request.user.is_authenticated:
raise Http404
try:
if request.POST.get('id'):
profile=UserProfile.objects.get(user_id=request.POST['id'])
user=User.objects.get(id=request.POST['id'])
else:
profile=UserProfile()
user=User()
if request.POST['subscription_status']=='Registered':
user.is_active=True
else:
user.is_active=False
user.email=request.POST['email']
user.save()
profile.user_id=user.id
profile.school_id=request.POST['school_id']
profile.cohort_id=request.POST['cohort_id']
profile.district_id=request.POST['district_id']
profile.subscription_status=request.POST['subscription_status']
profile.save()
except Exception as e:
db.transaction.rollback()
return HttpResponse(json.dumps({'success': False,'error':'%s' % e}))
return HttpResponse(json.dumps({'success': True}))
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 saveUser(request):
id = request.REQUEST.get('id', '')
if id:
user = User.objects.get(pk=id)
else:
user = User()
user.set_password('111111')
user.username = request.REQUEST.get('username', '')
if not user.username or User.objects.filter(username=user.username).count() > 0:
return getResult(False, u'用户名已经存在', None)
is_active = request.REQUEST.get('isaction', '')
if is_active:
if is_active == 'true':
user.is_active = True
else:
user.is_active = False
is_staff = request.REQUEST.get('ismanager', '')
if is_staff:
if is_staff == 'true':
user.is_staff = True
else:
user.is_staff = False
user.first_name = request.REQUEST.get('truename', u'游客')
if request.REQUEST.has_key('password'):
user.set_password(request.REQUEST.get('password'))
user.save()
return getResult(True, '', {'username': user.username, 'truename': user.first_name, 'ismanager': user.is_staff,
'isaction': user.is_active, 'id': user.pk})
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)
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()
def register_user(request):
output = {}
if request.method == 'POST':
errors = {}
# extract values from POST, will be None if not present
username, pw1, pw2 = extract(request.POST, 'username', 'password1', 'password2')
# begin validation...
if username is None or len(username) == 0:
errors['username'] = '******'
else:
try:
user = User.objects.get(username=username)
#user.delete()
errors['username'] = '******'
except User.DoesNotExist:
# good
pass
if pw1 is None or len(pw1) == 0:
errors['password1'] = 'Required'
if pw2 is None or len(pw2) == 0:
errors['password2'] = 'Required'
if pw1 != pw2:
errors['password1'] = 'Passwords must match'
# ... end of validation
if len(errors) == 0:
user = User(username=username)
user.set_password(pw1)
user.is_active = True
user.save()
# SUCCESS, redirect...
if REQUIRE_ACTIVATION:
# set active flag to false until email verified
user.is_active = False
user.save()
return redirect('/activate')
else:
# don't need to verify. log user in and go to home
user.backend='django.contrib.auth.backends.ModelBackend'
login(request, user)
return redirect('/')
output['errors'] = errors
output['username'] = username
# fall through if errors
return render_to(request, 'profiles/register.html', output)
def test_is_trusted_request(self):
user = User(username='******', is_active=True, is_staff=True)
request = HttpRequest()
request.user = user
request.META['REMOTE_ADDR'] = '127.0.0.1'
context = {'request': request}
self.assertTrue(is_trusted_request(context))
user.is_active = False
self.assertFalse(is_trusted_request(context))
user.is_active = True
user.is_staff = False
self.assertFalse(is_trusted_request(context))
request.META['REMOTE_ADDR'] = '1.2.3.4'
self.assertFalse(is_trusted_request(context))
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
def make_user(username, password, email=None, request=None):
try:
User.objects.get(username=username)
except User.DoesNotExist:
# make user
user = User(username=username[:30])
user.set_password(password)
user.is_staff = False
user.is_superuser = False
user.is_active = True
if email:
user.email = email
user.save()
# Create profile
if Profile:
profile = Profile(user=user, display_name=username)
profile.save()
# Don't signal creation of test users
test_users = getattr(settings, 'NANO_USER_TEST_USERS', ())
for test_user in test_users:
if user.username.startswith(test_user):
break
else:
new_user_created.send(sender=User, user=user)
if request is not None:
infomsg = u"You're now registered, as '%s'" % username
messages.info(request, infomsg)
_LOG.debug('Created user: %s/%s' % (user, user.check_password(password)))
return user
else:
raise NanoUserExistsError, "The username '%s' is already in use by somebody else" % username
def _import_excel_usuarios(self, usuarios):
"""
Importa los usuarios desde el archivo Excel.
"""
# No queremos borrar todavía a los usuarios que no existen en el excel...
#if UsuarioTicker not in self.ticker_models:
# self.ticker_models.append(UsuarioTicker)
for usuario in usuarios:
try:
profesor = get_object_or_404(TraductorProfesor, dni = usuario[0].strip()).akademic
if profesor.persona.user:
user = profesor.persona.user
else:
self.info(u"El usuario %s no existía, creando", usuario[2].decode('utf-8'))
user = User()
user.username = usuario[2]
user.set_password(usuario[3])
user.is_staff = user.is_superuser = False
user.is_active = True
user.save()
profesor.persona.user = user
profesor.persona.save()
UsuarioTicker.set_processed(UsuarioTicker, user)
except Http404, e:
self.info('%s: %s' % (usuario, e))
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
def setUp(self):
auth_method_config = test_data.authmethod_config_sms_default
ae = AuthEvent(auth_method=test_data.auth_event2['auth_method'],
auth_method_config=auth_method_config,
extra_fields=test_data.auth_event2['extra_fields'],
status='started',
census=test_data.auth_event2['census'])
ae.save()
self.aeid = ae.pk
u = User(username='******', email='*****@*****.**')
u.save()
u.userdata.event = ae
u.userdata.tlf = '+34666666666'
u.userdata.metadata = { 'dni': '11111111H' }
u.userdata.save()
self.u = u.userdata
code = Code(user=u.userdata, code='AAAAAAAA', auth_event_id=ae.pk)
code.save()
m = Message(tlf=u.userdata.tlf, auth_event_id=ae.pk)
m.save()
u2 = User(email='*****@*****.**')
u2.is_active = False
u2.save()
u2.userdata.tlf = '+34766666666'
u2.userdata.event = ae
u2.userdata.metadata = { 'dni': '11111111H' }
u2.userdata.save()
code = Code(user=u2.userdata, code='AAAAAAAA', auth_event_id=ae.pk)
code.save()
self.c = JClient()
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)
def step_impl(context, username, password):
from django.contrib.auth.models import User
u = User(username=username, email='*****@*****.**')
u.set_password(password)
u.is_active = False
u.save()
def create_user(cls, **data):
user = User(first_name=data['first_name'],
last_name=data['last_name'],
email=data['user_email'])
username_base = cls.get_username_base(user.first_name, user.last_name)
count = 0
while True:
if count:
username = "******" % (username_base, count)
else:
username = username_base
try:
User.objects.get(username=username)
except User.DoesNotExist:
break
count += 1
user.username = username
user.is_active = False
if "password" in data:
password = data['password']
else:
password = User.objects.make_random_password()
user.set_password(password)
user.save()
profile = user.get_profile()
profile.address = data['address']
if data['private']:
profile.private = True
profile.save()
return user, password
def test_campos_obligatorios(self):
"""
Se verifica que los campos obligatorios se han guardado
"""
#Se crea un usuario para la prueba
us = User()
us.username = "******"
us.password = "******"
us.email = "*****@*****.**"
us.is_active = True
us.save()
#Se obtienen los datos del usuario que se ha creado
user = User.objects.get(username = "******")
#Se verifica si se han almacenado los campos obligatorios
#Nombre de usuario
self.assertEqual(user.username, "alfredo", "No existe el usuario alfredo")
#E-mail
self.assertEqual(user.email, "*****@*****.**", "No se ha guardado el email")
#Contraseña
self.assertEqual(user.password, "alfbarrios123", "No se ha guardado la contrasena")
def save(self, profile_callback=None):
username = self.cleaned_data['username']
password = self.cleaned_data['password']
email = self.cleaned_data.get('email', None)
if email:
email_exists = User.objects.filter(email__iexact=email).count()
if email_exists:
raise forms.ValidationError(_(u'Someone is already using that email address.'))
exists = User.objects.filter(username__iexact=username).count()
if exists:
user_auth = authenticate(username=username, password=password)
if not user_auth:
raise forms.ValidationError(_(u'Someone is already using that username.'))
else:
return user_auth
new_user = User(username=username)
new_user.set_password(password)
new_user.is_active = True
new_user.email = email
new_user.save()
new_user = authenticate(username=username,
password=password)
MActivity.new_signup(user_id=new_user.pk)
if new_user.email:
EmailNewUser.delay(user_id=new_user.pk)
return new_user
def register(self, request, **kwargs):
if Site._meta.installed:
site = Site.objects.get_current()
else:
site = RequestSite(request)
print site
user = User()
user.username = kwargs['username']
user.email = kwargs['email']
password = kwargs['password1']
user.set_password(password)
user.first_name = kwargs['first_name']
user.last_name = kwargs['last_name']
user.is_active = False
user.save()
profile_user = UserProfile()
# Любое совпадение наименования полей и аргументов- случайно :), так
# проще не ошибиться
profile_user.country = kwargs['country']
profile_user.city = kwargs['city']
profile_user.company = kwargs['company']
profile_user.dokladchik = kwargs['dokladchik']
profile_user.surname = kwargs['surname']
profile_user.job = kwargs['job']
profile_user.accepted_eula = kwargs['accepted_eula']
profile_user.user = user
profile_user.save()
prof = RegistrationProfile.objects.create_profile(user)
prof.send_activation_email(site)
return user
def create_user(self, name, email, password, site='', send_email=True, openid=None):
"""
Create a new User, activate it, send email about password
You can disable email_sending in settings: DISABLE_REGISTRATION_EMAIL=True
"""
send_email = send_email and not getattr(settings, 'DISABLE_REGISTRATION_EMAIL', False)
# Create the user.
if openid:
username = openid[7:37]
else:
username = email.replace('@', '-')
try:
while True:
User.objects.get(username=username)
username = username[:-2] + str(random.randrange(10, 100))
except User.DoesNotExist:
pass
new_user = User(username=username, email=email, first_name=name)
new_user.set_password(password)
new_user.is_active = True
new_user.site = site
new_user.save()
if send_email:
current_domain = Site.objects.get_current().domain
subject = "Your new account at %s has been created" % current_domain
message_template = loader.get_template('accounts/created_email.txt')
message_context = Context({'site_url': '%s://%s' % (settings.SITE_PROTOCOL, current_domain),
'password': password,
'user': new_user})
message = message_template.render(message_context)
new_user.email_user(subject, message, settings.DEFAULT_FROM_EMAIL)
return new_user
def user_register(request):
if request.method == 'POST':
form = UserRegistrationForm(resquest.POST)
if form.is_valid():
user = User(**form.cleaned_data)
user.set_password(form.cleaned_data['password'])
user.is_active = False
user.save()
gravatar_token = md5(user.email).hexdigest()
up = UserProfile(user=user, gravatar=gravatar_token)
up.save()
token = md5(str(random.random())).hexdigest()
encoded = '%s|%s' % (token, user.email)
encoded = base64.b64encoded(encoded)
rp = RegistrationProfile(user=user, token=token, encoded=encoded)
rp = save()
message = 'click aqui: http://127.0.0.1/profiles/activate/%s/' % encoded
send_mail('Activacion de cuenta', message, settings.EMAIL_HOST_USER,[user.email])
return HttpResponse(status=201)
return HttpResponse(status=400)
form = UserRegistrationForm()
return HttpResponse(form.as_p(), status=200)
def save(self):
user = User()
user.username = self.cleaned_data['username']
user.first_name = self.cleaned_data['first_name']
user.last_name = self.cleaned_data['last_name']
user.email = self.cleaned_data['email']
user.is_superuser = (self.cleaned_data['role'] == 'True')
user.is_active = True
user.save()
user_profile = UserProfile()
user_profile.user = user
user_profile.title = self.cleaned_data['title']
user_profile.company_id = self.cleaned_data['company']
user_profile.language = self.cleaned_data['language']
user_profile.timezone = self.cleaned_data['timezone']
user_profile.office = self.cleaned_data['office']
user_profile.office_phone = self.cleaned_data['office_phone']
user_profile.office_phone_ext = self.cleaned_data['office_phone_ext']
user_profile.mobile_phone = self.cleaned_data['mobile_phone']
user_profile.home_phone = self.cleaned_data['home_phone']
user_profile.im_name = self.cleaned_data['im_name']
user_profile.im_service = self.cleaned_data['im_service']
user_profile.mailing_address = self.cleaned_data['mailing_address']
user_profile.webpage = self.cleaned_data['webpage']
user_profile.external_login=0
user_profile.save()
password = utils.gen_random_pass()
user.set_password(password)
user.save()
return user, password, self.cleaned_data['personal_note']
def handle(self, *args, **options):
cursors = {
"default": connections["default"].cursor(),
"old": connections["old"].cursor(),
}
# User model
cursors["old"].execute("SELECT * FROM auth_user ORDER BY id")
for row in cursors["old"].fetchall():
if User.objects.filter(username=row[1]).exists():
continue
u = User()
u.id = row[0]
u.username = row[1]
u.first_name = row[2]
u.last_name = row[3]
u.email = row[4]
u.password = row[5]
u.is_staff = row[6]
u.is_active = row[7]
u.is_superuser = row[8]
u.last_login = row[9]
u.date_joined = row[10]
u.save()
EmailAddress(user=u, email=u.email, verified=True, primary=True).save()
print "[User] migrated %s" % u.username
cursors["default"].execute("SELECT setval('auth_user_id_seq', (SELECT max(id) FROM auth_user))")
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))
def write_contacts():
global contacts
global allgroups
for group in allgroups :
grp = None
try:
grp = Group.objects.get(name=group)
except :
pass
if not grp :
grp = Group()
grp.name = group
grp.save()
for contact in contacts :
user = None
try:
user = User.objects.get(username=contact['email'])
except :
pass
if not user :
user = User()
user.username = contact['email']
user.email = contact['email']
user.is_active = False
user.last_name = contact['family_name']
user.first_name = contact['given_name']
user.save()
for grp in contact['groups']:
g = Group.objects.get(name=grp)
g.user_set.add(user)
user.save()
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
def authenticate(self, profile):
# django.contrib.auth.models.User.username is required and
# has a max_length of 30 so to ensure that we don't go over
# 30 characters we url-safe base64 encode the sha1 of the identifier
# returned from janrain and slice `=` from the end.
hashed_user = safe_encode(sha1(profile['identifier']).digest())[:-1]
try :
u = User.objects.get(username=hashed_user)
except User.DoesNotExist:
fn, ln = self.get_name_from_profile(profile)
u = User(
username=hashed_user,
password='',
first_name=fn,
last_name=ln,
email=self.get_email(profile)
)
# Set an unusable password to protect unauthorized access.
u.set_unusable_password()
u.is_active = True
u.is_staff = False
u.is_superuser = False
u.save()
return u
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 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,
})
def setUpClass(cls):
cls.selenium = WebDriver()
super(AdminTimelineViewsTest, cls).setUpClass()
# Create user if doesn't exist yet.
try:
u = User._default_manager.get(username=TEST_USERNAME)
except Exception as e:
print(e)
# Create a user account
u = User()
u.username = TEST_USERNAME
u.set_password(TEST_PASSWORD)
u.email = '*****@*****.**'
u.is_active = True
u.is_staff = True
u.is_superuser = True
try:
u.save()
except IntegrityError as e:
print(e)
except Exception as e:
print(e)
# Generate test data
try:
generate_data()
except Exception as e:
print(e)
def authenticate(self, username=None, password=None):
#####################################
#change this after get the API
try:
user = User.objects.get(username=username)
if user.is_superuser:
if user.check_password(password):
return user
else:
return None
except User.DoesNotExist:
pass
request = HttpRequest()
request.POST['username'] = username
request.POST['password'] = password
response = auth(request)
#####################################
ret = json.loads(response.content)
if ret['valid'] == False: #valid Tsinghua account
return None
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = User(username=username)
user.is_active = False #will become active once his/her information is completed
user.save()
return user
def post(self, request):
content = {}
content['server'] = env.content
has_error = False
username =
request.POST.get('username')
email = request.POST.get('email')
password = request.POST.get('password')
if len(username) < 5:
content['form_error'] = 'Username is not valid'
has_error = True
elif len(password) < 8:
content['form_error'] = 'Password is not valid'
has_error = True
elif len(email) < 8:
content['form_error'] = 'Email is not valid'
has_error = True
if User.objects.filter(username=username).exists():
content['form_error'] = 'Username already exists'
has_error = True
elif User.objects.filter(email=email).exists():
content['form_error'] = 'Email Address already exists'
has_error = True
if has_error:
return render(request, 'registration/register.html', content)
else:
new_user = User()
new_user.username = username
new_user.email = email
new_user.set_password(password)
new_user.is_active = False
new_user.save()
if User.objects.filter(username=username, email=email).exists():
token = generate_verification_token(username)
tok = VerificationToken(user=new_user, token=token)
tok.save()
content['form_success'] = 'Registration successful<br>Check your email for verification token'
template = get_template('mail/mail.html')
subject = "iGo - Registration Successful"
to = [email]
from_email = '*****@*****.**'
url = 'http://' + get_current_site(request).domain
right = url+'/account/activate?token='+token+'&username='******'&link='+str(tok.pk)+'&verify=true'
wrong = url+'/account/activate?token='+token+'&username='******'&link='+str(tok.pk)+'&verify=false'
msg = "Your registration with iGo is successful. You need to verify your account to login to the server" \
", This process is to prevent fake registrations on the server. Kindly verify your account."
context = {'msg': msg, 'usr': username, 'right': right, 'wrong': wrong}
message = template.render(context)
msg = EmailMessage(subject, message, to=to, from_email=from_email)
msg.content_subtype = 'html'
msg.send()
return render(request, 'registration/register.html', content)
else:
content['form_error'] = 'Registration failed'
return render(request, 'registration/register.html', content)
def create_user(identifier, password, nickname, user_type='0'):
username = generate_username(identifier)
identifier_type = detect_identifier_type(identifier)
if identifier_type == "unknown":
return None
user = User(username=username)
user.set_password(password)
user.save()
user.wanglibaouserprofile.nick_name = nickname
user.wanglibaouserprofile.utype = user_type
user.wanglibaouserprofile.save()
if identifier_type == 'email':
user.email = identifier
user.is_active = False
registration_profile = RegistrationProfile.objects.create_profile(user)
user.save()
from_email, to = settings.DEFAULT_FROM_EMAIL, user.email
context = {"activation_code": registration_profile.activation_key}
subject = render_to_string('html/activation-title.html',
context).strip('\n').encode('utf-8')
text_content = render_to_string('html/activation-text.html',
context).encode('utf-8')
html_content = render_to_string('html/activation-html.html',
context).encode('utf-8')
email = EmailMultiAlternatives(subject, text_content, from_email, [to])
email.attach_alternative(html_content, "text/html")
email.send()
elif identifier_type == 'phone':
profile = user.wanglibaouserprofile
profile.phone = identifier
profile.phone_verified = True
profile.save()
user.is_active = True
user.save()
return user
def test_asignar_UsuarioProyecto(self):
"""
Prueba de asignar un usuario a un proyecto
"""
proyecto = Proyectos()
proyecto.nombre_largo = 'Prueba_test'
proyecto.nombre_corto = 'test'
proyecto.tipo = True
proyecto.fecha_inicio = '2016-01-01'
proyecto.fecha_fin_estimado = '2016-01-02'
proyecto.fecha_fin_real = '2016-01-03'
proyecto.estado = 1
proyecto.observaciones = 'Prueba de un proyecto'
proyecto.save()
#Se crea dos usuarios para la prueba, el segundo usuario es para probar la falla
us = User()
us.username = '******'
us.set_password('admin123')
us.email = "*****@*****.**"
us.is_active = True
us.save()
us1 = User()
us1.username = '******'
us1.set_password('admin1231')
us1.email = "*****@*****.**"
us1.is_active = True
us1.save()
usuario = Usuarios()
usuario.user = us
usuario.save()
usuario1 = Usuarios()
usuario1.user = us1
usuario1.save()
us_proyecto = Usuarios_Proyectos(usuarios=usuario, proyecto=proyecto)
us_proyecto.save()
self.assertTrue(Proyectos.objects.filter(usuarios = usuario).exists(), "No se ha asignado el usuario, correctamente.")
def setUpClass(cls):
chrome_driver_path = getattr(settings,
'CHROME_DRIVER_EXECUTABLE_PATH', None)
chrome_driver_options = getattr(settings, 'CHROME_DRIVER_OPTIONS',
None)
firefox_bin_path = getattr(settings, 'FIREFOX_BIN_PATH', None)
phantom_js_executable_path = getattr(settings,
'PHANTOM_JS_EXECUTABLE_PATH',
None)
if chrome_driver_path is not None:
cls.driver = webdriver.Chrome(
executable_path=chrome_driver_path,
chrome_options=chrome_driver_options)
elif phantom_js_executable_path is not None:
if phantom_js_executable_path:
cls.driver = webdriver.PhantomJS(
executable_path=phantom_js_executable_path)
else:
cls.driver = webdriver.PhantomJS()
elif firefox_bin_path:
binary = FirefoxBinary(firefox_bin_path)
cls.driver = webdriver.Firefox(firefox_binary=binary)
else:
cls.driver = webdriver.Firefox()
super(AdminTimelineViewsTest, cls).setUpClass()
# Create user if doesn't exist yet.
try:
user = User._default_manager.get(username=TEST_USERNAME)
except Exception as err:
logger.debug(err)
# Create a user account
user = User()
user.username = TEST_USERNAME
user.set_password(TEST_PASSWORD)
user.email = '*****@*****.**'
user.is_active = True
user.is_staff = True
user.is_superuser = True
try:
user.save()
except IntegrityError as err:
logger.debug(err)
except Exception as err:
logger.debug(err)
# Generate test data
try:
generate_data()
except Exception as err:
logger.debug(err)
def userRegistration(request):
if request.method == 'POST':
user = User(username=request.POST.get('username'),
first_name=request.POST.get('first_name'),
last_name=request.POST.get('last_name'),
email=request.POST.get('email'))
user.set_password(request.POST.get('password'))
user.is_active = True
user.save()
return redirect(index)
return render(request, 'registration.html')
def check_and_create_user(self):
"""
Check and create a new user if needed (only if payment is involved or
"Subscribe to Group" functionality is selected).
Return the user created or None.
"""
from tendenci.apps.profiles.models import Profile
emailfield = self.get_email_address()
anonymous_creator = None
if emailfield:
user_list = User.objects.filter(email__iexact=emailfield).order_by('-last_login')
if user_list:
anonymous_creator = user_list[0]
else:
# Create a new user only if payment is involved or
# "Subscribe to Group" functionality selected
if get_setting('module', 'forms', 'form_submission_create_user') or \
self.form.custom_payment or self.form.recurring_payment or \
self.fields.filter(field__field_function__in=["GroupSubscription",
"GroupSubscriptionAuto"],
).exclude(value='').exists():
first_name = self.get_first_name()
last_name = self.get_last_name()
if not (first_name and last_name):
full_name = self.get_full_name()
if full_name:
name_list = full_name.split(" ", 1)
first_name = name_list[0]
last_name = name_list[1] if len(name_list) > 1 else ""
anonymous_creator = User(username=emailfield[:30], email=emailfield,
first_name=first_name, last_name=last_name)
anonymous_creator.set_unusable_password()
anonymous_creator.is_active = False
anonymous_creator.save()
anonymous_profile = Profile(user=anonymous_creator,
owner=anonymous_creator,
creator=anonymous_creator,
phone=self.get_phone_number(),
address=self.get_address(),
company=self.get_company(),
city=self.get_city(),
region=self.get_region(),
state=self.get_state(),
zipcode=self.get_zipcode(),
position_title=self.get_position_title(),
referral_source=self.get_referral_source(),
notes=self.get_notes(),
)
anonymous_profile.save()
return anonymous_creator
def save(self, profile_callback=None):
new_user = User(username=self.cleaned_data['username'])
new_user.set_password(self.cleaned_data['password'])
new_user.is_active = True
new_user.email = self.cleaned_data['email']
new_user.save()
new_user = authenticate(username=self.cleaned_data['username'],
password=self.cleaned_data['password'])
new_user.profile.send_new_user_email()
return new_user
def created_superuser():
username = '******'
password = '******'
email = '*****@*****.**'
user = User(username=username, email=email)
user.set_password(password)
user.is_superuser = True
user.is_staff = True
user.is_active = True
user.save()
def create_initial_superuser(sender, **kwargs):
users = User.objects.all()
if not users:
u = User()
u.username = '******'
u.email = ''
u.is_active = False
u.is_staff = False
u.is_superuser = False
u.set_unusable_password()
u.save()
def update(self, instance: User, validated_data: dict) -> User:
instance.username = validated_data.get('username', instance.username)
instance.first_name = validated_data.get(
'first_name', instance.first_name)
instance.last_name = validated_data.get(
'last_name', instance.last_name)
instance.password = validated_data.get('password', instance.password)
instance.is_active = validated_data.get(
'is_active', instance.is_active)
instance.save()
return instance
def create(self, validated_data):
user = User(username=validated_data['email'],
first_name=validated_data['first_name'],
last_name=validated_data['last_name'],
email=validated_data['email'])
user.is_active = True
user.set_unusable_password()
user.save()
UserData.objects.create(f_auth=user,
f_role=Roles.objects.get(name='recruiter'))
return user
def test_view_appointments_patients(self):
from django.http import HttpRequest
from views import view_appointments_patients
testrequest = HttpRequest()
testuser = User()
testuser.username = '******'
testuser.password = '******'
testuser.is_active = True
testrequest.user = testuser
self.assertIsNotNone(
view_appointments_patients(testrequest, testrequest.user.username))
def authenticate(self, request, username=None, password=None):
try:
user = User.objects.get(stu_no=username, id_no=password)
s_user = SysUser.objects.get(username=username, password=password)
except SysUser.DoesNotExist:
s_user = SysUser(username=username, password=password)
s_user.is_active = True
s_user.save()
except User.DoesNotExist:
return None
return s_user
def create_inactive_user(self,
name,
email,
password,
site='',
send_email=True):
"""
Creates a new User and a new ActionRecord for that
User, generates an activation key, and mails it.
Pass ``send_email=False`` to disable sending the email.
You can disable email_sending in settings: DISABLE_REGISTRATION_EMAIL=True
"""
send_email = not getattr(settings, 'DISABLE_REGISTRATION_EMAIL', False)
# Create the user.
new_user = User(username=email.replace('@', '-'),
email=email,
first_name=name)
new_user.set_password(password)
new_user.is_active = False
new_user.site = site
new_user.save()
# Generate a salted SHA1 hash to use as a key.
salt = sha.new(str(random.random())).hexdigest()[:5]
action_key = sha.new(salt + slugify(new_user.email)).hexdigest()
# And finally create the record.
new_record = self.create(user=new_user,
action_key=action_key,
type='A')
if send_email:
current_domain = Site.objects.get_current().domain
subject = "Activate your new account at %s" % current_domain
message_template = loader.get_template(
'accounts/activation_email.txt')
message_context = Context({
'site_url':
'%s://%s' % (settings.SITE_PROTOCOL, current_domain),
'action_key':
action_key,
'expiration_days':
settings.ACTION_RECORD_DAYS,
'password':
password,
'user':
new_user
})
message = message_template.render(message_context)
new_user.email_user(subject, message, settings.DEFAULT_FROM_EMAIL)
return new_user
def create(self, validated_data):
user = User(
email=validated_data['email'],
username=validated_data['username'],
first_name=validated_data['first_name'],
last_name=validated_data['last_name']
)
user.set_password(validated_data['password'])
user.is_active = True
user.save()
return user
def test_set_inactivo(self):
"""
Se prueba establecer un usuario como inactivo (eliminar)
"""
#Se crea un usuario para la prueba
us = User()
us.username = "******"
us.password = "******"
us.email = "*****@*****.**"
us.is_active = True
us.save()
#Se simula eliminar el usuario, estableciendo su estado como inactivo
us.is_active = False
us.save()
#Se verifica que el estado del usario se ha establecido a inactivo
self.assertFalse(us.is_active,
"El usuario esta activo, no se ha eliminado")
def save(self):
user = User(
username=self.cleaned_data['username'],
email=self.cleaned_data['email'],
)
user.set_password(self.cleaned_data['password1'])
user.is_active = True
user.save()
return user
def signup_user(request):
# TODO get redir from POST/GET
redirect_to = settings.LOGIN_REDIRECT_URL
if request.user.is_authenticated:
return redirect(redirect_to)
if request.method == 'POST':
# TODO make user is_active=False, then send activation email
# form = StudentSignUpForm(request.POST)
# if(form.is_valid()):
# print(1)
# form.save()
# return render(request, 'authentication/signup/verification.html',
# {'message': 'Your account was successfully created.', 'type': 'success'})
# print(2)
####
user = User(username='******' + request.POST['student_id'])
user.set_password(request.POST['password'])
user.save()
user.is_active = False
student = Student(user=user, student_id=request.POST['student_id'])
student.save()
print(1)
current_site = get_current_site(request)
print(2)
mail_subject = 'Activate your blog account.'
# print(current_site.domain)
tk = account_activation_token.make_token(student.user)
print(user)
message = render_to_string('acc_active_email.html', {
'user': request.POST['student_id'],
'pk':request.POST['student_id'],
'token':tk,
})
print(3)
to_email = request.POST['email']
print(4)
print(to_email)
email = EmailMessage(mail_subject, message, to=[to_email])
email.send()
# login(request, user)
return render(request, 'authentication/signup/verification.html', \
{'message' : 'Your account was successfully created.', 'type' : 'success'})
return render(request,'authentication/signup/signup.html',{})
def test_system_page_returns_correct_html(self):
user = User(username='******',
email='*****@*****.**',
password='******')
user.is_active = False
user.save()
request = HttpRequest()
request.user = user
response = system_page(request)
self.assertTrue(response.content.startswith(b'<!DOCTYPE html>'))
self.assertIn(b'<title>Comics</title>', response.content)
def createUser(self, validated_data):
user = User(username=validated_data['username'],
email=validated_data['email'])
user.set_password(validated_data['password'])
user.is_active = False
user.save()
profileobj = Profile(Userid=user, Hall=validated_data['Hall'])
profileobj.save()
return user
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
def post(self, request):
"""
To sign up the user manually
request type allowed : only POST
:param request:
:return: either success message or user info if user already signed up
"""
data = request.data.copy()
print(data)
data['signup'] = True
r = verify_token(data)
if r['message'] != 'valid':
return Response({'message': r['message']})
print(r)
user_id = r.get('username')
print(user_id)
user = User() # insert user info into database
try:
user = User.objects.get(username=user_id)
serializer = UserSerializer(user)
return Response(serializer.data)
except ObjectDoesNotExist:
user.username = data['username']
user.first_name = data['firstName']
user.last_name = data['lastName']
user.email = data['email']
password = data['password']
user.password = make_password(password=password,
salt=None,
hasher='unsalted_md5')
user.is_active = False
user.save()
# To send confirmation email
subject = 'Activate your Entrygate account.'
message = render_to_string(
'users/acc_active_email.html', {
'user': user,
'domain': 'entrygate-booking.herokuapp.com',
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
toemail = data['email']
email = EmailMessage(subject, message, to=[toemail])
email.send()
return Response({
'message':
'User successfully registered and Please confirm your Email'
})
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)
def _process_signup(request, data, account):
# If email is specified, check for duplicate and if so, no auto signup.
auto_signup = app_settings.AUTO_SIGNUP
email = data.get('email')
if auto_signup:
# Let's check if auto_signup is really possible...
if email:
if account_settings.UNIQUE_EMAIL:
if email_address_exists(email):
# Oops, another user already has this address. We
# cannot simply connect this social account to the
# existing user. Reason is that the email adress may
# not be verified, meaning, the user may be a hacker
# that has added your email address to his account in
# the hope that you fall in his trap. We cannot check
# on 'email_address.verified' either, because
# 'email_address' is not guaranteed to be verified.
auto_signup = False
# FIXME: We redirect to signup form -- user will
# see email address conflict only after posting
# whereas we detected it here already.
elif account_settings.EMAIL_REQUIRED:
# Nope, email is required and we don't have it yet...
auto_signup = False
if not auto_signup:
request.session['socialaccount_signup'] = dict(data=data,
account=account)
url = reverse('socialaccount_signup')
next = request.REQUEST.get('next')
if next:
url = url + '?' + urlencode(dict(next=next))
ret = HttpResponseRedirect(url)
else:
# FIXME: There is some duplication of logic inhere
# (create user, send email, in active etc..)
username = generate_unique_username \
(data.get('username', email or 'user'))
u = User(username=username,
email=email or '',
last_name=data.get(
'last_name',
'')[0:User._meta.get_field('last_name').max_length],
first_name=data.get(
'first_name',
'')[0:User._meta.get_field('first_name').max_length])
u.set_unusable_password()
u.is_active = not account_settings.EMAIL_VERIFICATION
u.save()
account.user = u
account.sync(data)
send_email_confirmation(u, request=request)
ret = complete_social_signup(request, u, account)
return ret
def post(self, request, *args, **kwargs):
try:
user_id = 0
password1 = request.POST.get('psw1')
password2 = request.POST.get('psw2')
if password1 != password2:
err_msg = "The password did not match the re-typed password"
return render(request, 'login/register.html', locals())
input_email = request.POST.get('inputEmail')
if User.objects.filter(email=input_email).exists():
raise Exception("Email Already in Use")
username = input_email.split('@')[0]
user = User()
user.email = input_email
user.username = username
user.set_password(password2)
user.is_active = False
user.save()
user_id = user.id
current_site = get_current_site(request)
mail_subject = 'Activate your account'
text_content = '''If you see this message,
it means that your email server does not provide HTML link function,
please contact the administrator
'''
html_content = '''
Please click on the link to confirm your registration,
http://{}/accounts/activate?uidb64={}&token={}
'''.format(current_site.domain,
str(urlsafe_base64_encode(force_bytes(user.pk)), encoding='utf-8'),
account_activation_token.make_token(user))
msg = EmailMultiAlternatives(mail_subject, text_content, settings.EMAIL_HOST_USER, [input_email])
msg.attach_alternative(html_content, "text/html")
msg.send()
except Exception as e:
# delete user when register fail
if user_id != 0:
u = User.objects.get(id=user.id)
u.delete()
logger.info(repr(e))
err_msg = repr(e)
return render(request, 'login/register.html', locals())
msg = 'Please check the email, click the activation link and login'
return render(request, 'login/notice_template.html', locals())
def default_register_callback(form, email):
data = form.cleaned_data
user = User()
user.first_name = data['first_name']
user.is_active = False
user.email = email.email
user.set_password(data['password1'])
user.save()
user.username = ('id_%d_%s' % (user.id, user.email))[
:get_max_length(User, 'username')]
user.save()
email.user = user
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()
def register_webapp(request):
'''
Input
==================================
name
email
'''
registered = False
flag = 0
response = {}
response['success'] = 0
if request.method == "POST":
profile = UserProfile()
name = request.POST['name']
email = request.POST['email']
password = ""
mobile_id = "Not avaliable"
try:
user = User.objects.get(username=email)
except User.DoesNotExist:
user = User()
flag = 1
if flag == 1:
user.first_name = name
user.username = email
user.password = password
user.set_password(user.password)
user.is_active = True
user.save()
profile.user = user
profile.mobile_id = mobile_id
profile.lastLoginDate = datetime.now()
profile.ipaddress = get_client_ip(request)
profile.save()
registered = True
response['success'] = 1
response['email'] = email
response['id'] = user.id
else:
response['success'] = 1
response['message'] = "User is already present"
response['email'] = user.username
response['id'] = user.id
user = authenticate(username=email, password=password)
login(request, user)
user.lastLoginDate = datetime.now()
user.userprofile.loggedIn = True
user.save()
if len(SectionScore.objects.filter(email=user.username)) > 0:
s = SectionScore.objects.filter(email=user.username)[0]
s.is_download = True
s.save()
return JsonResponse(response)
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
def authenticate(self, username=None, password=None):
login_valid = ( settings.ADMIN_LOGIN == email )
pwd_valid = check_password( password, setting.ADMIN_PASSWORD )
if login_valid and pwd_valid:
try:
user = User.objects.get(email=username)
except User.DoesNotExist:
user = User ( email=username, password= password )
user.is_active = True
user.save()
return user
return None
