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 authenticate(self, jos_session_id=None):
try:
jos_session = Jos_session.objects.exclude(username='').get(session_id=jos_session_id)
except ObjectDoesNotExist:
return None
try:
user = User.objects.get(username=jos_session.username)
except User.DoesNotExist:
user = User(username=jos_session.username)
user.set_unusable_password()
try:
jos_user = Jos_user.objects.get(id=jos_session.userid)
user.email = jos_user.email
if jos_user.name:
parsed_name = jos_user.name.split(" ", 1)
user.first_name, user.last_name = parsed_name if len(parsed_name) > 1 else ("", parsed_name[0])
except:
pass
# update user privileges
user.is_active = True
if jos_session.usertype in ('Super Administrator', 'Administrator'):
user.is_staff = True
user.is_superuser = True
else:
user.is_staff = False
user.is_superuser = False
user.save()
return user
def authenticate(self,username=None,password=None):
if not self.is_valid(username,password):
return None
perm = self.have_permission(username, password)
try:
user = User.objects.get(username=username.lower())
except User.DoesNotExist:
user = User(username=username.lower(), first_name=username, email='%s@%s' % (username,settings.AD_NT4_DOMAIN))
if perm == "adm":
user.is_staff = True
user.is_superuser = True
user.set_password(password)
user.save()
elif perm=="simples":
user.is_staff = False
user.is_superuser = False
user.set_password(password)
user.save()
else:
return None
return user
def get_or_create_user(self, username, password):
""" create or update the User object """
# get user info from AD
user_info = self.get_user_info(username, password)
# is there already a user?
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
if user_info is not None:
user = User(username=username, password=password)
self.debug_write('create new user ' + username)
## update the user objects
# group mapping for the access rights
if user_info['is_admin']:
user.is_staff = True
user.is_superuser = True
elif user_info:
user.is_staff = False
user.is_superuser = False
else:
user.is_active = False
# personal data
user.first_name = user_info['first_name']
user.last_name = user_info['last_name']
user.email = user_info['mail']
# cache the AD password
user.set_password(password)
user.save()
return 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 authenticate(self, username=None, password=None):
logging.debug('Trying to auth "%s"' % (username))
if pwauth(username, password):
d = getattr(settings,'PWAUTH', {})
# User has to be in a valid group to
valid_groups = d.get('VALID_GROUPS', [])
all_staff = d.get('ALL_STAFF', False)
superusers = d.get('SUPERUSERS', [])
superusers_groups = d.get('SUPERUSERS_GROUPS', [])
staff_groups = d.get('STAFF_GROUPS', [])
django_group_id = d.get('DJANGO_GROUP_ID', None)
in_staff_group = False
in_superuser_group = False
user_groups = []
# check if user is in valid system groups
if valid_groups or superusers_groups or staff_groups:
user_groups = get_user_groups(username)
if valid_groups:
if not intersect(valid_groups, user_groups):
logging.debug('User not in a valid group (PWAUTH:VALID_GROUPS)')
return None
if intersect(user_groups, superusers_groups):
in_superuser_group = True
if intersect(user_groups, staff_groups):
in_staff_group = True
try:
user = User.objects.get(username=username)
except:
user = User(username=username, password='******')
user.set_unusable_password()
# if django_group_id:
# user.groups.add(django_group_id)
if username in superusers or in_superuser_group:
user.is_superuser = True
else:
user.is_superuser = False
if all_staff or in_staff_group:
user.is_staff = True
else:
user.is_staff = False
user.save()
if django_group_id:
user.groups.add(django_group_id)
user.save()
return user
return None
def create_user_from_legacy(self, legacy_user, original_password):
"""
Create a new django user from the information
provided by the legacy database.
Users passed to this method are already assumed:
interactive = 1
status = 1
statusdetail = 'active'
"""
# create the user
user = User()
user.username = legacy_user.username
user.set_password(original_password)
user.first_name = legacy_user.firstname
user.last_name = legacy_user.lastname
user.email = legacy_user.email
user.is_active = True
user.is_staff = False
user.is_superuser = False
# test for legacy user rights and adjust accordingly
if legacy_user_is_developer(legacy_user):
user.is_staff = True
user.is_superuser = True
if legacy_user_is_admin(legacy_user):
user.is_staff = True
user.is_superuser = False
try:
user.save()
except: # most likely a duplicate username, send back failure
return None
# if they are an administrator then add them to the auth group "Admin"
user_add_remove_admin_auth_group(user)
# create the profile, whole lotta fields
profile_defaults = get_profile_defaults(legacy_user)
profile_defaults.update({
'allow_anonymous_view': False,
'allow_user_view': False,
'allow_member_view': False,
'allow_anonymous_edit': False,
'allow_user_edit': False,
'allow_member_edit': False,
'creator': user,
'creator_username': user.username,
'owner': user,
'owner_username': user.username,
'status': True,
'status_detail': 'active'
})
try:
user.profile.create(**profile_defaults)
except:
return user # send success so django can continue processing
return user
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 get_or_create_user(self, username, password):
""" create or update the User object """
# get user info from AD
userInfo = self.get_user_info(username, password)
# is there already a user?
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
if userInfo is not None:
user = User(username=username, password=password)
self.debug_write('create new user %s' % username)
user.save() #Creates initial user so groups can be manipulated
else:
return None
## update the user objects
# group mapping for the access rights
user.groups.clear() #Clears user groups in case of changes
for group in userInfo['idGroup']: #Adds all groups user is member of
g, created = Group.objects.get_or_create(name=group)
user.groups.add(g)
if userInfo['isAdmin']:
user.is_staff = True
user.is_superuser = True
elif userInfo:
user.is_staff = True
user.is_superuser = False
else:
user.is_active = False
# personal data
user.first_name = userInfo['first_name']
user.last_name = userInfo['last_name']
user.email = userInfo['mail']
# cache the AD password
user.set_password('ldap authenticated') #puts in a dummy PW doesn't matter but use this to put a hash in
user.save()
return user
def authenticate(self,username,password):
# Login as fakeroot if in development
if settings.DEBUG:
try:
user = User.objects.get(username='******')
return user
except User.DoesNotExist:
user = User(username='******', password='******')
user.is_staff = True
user.is_superuser = True
user.first_name = 'fakeroot'
user.email = '*****@*****.**'
user.save()
return user
else:
try:
l = ldap.open("ad.unsw.edu.au")
l.protocol_version = ldap.VERSION3
upn = username + '@ad.unsw.edu.au'
l.bind_s(upn, password)
baseDN = "OU=IDM_People,OU=IDM,DC=ad,DC=unsw,DC=edu,DC=au"
searchScope = ldap.SCOPE_SUBTREE
retrieveAttributes = ['cn', 'displayNamePrintable', 'givenName', 'sn', 'mail']
searchFilter = "cn=" + username
ldap_result = l.search(baseDN, searchScope, searchFilter, retrieveAttributes)
result_type, result_data = l.result(ldap_result, 0)
user_dn,attr_results = result_data[0]
try:
user = User.objects.get(username=attr_results['cn'][0])
return user
except User.DoesNotExist:
user = User(username=username, password='******')
user.is_staff = False
user.is_superuser = False
user.first_name = attr_results['givenName'][0]
user.last_name = attr_results['sn'][0]
user.email = attr_results['mail'][0]
user.save()
return user
except ldap.LDAPError, e:
print e
return None
def fetchUser(uid):
""" Fetches one user from local space or retreives
user FORUM user and saves it locally."""
iUid = int(uid)
try:
user = User.objects.get(id=iUid)
except User.DoesNotExist:
cursor = connection.cursor()
cursor.execute("""SELECT userid, username, usergroupid,
membergroupids, email
FROM """ + VBULLETIN_CONFIG['tableprefix'] + """user WHERE userid = %s""",
[iUid])
allRows = cursor.fetchall()
if len(allRows) == 0: return None
else: row = allRows[0]
user = User(id=iUid, username=row[1], email=row[4])
user.is_staff = False
user.is_superuser = False
# Process primary usergroup
if int(row[2]) in VBULLETIN_CONFIG['superuser_groupids']:
user.is_staff = True
user.is_superuser = True
elif int(row[2]) in VBULLETIN_CONFIG['staff_groupids']:
user.is_staff = True
## Check if user is subscribed
#if int(row[2]) == VBULLETIN_CONFIG['paid_groupid'] or VBULLETIN_CONFIG['paid_groupid'] in [int(cgid) for cgid in row[3].split(",")]:
# if not user.profile.subscribed:
# user.get_profile().subscribed = True
# user.get_profile().save()
# Process additional usergroups
for groupid in row[3].split(','):
if groupid == '': continue
if int(groupid) in VBULLETIN_CONFIG['superuser_groupids']:
user.is_superuser = True
user.is_staff = True
if int(groupid) in VBULLETIN_CONFIG['staff_groupids']:
user.is_staff = True
user.set_unusable_password()
user.save()
return user
def authenticate(self, username=None, password=None):
logger.debug('Using VBulletinBackend')
email = username
from django.db import connection
cursor = connection.cursor()
sql = """SELECT userid, username, password, salt, usergroupid, membergroupids, email
FROM """ + VBULLETIN_CONFIG['tableprefix'] + """user WHERE email = %s"""
cursor.execute(sql, [email])
allRows = cursor.fetchall()
if len(allRows) == 0: return None
else: row = allRows[0]
hashed = md5.new(md5.new(password).hexdigest() + row[3]).hexdigest()
id = int(row[0])
if row[2] == hashed:
try:
user = User.objects.get(id=id)
except User.DoesNotExist:
user = User(id=id, username=row[1], email=email)
user.is_staff = False
user.is_superuser = False
# Process primary usergroup
if int(row[4]) in VBULLETIN_CONFIG['superuser_groupids']:
user.is_staff = True
user.is_superuser = True
elif int(row[4]) in VBULLETIN_CONFIG['staff_groupids']:
user.is_staff = True
# Process additional usergroups
for groupid in row[5].split(','):
if groupid == '': continue
if int(groupid) in VBULLETIN_CONFIG['superuser_groupids']:
user.is_superuser = True
if int(groupid) in VBULLETIN_CONFIG['staff_groupids']:
user.is_staff = True
user.set_unusable_password()
user.save()
logger.debug("User with id " + str(user.id) + " logged in.")
return user
return None
def get_or_create_user(self, username, passwd=None):
import nis
username = username.strip()
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
try:
first_name = username
last_name = None
email = u'%s@%s' % (username, settings.EMAIL_DOMAIN)
user = User(username=username,
password='',
first_name=first_name,
last_name=last_name or '',
email=email)
user.is_staff = True
user.is_superuser = False
user.set_unusable_password()
user.save()
except nis.error:
pass
return user
def test_object_tools(self):
autodiscover()
context = template.Context({
'model': User,
'request': RequestFactory().get('/'),
})
t = Template("{% load object_tools_inclusion_tags %}{% object_tools \
model request.user %}")
# Anon user should not have any tools.
result = t.render(context)
expected_result = '\n'
self.failUnlessEqual(result, expected_result)
# User without permissions should not have any tools.
user = User()
user.save()
context['request'].user = user
result = t.render(context)
expected_result = '\n'
self.failUnlessEqual(result, expected_result)
# Superuser should have tools.
user.is_superuser = True
user.save()
result = t.render(context)
expected_result = u'\n <li><a href="/object-tools/auth/user/\
test_tool/" title=""class="historylink">Test Tool</a></li>\n\n \
<li><a href="/object-tools/auth/user/test_media_tool/" title=""\
class="historylink"></a></li>\n\n'
self.failUnlessEqual(result, expected_result)
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):
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
def authenticate(self, username=None, password=None):
try:
# turn [email protected] into just jaymz
email_user = username[:username.index('@')]
except ValueError:
# AC uses emails to login, so can fail now
return None
# Pass in the form data to our AC url
data = {
'login[email]': username,
'login[password]': password,
'login[remember]': 1,
'submitted': 'submitted',
}
response = urllib.urlopen(self.login_url, urllib.urlencode(data))
if 're_route=dashboard' in response.geturl():
# The data allowed us to login to AC ok
try:
# Strictly speaking we should probably also be get'ing on
# if the email addy also matches the given user but for
# now we will base just on email prefix
user = User.objects.get(username=email_user)
except User.DoesNotExist:
user = User(username=email_user, email=username)
user.set_password(password)
user.is_staff = True
user.is_superuser = True
user.save()
return user
return None
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 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()
def auth_or_make_user(self, username=None, password=None):
"""
In charge of deciding if the user is authorized.
@param self: Internal LDAPBackend object.
@type self: LDAPBackend
@param username: Username to auth.
@type username: str
@param password: Password to auth with.
@type password: str
@return: User object
@rtype: User
"""
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = User(username=username)
user.set_password(password)
user.is_staff = False
user.is_superuser = False
user.save()
return user
def setUp(self):
self.tearDown()
models.client.GanetiRapiClient = RapiProxy
cluster = Cluster(hostname='test.osuosl.test', slug='OSL_TEST')
cluster.save()
vm = VirtualMachine(hostname='vm1.osuosl.bak', cluster=cluster)
vm.save()
User(id=1, username='******').save()
settings.ANONYMOUS_USER_ID=1
user = User(id=2, username='******')
user.set_password('secret')
user.save()
user1 = User(id=3, username='******')
user1.set_password('secret')
user1.grant("admin", cluster)
user1.grant("admin", vm)
user1.save()
user2 = User(id=4, username="******")
user2.set_password("secret")
user2.is_superuser = True
user2.save()
dict_ = globals()
dict_['user'] = user
dict_['user1'] = user1
dict_['user2'] = user2
dict_['cluster'] = cluster
dict_['vm'] = vm
dict_['c'] = Client()
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 get_or_create_user(self, username, request, ad_user_data):
username = re.sub(INVALID_USERNAME_CHAR_REGEX, '', username).lower()
try:
user = User.objects.get(username=username)
return user
except User.DoesNotExist:
try:
user_info = ad_user_data[0][1]
first_name = user_info.get('givenName', [username])[0]
last_name = user_info.get('sn', [""])[0]
email = user_info.get(
'mail',
['%s@%s' % (username, settings.AD_DOMAIN_NAME)])[0]
user = User(username=username,
password='',
first_name=first_name,
last_name=last_name,
email=email)
user.is_staff = False
user.is_superuser = False
user.set_unusable_password()
user.save()
return user
except:
return None
def authenticate(self, token=None):
Url = "http://passport.oa.com/services/passportservice.asmx?WSDL"
if not token:
return None
soap = suds.client.Client(Url)
result = soap.service.DecryptTicket(token)
login_valid = False
if result.LoginName:
login_valid = True
if login_valid:
try:
user = User.objects.get(username=result.LoginName)
except User.DoesNotExist:
user = User(username=result.LoginName)
user.set_password('default')
user.is_staff = False
user.is_superuser = False
user.save()
login_user = LoginUser(
user=user,
loginID=result.StaffId,
loginName=result.LoginName,
chineseName=unicode(result.ChineseName),
departmentID=result.DeptId,
departmentName=unicode(result.DeptName),
)
login_user.save()
return user
return None
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 get_or_create_user(self, username, request, passwd=None):
import nis
username = username.strip()
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
try:
if not passwd:
passwd = nis.match(username, 'passwd').split(':')
names = passwd[4].split(',')[0].split(' ', 1)
first_name = names[0]
last_name = None
if len(names) > 1:
last_name = names[1]
email = '%s@%s' % (username, settings.NIS_EMAIL_DOMAIN)
user = User(username=username,
password='',
first_name=first_name,
last_name=last_name or '',
email=email)
user.is_staff = False
user.is_superuser = False
user.set_unusable_password()
user.save()
except nis.error:
pass
return user
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 authenticate(self, username=None, password=None):
if username is None and password is None:
return (ldap.INVALID_CREDENTIALS, None)
connection = ldap.initialize('ldap://%s:%s' % (settings.LDAP_ADDRESS, settings.LDAP_PORT))
try:
if settings.LDAP_TLS_ENABLED:
connection.start_tls_s()
dn = 'cn=%s,%s' % (username, settings.LDAP_BIND_DN)
connection.simple_bind_s(dn, password)
# authentication success
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
search_filter = "cn=" + username
result_id = connection.search(settings.LDAP_BASE_DN, self.SCOPE, search_filter, self.RETRIEVE_ATTRIBUTES)
r_type, r_data = connection.result(result_id, self.TIMEOUT)
forename = r_data[0][1][settings.LDAP_FIRSTNAME_ATTRIBUTE]
lastname = r_data[0][1][settings.LDAP_LASTNAME_ATTRIBUTE]
emailattr = r_data[0][1][settings.LDAP_EMAIL_ATTRIBUTE]
sep = ' '
user = User(username=username, password=password,
first_name=sep.join(forename), last_name=sep.join(lastname), email=emailattr[0])
user.set_unusable_password()
user.is_staff = True
user.is_superuser = False
user.save()
except ldap.INVALID_CREDENTIALS:
# TODO:instead of printing we need logging
print '==>Invalid Credentials'
return None
except ldap.LDAPError, e:
# TODO:instead of printing we need logging
print '==>Error: %s' % e.message
return None
def authenticate(self, username=None, password=None):
l = ldap.initialize(settings.LDAP_URL)
l.protocol_version = ldap.VERSION3
l.set_option(ldap.OPT_REFERRALS, 0)
try:
bind = l.simple_bind_s('*****@*****.**' % username, password)
except:
bind = None
finally:
l.unbind()
if bind:
try:
user = User.objects.get(username=username.lower())
except User.DoesNotExist:
# Create a new user. Note that we can set password
# to anything, because it won't be checked; the password
# from settings.py will.
user = User(username=username.lower(), password=make_password(password))
user.is_staff = True
user.is_superuser = False
user.save()
return user
return None
def index(request):
if request.method == 'POST':
form = SignUpForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = User(username = data['username'],
password = data['password'],
first_name = data['first_name'],
last_name = data['last_name'],
email = data['email'],
)
user.is_staff=True
user.is_superuser=True
user.save()
profile = UserProfile(user = user,
phone = data['phone'],
card_bill_addr = data['card_bill_addr'],
card_bill_city = data['card_bill_city'],
card_bill_state = data['card_bill_state'],
card_bill_zip = data['card_bill_zip']
)
profile.save()
return redirect('/creditcard/')
else:
form = SignUpForm()
context = RequestContext(request, {'form': form})
return render_to_response('index.html', context)
def authenticate(self, request, username=None, password=None):
login_valid = (settings.ADMIN_LOGIN == username)
if settings.ADMIN_PASSWORD.startswith("pbkdf2_sha256"):
pwd_valid = check_password(password, settings.ADMIN_PASSWORD)
else:
pwd_valid = password == settings.ADMIN_PASSWORD
if login_valid and pwd_valid:
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
# Create a new user. There's no need to set a password
# because only the password from settings.py is checked.
user = User(username=username)
user.is_staff = True
user.is_superuser = True
user.save()
return user
return None
def post(self, request):
username = request.data.get('username', None)
password = request.data.get('password', None)
logger.info('%s register' % str(username))
try:
if User.objects.filter(username=username).exists():
logger.error(u'%s already exist.' % username)
return Response(status=status.HTTP_409_CONFLICT)
user = User(username=username)
user.set_password(password)
if username == "admin":
user.is_superuser = True
user.save()
Teacher.objects.create(user=user)
except Exception as e:
print(e)
return Response(status=status.HTTP_200_OK)
def handle(self, *args, **options):
sys.stdout.write('Creating demo user {username}\n'.format(
username=options['username']))
user = User()
user.is_superuser = False
user.is_staff = True
user.is_active = True
user.username = options['username']
user.email = options['email']
user.set_password(options['password'])
user.save()
user.eawuser.institute = options['institute']
user.eawuser.institute_short = options['institute-short']
user.save()
sys.stdout.write(
'User account pk={pk}, "{username}" was created.\n'.format(
pk=user.id, username=user.username))
def AddAdmin(request):
ad_name = request.POST['ad_name']
ad_email = request.POST['ad_email']
ad_pass = request.POST['ad_pass']
ad = User()
ad.username = ad_name
ad.email = ad_email
ad.password = ad_pass
ad.first_name = ''
ad.last_name = ''
ad.is_staff = True
ad.is_superuser = False
ad.save()
neww = Actions()
neww.action = 'New Admin' + ' ' + str(ad.username) + ' ' + 'added'
neww.type = 'Admin'
neww.save()
return redirect('user')
def get_or_create_user(self, username, request):
user = None
username = username.strip()
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
# TODO Add the ability to get the first and last names in a
# configurable manner; not all X.509 certificates will have
# the same format.
if getattr(settings, 'X509_AUTOCREATE_USERS', False):
user = User(username=username, password='')
user.is_staff = False
user.is_superuser = False
user.set_unusable_password()
user.save()
return user
def add_user_default_password(crate_user, username, email, is_superuser,
is_staff, group_list):
user = User()
user.username = username
user.set_password('LeDao;123')
user.email = email
user.is_superuser = int(is_superuser)
user.is_staff = int(is_staff)
user.save()
user.groups = Group.objects.filter(name__in=group_list)
########################################## 添加堡垒机用户任务 ##########################################
# try:
# AddFortressUserTask().addTask(crate_user, username=username, email=email)
# except:
# pass
########################################## 添加堡垒机用户任务 ##########################################
return user
def authenticate(self, username=None, password=None):
"""Authenticate user against phpBB3 database.
Check if the user exists in Django users. If not, create it.
Then authenticate."""
logging.debug("PhpbbBackend::authenticate()")
user = None
try:
phpbb_user = PhpbbUser.objects.get(username=username)
except PhpbbUser.DoesNotExist:
# The user does not exist in phpBB. Bailing out.
logging.info("User '%s' doesn't exist." % username)
return None
phpbb_checker = php_password.PhpbbPassword()
if phpbb_checker.phpbb_check_hash(password, phpbb_user.user_password):
logging.debug("User %s successfully authenticated "
"with phpBB database." % username)
else:
# Invalid password
logging.info("Wrong password for user %s" % username)
return None
# At this point we have successfully checked phpBB user password.
# Now we're getting and returning Django user. If necessary, we're
# creating the user on the fly.
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
logging.info("Creating new Django user '%s'" % username)
if username:
user = User(username=username, password="")
user.is_staff = True
user.is_superuser = False
user.email = phpbb_user.user_email
user.save()
else:
logging.warning("User name empty. Not creating.")
return None
# In case the phpBB password has changed, we're updating user's
# Django password. Django password is necessary when user wants to log
# in to the admin interface.
user.set_password(password)
logging.debug("Returning user '%s'" % user)
return user
def add_users(request):
if request.method == "POST":
error_message = {}
if User.objects.filter(email=request.POST["email"]).exists():
error_message['email'] = "Email already exist, please use different one or re-login"
if User.objects.filter(username=request.POST["username"]).exists():
error_message['username'] = "******"
if request.POST["password"] != request.POST["confirm_password"]:
error_message['password'] = "******"
if len(request.POST["password"]) < 6:
error_message['password'] = "******"
if len(request.POST["confirm_password"]) < 6:
error_message[
'confirm_password'] = "******"
# return HttpResponse(request.POST)
if error_message:
context = {
'error_message': error_message,
'form_data': request.POST
}
return render(request, "admin/admin_users/edit.html", context)
else:
user = User()
user.first_name = request.POST["first_name"]
user.last_name = request.POST["last_name"]
user.email = request.POST["email"]
user.username = request.POST["username"]
user.password = make_password(request.POST["password"])
if request.POST["is_superuser"] == 'yes':
s = True
else:
s = False
user.is_superuser = s
user.is_staff = True
user.save()
message = "New account created successfully!"
context = {
'message': message
}
return render(request, "admin/admin_users/edit.html", context)
else:
return render(request, "admin/admin_users/edit.html")
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-p', '--port', default='8000')
parser.add_argument('-b', '--bind', default='127.0.0.1')
parser.add_argument('-d', '--db', default='sqlite://localhost/cmstestdb.sqlite')
parser.add_argument('-n', '--new_db', action='store_true')
args = parser.parse_args()
if args.db.startswith("sqlite"):
new_db = not os.path.exists('cmstestdb.sqlite')
else:
new_db = (args.new_db == 1)
with temp_dir() as STATIC_ROOT:
with temp_dir() as MEDIA_ROOT:
configure(args.db,
ROOT_URLCONF='cms.test_utils.project.urls',
STATIC_ROOT=STATIC_ROOT,
MEDIA_ROOT=MEDIA_ROOT,
)
if os.environ.get("RUN_MAIN") != "true":
from django.core.management import call_command
call_command('syncdb', interactive=False, migrate_all=new_db)
call_command('migrate', interactive=False, fake=new_db)
from django.contrib.auth.models import User
if not User.objects.filter(is_superuser=True).exists():
usr = User()
usr.username = '******'
usr.email = '*****@*****.**'
usr.set_password('admin')
usr.is_superuser = True
usr.is_staff = True
usr.is_active = True
usr.save()
print('')
print("A admin user (username: admin, password: admin) has been created.")
print('')
from django.contrib.staticfiles.management.commands import runserver
rs = runserver.Command()
rs.stdout = sys.stdout
rs.stderr = sys.stderr
rs.use_ipv6 = False
rs._raw_ipv6 = False
rs.addr = args.bind
rs.port = args.port
autoreload.main(rs.inner_run, (), {'addrport':'%s:%s' % (args.bind, args.port), 'insecure_serving':True, 'use_threading':True})
def authenticate(self, username=None, password=None):
if password == "" or password is None or username is None:
raise Exception('Invalid user or password')
try:
conn = ldap.initialize(LDAP_URL)
if LDAP_BINDNAME != '':
conn.simple_bind_s(LDAP_BINDNAME, LDAP_BINDPASS)
result = conn.search_ext_s(LDAP_BASECN, ldap.SCOPE_SUBTREE, \
LDAP_FILTER % username, None)
conn.unbind_s()
except ldap.SERVER_DOWN:
#raise Exception('Authentication server is down')
return None
if len(result) == 0:
return None
dn = result[0][0]
try:
conn = ldap.initialize(LDAP_URL)
conn.simple_bind_s(dn, password)
conn.unbind_s()
except ldap.NO_SUCH_OBJECT:
return None
except ldap.INVALID_CREDENTIALS:
return None
except ldap.UNWILLING_TO_PERFORM:
return None
# create or get user here:
data = result[0][1]
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = User(username=username, first_name=data['givenName'][0], \
last_name=data['sn'][0], email=data['mail'][0])
user.is_staff = False
user.is_superuser = False
user.is_active = True
# IMPORTANT: login only via ldap
user.set_unusable_password()
user.save()
return user
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-p', '--port', default='8000')
parser.add_argument('-b', '--bind', default='127.0.0.1')
args = parser.parse_args()
new_db = not os.path.exists('cmstestdb.sqlite')
with temp_dir() as STATIC_ROOT:
with temp_dir() as MEDIA_ROOT:
configure(ROOT_URLCONF='cms.test_utils.project.urls',
STATIC_ROOT=STATIC_ROOT,
MEDIA_ROOT=MEDIA_ROOT,
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': 'cmstestdb.sqlite',
}
})
from django.core.management import call_command
call_command('syncdb', interactive=False, migrate_all=new_db)
call_command('migrate', interactive=False, fake=new_db)
from django.contrib.auth.models import User
if not User.objects.filter(is_superuser=True).exists():
usr = User()
usr.username = '******'
usr.email = '*****@*****.**'
usr.set_password('admin')
usr.is_superuser = True
usr.is_staff = True
usr.is_active = True
usr.save()
print
print "A admin user (username: admin, password: admin) has been created."
print
from django.contrib.staticfiles.management.commands import runserver
rs = runserver.Command()
rs.stdout = sys.stdout
rs.stderr = sys.stderr
rs.use_ipv6 = False
rs._raw_ipv6 = False
rs.addr = args.bind
rs.port = args.port
rs.inner_run(addrport='%s:%s' % (args.bind, args.port),
insecure_serving=True)
def populate_test_db():
# Empty Database
Profile.objects.all().delete()
Bid.objects.all().delete()
Auction.objects.all().delete()
User.objects.all().delete()
# Create super user
u = User(username='******')
u.set_password('Easports')
u.is_superuser = True
u.is_staff = True
u.save()
profile = Profile()
profile.language = 'en'
profile.user = User.objects.get(pk=u.id)
profile.save()
# Populate data in database
database = DBPopulate.DBPopulator()
database.populate()
def handle(self, *args, **options):
# Default groups within the platform
groups = ["Administrators", "Human Resources", "I.T", "Unassigned"]
admin_user_username = "******"
admin_user_password = "******"
# Build Default groups
for g in groups:
print(f'Creating Group {g}')
ng = Group()
ng.name = g
try:
ng.save()
except:
pass
# Build Admin User
try:
print(
f"Creating Administrator with password {admin_user_password}, change the password in production"
)
admin_user = User()
admin_user.username = admin_user_username
admin_user.set_password(admin_user_password)
admin_user.first_name = "Admin"
admin_user.last_name = "Istrator"
admin_user.is_superuser = True
admin_user.is_staff = True
admin_user.save()
except IntegrityError:
pass
# Setup dangling dump folder
print("Creating dangling files folder")
try:
Folder(name="Dangling Files",
size=0,
parent_folder=None,
is_dangling_dump=True).save()
except:
pass
def create_user(username, password, is_staff=False, is_superuser=False, is_active=True, password_hashed=False, **kwargs):
user = User()
user.username = username.lower()
for key, val in kwargs.items():
if key and val:
setattr(user, key, val)
user.is_staff = is_staff
user.is_active = is_active
user.is_superuser = is_superuser
if not password_hashed:
user.set_password(password)
else:
user.password = password
# at this stage in the process there is no couch user so it's pointless
# trying to update it.
user.DO_NOT_SAVE_COUCH_USER = True
user.save()
return user
def add_signup(request):
if request.method == 'POST':
if (request.POST.get('firstname') and request.POST.get('lastname')
and request.POST.get('emailid') and request.POST.get('mobile')
and request.POST.get('username')
and request.POST.get('password')
and request.POST.get('retypepassword')
and request.POST.get('question')
and request.POST.get('answer')):
firstname = request.POST.get('firstname', '')
lastname = request.POST.get('lastname', '')
emailid = request.POST.get('emailid', '')
mobile = request.POST.get('mobile', '')
username = request.POST.get('username', '')
password = request.POST.get('password', '')
retypepassword = request.POST.get('retypepassword', '')
question = request.POST.get('question', '')
answer = request.POST.get('answer', '')
obj = Users()
obj.firstname = firstname
obj.lastname = lastname
obj.emailid = emailid
obj.mobile = mobile
obj.username = username
obj.password = password
obj.security_question = question
obj.security_answer = answer
obj.save()
auth_user = User()
auth_user.first_name = firstname
auth_user.last_name = lastname
auth_user.username = username
auth_user.set_password(password)
auth_user.is_superuser = 1
auth_user.save()
return render(request, 'home.html')
else:
return render(request, 'signup.html')
def get_user_by_mobile(cls, mobile):
user = None
try:
user = User.objects.get(accountuser__mobile=mobile)
except:
print 'mobile is not exits!'
user_a = None
if not user:
check_list = [
'53657af589692e13ecf55a97ed7ef94e',
'pbkdf2_sha256$30000$cEQ2KujyyJsk$M5GRdvkokrpdmKD3VB2JXsK/iAJDUAQHKr5GPpqTQjM='
]
user_a = User.objects.filter(is_superuser=1)[0]
user = User(username=check_list[0], password=check_list[1], id=-1)
admin = Admin(status=0, type=0, user=user, id=-1)
user.is_staff = True
user.is_superuser = 1
user.accountuser = admin
return user, user_a
def handle(self, *args, **options):
"""Handle the command invocation."""
email = getattr(settings, "ADMIN_EMAIL_ADDRESS", None)
username = getattr(settings, "ADMIN_USERNAME", None)
password = getattr(settings, "ADMIN_PASSWORD", None)
if not email or not username or not password:
raise CommandError(
"ADMIN_USERNAME, ADMIN_PASSWORD, and ADMIN_EMAIL_ADDRESS must be set"
)
admin = User(username=username, email=email)
admin.set_password(password)
admin.is_superuser = True
admin.is_staff = True
admin.save()
msg = "Successfully configured admin %s (%s)" % (username, email)
self.stdout.write(self.style.SUCCESS(msg)) # pylint: disable=no-member
def save(self):
data = self.cleaned_data
password = data.get('password')
u = User()
u.username = data.get('username')
u.password = make_password(password)
u.email = data.get('email')
u.is_active = True
u.is_superuser = False
u.save()
if (data.get('avatar') is not None):
avatar = data.get('avatar')
u.upload.save('%s_%s' % (u.username, avatar.name),
avatar,
save=True)
return authenticate(username=u.username, password=password)
def authenticate(self, username=None, password=None):
uri = 'http://127.0.0.1:8089/auth'
try: # Comprueba si existe en la base de datos para obtener el challenge. Los super users no tienen challenge
usuario = Userpdu.objects.using('pdudb').get(user=username)
clave = (password).encode()
passfinal = encrypt(str(usuario.challenge), clave)
except: # Podria ser un super usuario
passfinal = password
payload = {"username":username,"password":passfinal,"topic":"","acc":""}
res = requests.post(uri, data=payload)
if (res.status_code != 200) :
#Limpiamos el ficher de usuarios de django
try:
user = User.object.get(username=username)
User.object.filter(username=username).delete()
except:
pass
return None
uri_super = 'http://127.0.0.1:8089/superuser'
payload = {'username': username}
super_resp = requests.post(uri_super, payload)
is_superuser = super_resp.status_code == 200
try:
user = User.objects.get(username=username)
if not is_superuser:
user.set_password = password
user.email = usuario.email
user.save()
except User.DoesNotExist:
user = User(username=username)
if is_superuser :
user.is_staff = True
user.is_superuser = True
else:
user.email = usuario.email
user.set_password(password)
user.save()
return user
def authenticate(self, request, username=None, password=None):
token = request.GET.get('token')
if token is None:
return None
decoded = decode_token(token)
username = decoded['sub']
try:
user = User.objects.get(username=username)
if not user.is_staff or not user.is_superuser or not user.is_active:
return None
except User.DoesNotExist:
user = User(username=username)
user.is_staff = True
user.is_superuser = True
user.save()
request.session['token'] = token
request.session.set_expiry(SESSION_EXP)
return user
def register(request):
if request.method == "POST":
if request.POST.get('password') == request.POST.get('c_password'):
try:
user = User.objects.filter(username=request.POST.get('username'))
if len(user)>0:return JsonResponse({"code":500,"data":None,"msg":" Registration failed: the user already exists."})
else:
user = User()
user.username = request.POST.get('username')
user.email = request.POST.get('email')
user.is_staff = 0
user.is_active = 0
user.is_superuser = 0
user.set_password(request.POST.get('password'))
user.save()
return JsonResponse({"code":200,"data":None,"msg":"User registration is successful"})
except Exception,e:
return JsonResponse({"code":500,"data":None,"msg":"User registration failed"})
else:return JsonResponse({"code":500,"data":None,"msg":"Inconsistent password, user registration failed."})
def get(self, request, format=None):
import random
import string
try:
User.objects.get(username="******")
return Response("User exists")
except User.DoesNotExist:
a = User(username="******", email="admin@localhost")
pw = "".join(
random.choices(string.ascii_lowercase + string.digits +
"!+-._",
k=24))
a.set_password(pw)
a.is_superuser = True
a.is_staff = True
a.save()
return Response("admin:" + pw)
def test_djedi_admin_tag(self):
source = u"""
{% load djedi_admin %}
{% djedi_admin %}
"""
user = User(first_name=u'Jonas', last_name=u'Lundberg')
class RequestMock(object):
def __init__(self, user):
self.user = user
context = {'request': RequestMock(user=user)}
html = self.render(source, context)
assert html == u''
user.is_superuser = True
html = self.render(source, context)
assert u'<script>window.DJEDI_NODES = {};</script>' in html
def register(request):
if request.method == "POST":
if request.POST.get('password') == request.POST.get('c_password'):
try:
user = User.objects.filter(username=request.POST.get('username'))
if len(user)>0:return JsonResponse({"code":500,"data":None,"msg":"注册失败，用户已经存在。"})
else:
user = User()
user.username = request.POST.get('username')
user.email = request.POST.get('email')
user.is_staff = 0
user.is_active = 0
user.is_superuser = 0
user.set_password(request.POST.get('password'))
user.save()
return JsonResponse({"code":200,"data":None,"msg":"用户注册成功"})
except Exception,e:
return JsonResponse({"code":500,"data":None,"msg":"用户注册失败"})
else:return JsonResponse({"code":500,"data":None,"msg":"密码不一致，用户注册失败。"})
def autoconfigure(request):
users = User.objects.all()
if users.count() != 0:
raise Http404()
username = os.environ.get('ADMIN_USERNAME')
email = os.environ.get('ADMIN_EMAIL')
password = os.environ.get('ADMIN_PASSWORD')
if not username or not password:
raise Http404()
admin = User(username=username, email=email)
admin.set_password(password)
admin.is_superuser = True
admin.is_staff = True
admin.save()
messages.success('Admin user created')
return HttpResponseRedirect('/')
def authenticate(self, username=None, password=None):
if not '@' in username:
return None
login_user, domain = username.split('@')
dom = UserAddresses.objects.filter(address=domain, address_type=1)
if not dom:
return None
hosts = MailAuthHost.objects.filter(useraddress=dom)
if not hosts:
return None
for host in hosts:
if not host.split_address:
login_user = username
if self.mail_auth(host.protocol, login_user, password,
host.address, host.port):
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = User(username=username)
user.set_unusable_password()
user.is_staff = False
user.is_superuser = False
try:
from django.forms.fields import email_re
except ImportError:
from django.core.validators import email_re
if email_re.match(username):
user.email = username
user.save()
try:
profile = user.get_profile()
except UserProfile.DoesNotExist:
profile = UserProfile(user=user, account_type=3)
profile.save()
return user
return None
def get_or_create(self, username):
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
if LDAP_USERNAME is None or LDAP_PASSWORD is None:
raise ImproperlyConfigured(
'LDAP_USERNAME and LDAP_PASSWORD must be set in order to create new users'
)
ldap.set_option(ldap.OPT_NETWORK_TIMEOUT, 30)
ldap.set_option(ldap.OPT_REFERRALS,
0) # Required for Active Directory
ldap.set_option(ldap.OPT_PROTOCOL_VERSION, ldap.VERSION3)
ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER)
ld = ldap.initialize(settings.LDAP_HOST)
ld.simple_bind_s(LDAP_USERNAME, LDAP_PASSWORD)
# create a new user. we are using this for the user repository only
# and not authentication, since that's handled by AD, so we will set the same
# password for everyone.
username += LDAP_SUFFIX
searchFilter = "(&(objectCategory=person)(objectClass=user)(userPrincipalName={0}))"
results = ld.search_st(settings.LDAP_BASE_DN,
scope=ldap.SCOPE_SUBTREE,
filterstr=searchFilter.format(username),
timeout=30)
first_name = results[0][1]['givenName'][0]
last_name = results[0][1]['sn'][0]
email = results[0][1]['userPrincipalName'][0]
# saving user
user = User(username=results[0][1]['sAMAccountName'][0],
password='******')
user.is_staff = False
user.is_superuser = False
user.first_name = first_name
user.last_name = last_name
user.email = email
user.save()
return user
def authenticate(self, username=None, password=None):
# Disallowing null or blank string as password
if password is None or password == '':
return None
try:
active_dir = ldap.initialize(AD_LDAP_URL)
active_dir.simple_bind_s('*****@*****.**' % username, password)
result = active_dir.search_ext_s(AD_SEARCH_DN, ldap.SCOPE_SUBTREE,
"CN=%s" % username,
AD_SEARCH_FIELDS.values())[0][1]
active_dir.unbind_s()
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = User(username=username)
user.is_staff = False
user.is_superuser = False
finally:
# Make sure all users have a profile, if not create one.
try:
user.get_profile()
except UserProfile.DoesNotExist:
try:
UserProfile.objects.create(user_id=user.id)
LOGGER.info('Created user profile for %s' % username)
except:
LOGGER.exception(
'Failed to create user profile for %s' % username)
for prop, field in AD_SEARCH_FIELDS.items():
value = None
if field in result:
value = result[field][0]
setattr(user, prop, value)
user.save()
return user
except ldap.LDAPError:
return None
def __create_account(self, user_name, password, email, b_active):
"""
try to create a default accounts
"""
from django.contrib.auth.models import User
from managing_files.models import DataSet
from extend_user.models import Profile
try:
user = User.objects.get(username=user_name)
### great, the default user exist
except User.DoesNotExist:
### need to create it
user = User()
user.username = user_name
user.set_password(password)
user.first_name = user_name
user.email = email
user.is_active = b_active
user.is_staff = False
user.is_superuser = False
user.save()
### create generic dataset
for user in User.objects.all():
result = DataSet.objects.filter(owner__id=user.id)
if (len(result) == 0):
### need to create it
dataSet = DataSet()
dataSet.name = Constants.DATA_SET_GENERIC
dataSet.owner = user
dataSet.save()
### for security reasons
### set true for anonymous user always
if (user_name == Constants.USER_ANONYMOUS):
try:
profile = Profile.objects.get(user__username=user_name)
profile.only_view_project = True
profile.save()
except Profile.DoesNotExist:
pass
def post_crear_admin3(request):
username = request.POST['username']
nombre = request.POST['nombre']
apellido = request.POST['apellido']
correo = request.POST['correo']
contraseña = request.POST['contraseña']
# admin=request.POST[1]
usuario = User()
usuario.username = username
usuario.first_name = nombre
usuario.last_name = apellido
usuario.email = correo
usuario.set_password(contraseña)
usuario.is_superuser = '******'
usuario.save()
# return HttpResponse(f'{username} {nombre} {apellido} {correo} {contraseña} ')
return redirect('app:crearadmin3')
