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 save(self, commit=True):
if not self.edit:
persona = super(PersonaForm, self).save(commit=False)
nUsuario = User()
nUsuario.username = persona.identificacion
nUsuario.first_name = persona.nombre
nUsuario.last_name = persona.apellido
nUsuario.email = persona.email
contrase = Util.contrasena_aleatoria()
nUsuario.set_password(contrase)
nUsuario.save()
persona.usuario = nUsuario
persona.edad = Util.getEdad(persona.fechaNacimiento)
self.personaServicio.insert(persona)
correoUtil=CorreoUtil()
correoUtil.correoCreacionEmpleado(persona.identificacion, contrase, persona)
else:
persona = super(PersonaForm, self).save(commit=False)
persona.edad = Util.getEdad(persona.fechaNacimiento)
nUsuario = persona.usuario
nUsuario.first_name = persona.nombre
nUsuario.last_name = persona.apellido
nUsuario.email = persona.email
self.personaServicio.update(persona)
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 setUp(self):
django.setup()
testuser1 = User()
testuser1.username = '******'
testuser1.password = '******'
testuser1.email = '*****@*****.**'
testuser1.save()
testuser2 = User()
testuser2.username = '******'
testuser2.password = '******'
testuser2.email = '*****@*****.**'
testuser2.save()
restoA = RestoModel()
restoA.nom = 'A'
restoA.save()
restoB = RestoModel()
restoB.nom = 'B'
restoB.save()
restoC = RestoModel()
restoC.nom = 'C'
restoC.save()
def authenticate(self, username=None, password=None):
result = xmlrpc.call('authenticate', username, password)
if result:
try:
# user exists so, we update the password
user = User.objects.get(username=username)
user.set_password(password)
user.save()
except User.DoesNotExist:
# check if there is no other my account in DB
if not username == "root" and len(User.objects.exclude(username="******")) > 0:
return None
# create a new django user
user = User(username=username)
user.is_staff = False
user.is_superuser = False
if username == 'root':
user.email = 'root@localhost'
else:
user.email = username
user.set_password(password)
user.save()
return user
# bad password
else:
return None
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 create_user(name, email=None, password=None, first_name=None, last_name=None):
user = User()
user.username = name
user.first_name = first_name or ""
user.last_name = last_name or ""
user.set_password(password or '1')
if email:
user.email = email
else:
user.email = name + '@' + name
user.save()
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 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 register(request):
form_data = request.POST.copy()
form = RegistrationForm(form_data)
errors = form.errors
print request.POST
print form.errors
if errors:
return render_to_response('login.html', {'form': form})
# logout the existing user
if (isinstance (request.user, AnonymousUser)):
u = None
else:
u = request.user
logout(request)
email = request.POST['register_email']
password = request.POST['register_password']
try:
u = User(username=email)
u.set_password(password)
u.email = email
u.save()
except:
return render_to_response('login.html', {'form': form})
response = render_to_response('login.html', {'registration_status': "Registered successfully! Now you can login with your credentials!" })
return response
def authenticate(self, linkedin_access_token, user=None):
linkedin = LinkedIn(LINKEDIN_CONSUMER_KEY, LINKEDIN_CONSUMER_SECRET)
# get their profile
profile = ProfileApi(linkedin).getMyProfile(access_token=linkedin_access_token)
try:
user_profile = LinkedInUserProfile.objects.get(linkedin_uid=profile.id)
user = user_profile.user
return user
except LinkedInUserProfile.DoesNotExist:
# Create a new user
username = "******" % profile.id
if not user:
user = User(username=username)
user.first_name, user.last_name = (profile.firstname, profile.lastname)
user.email = "%s@socialauth" % (username)
user.save()
userprofile = LinkedInUserProfile(user=user, linkedin_uid=profile.id)
userprofile.save()
auth_meta = AuthMeta(user=user, provider="LinkedIn").save()
return user
def authenticate(self, access_token):
'''authenticates the token by requesting user information from twitter
'''
twitter = oauthtwitter.OAuthApi(TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET, access_token)
try:
userinfo = twitter.GetUserInfo()
except:
# If we cannot get the user information, user cannot be authenticated
raise
screen_name = userinfo.screen_name
try:
user = User.objects.get(username = '******'%screen_name )
return user
except User.DoesNotExist:
user = User(username = '******'%screen_name)
temp_password = User.objects.make_random_password(length=12)
user.set_password(temp_password)
user.first_name = userinfo.name
user.email = '%s@twitteruser.%s.com'%(userinfo.screen_name, settings.SITE_NAME)
user.save()
userprofile = TwitterUserProfile(user = user)
userprofile.access_token = access_token.key
userprofile.url = userinfo.url
userprofile.location = userinfo.location
userprofile.description = userinfo.description
userprofile.profile_image_url = userinfo.profile_image_url
userprofile.save()
auth_meta = AuthMeta(user=user, provider='Twitter').save()
return user
def admin_reader_add(request):
if request.method == 'POST':
# Handle form submission.
form = ReaderForm(request.POST) # Initialize form with data.
if form.is_valid():
# First create a new User object.
user = User()
# Process the data in form.cleaned_data
user.email = form.cleaned_data['email']
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.username = form.cleaned_data['username']
user.password = make_password(form.cleaned_data['password'])
user.save()
# New create a reader object.
reader = Reader()
reader.user = user
reader.address = form.cleaned_data['address']
reader.phone_number = form.cleaned_data['phone_number']
reader.save()
return HttpResponseRedirect(reverse('admin_reader')) # Redirect after POST
else:
form = ReaderForm() # An unbound form
return render(request, 'library/admin_reader_add.html', {
'form': form,
})
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 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 authenticate(self, username=None, password=None):
if pam.authenticate(username, password, settings.PAM_SERVICE):
try:
user = User.objects.get(username=username)
user.set_password(password)
user.save()
except User.DoesNotExist:
user = User(username=username, password=password)
user.save()
if settings.USE_LDAP:
import ldap
l = ldap.initialize(settings.LDAP_HOST)
l.set_option(ldap.OPT_REFERRALS, 0)
l.set_option(ldap.OPT_PROTOCOL_VERSION, 3)
l.simple_bind_s(settings.LDAP_BIND_DN, settings.LDAP_BIND_PASS)
r = l.search(settings.LDAP_SEARCH_PATH, ldap.SCOPE_ONELEVEL, "(uid=%s)" % username,
[settings.LDAP_FIRST_NAME, settings.LDAP_LAST_NAME, settings.LDAP_EMAIL,
settings.LDAP_DATE_JOINED])
r = l.result(r)
user.first_name = r[1][0][1][settings.LDAP_FIRST_NAME][0]
user.last_name = r[1][0][1][settings.LDAP_LAST_NAME][0]
user.email = r[1][0][1][settings.LDAP_EMAIL][0]
date_joined = r[1][0][1][settings.LDAP_DATE_JOINED][0]
user.date_joined = datetime.strptime(date_joined[:-1], '%Y%m%d%H%M%S')
user.save()
return user
return None
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 create_account(request):
error=None
form = CreateUserForm()
if request.method=='POST':
form = CreateUserForm(request.POST)
if form.is_valid():
data = form.cleaned_data
try:
check_user = User.objects.get(username=data.get('username'))
error = "User with username: "******" already exists."
except User.DoesNotExist:
if data.get('password') != data.get('verify_password'):
error= "Passwords do not match."
else:
user = User()
user.username=data.get('username')
user.set_password(data.get('password'))
user.email=data.get('email')
user.save()
squirl=Squirl()
squirl.squirl_user=user
squirl.save()
auth_user = authenticate(username=data.get('username'), password=data.get('password'))
auth_login(request, auth_user)
return redirect(index)
else:
error = "Try Again"
return render(request, 'squirl/createAccount.html', {'form': form, 'error': error})
def authenticate(self,username=None,password=None):
logger.info("AD auth backend for %s" % username)
aduser = ADUser(username)
if not aduser.connect(password):
return None
user = None
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = User(username=username, is_staff = False, is_superuser = False)
if not aduser.get_data():
logger.warning("AD auth backend failed when reading data for %s. User detail data won't be updated in User model." % username)
else:
# NOTE: update user data exchange to User model
assert user.username==aduser.username
user.first_name=aduser.first_name
user.last_name=aduser.last_name
user.email=aduser.email
#user.set_password(password)
logger.warning("AD auth backend overwriting auth.User data with data from ldap for %s." % username)
user.save()
logger.info("AD auth backend check passed for %s" % username)
return user
def handle(self, *args, **options):
csv_filepathname = args[0]
sys.path.append(PROJECT_ROOT)
dataReader = csv.reader(open(csv_filepathname), delimiter=';', quotechar='"')
i = 0
index = {}
for row in dataReader:
if i==0:
index = self.comprovaCamps(row)
else:
usuari = User()
name = row[index.get('Name')]
surname = row[index.get('Surname')]
email = row[index.get('E-mail')]
username = self.comprovaUser(name, surname, email, usuari)
if(username!=False):
usuari.email = row[index.get('E-mail')]
usuari.username = username
usuari.first_name = row[index.get('Name')]
usuari.last_name = row[index.get('Surname')]
usuari.groups.add("teachers")
usuari.save()
usuari.fsuser.classroom = row[index.get('Classroom')]
i += 1
def adduser_createpw_sendmail(email, group, firstname, lastname, group_id, is_groupsuperuser=False):
if email == '':
return False
elif len(User.objects.filter(email=email)) != 0:
return False
new_user = User()
new_user.username = email.split('@')[0]
new_user.email = email
new_user.first_name = firstname
new_user.last_name = lastname
new_user.set_password('dummy_password')
new_user.save()
new_user_detail = UserDetail()
new_user_detail.user = new_user
new_user_detail.full_name = lastname+firstname
new_user_detail.save()
new_user.userdetail = new_user_detail
new_user.username = str(new_user.id)
new_user.save()
new_user_group_info = UserGroupInfo()
new_user_group_info.user = new_user
new_user_group_info.group = group
new_user_group_info.is_groupsuperuser = is_groupsuperuser
new_user_group_info.user_id_of_group = group_id
new_user_group_info.save()
if not createpassword_sendmail(email):
return False
return True
def getOrCreateUser(cls, username, email, first_name, last_name, picture):
"""
find user associated with username and updates its data or create a user
:param username:
:param email:
:param first_name:
:param last_name:
:param picture:
:return: User
"""
try:
user = User.objects.get(username=username)
profile = user.userprofile
credential = profile.credential
except ObjectDoesNotExist:
user = User()
user.email = email
user.username = username
profile = UserProfile()
credential = profile.generate_credential()
user.first_name = first_name
user.last_name = last_name
user.save()
profile.credential = credential
profile.picture = picture
profile.user = user
profile.save()
return user
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 create_user():
user = User()
user.username = '******'
user.email = '*****@*****.**'
user.password = '******'
user.save()
return user
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 create_user(request):
if request.user.is_authenticated():
return HttpResponseRedirect("/")
state = []
if request.POST:
form = Create_user_form(request.POST)
if form.is_valid():
user = User()
if User.objects.filter(username = form.cleaned_data['username']):
state.append("This username is already used!")
else:
user.username=form.cleaned_data['username']
user.set_password(form.cleaned_data['password'])
if User.objects.filter(email = form.cleaned_data['email']):
state.append("This email address is already used!")
else:
user.email=form.cleaned_data['email']
if len(state)==0:
user.save()
user_profile = User_profile()
user_profile.age=form.cleaned_data['age']
user_profile.city=form.cleaned_data['city']
user_profile.user = user
user_profile.save()
return HttpResponseRedirect("/create_done")
return my_render_to_response('create_user_form.html',{'state' : state, 'form': form}, request)
form = Create_user_form()
return my_render_to_response('create_user_form.html',{'form': form}, request)
def user_signup(request):
context = RequestContext(request)
registered = False
user = User(username = '')
next_link = ""
if request.GET:
next_link = request.GET['next']
if request.method == 'POST':
next_link = request.POST['signup_next']
user.first_name = request.POST['user[full_name]']
user.last_name = request.POST['user[sur_name]']
user.username = request.POST['user[email]']
user.email = request.POST['user[email]']
user.password = request.POST['user[password]']
user.set_password(user.password)
user.save()
patron = Patron(user = user)
account = PatronAccount(balance = 0, frozen = False, valid = True )
account.save()
patron.account = account
patron.save()
user = authenticate(username = request.POST['user[email]'], password = request.POST['user[password]'])
if user is not None:
if user.is_active:
login(request, user)
if next_link == "":
return HttpResponseRedirect('/giftcards')
else:
return HttpResponseRedirect(next_link)
else:
return render_to_response('login.html', {'next':next_link}, context)
return
def newaccount_view(request):
if request.method == 'POST':
form = NewAccountForm(request.POST)
info = "Inicializando"
if form.is_valid():
first_name = form.cleaned_data['first_name']
last_name = form.cleaned_data['last_name']
email = form.cleaned_data['email']
username = form.cleaned_data['username']
password = form.cleaned_data['password']
n = User()
n.first_name = first_name;
n.last_name = last_name;
n.email = email;
n.username = username;
n.set_password(password);
n.save();
info = "new account :)"
form = NewAccountForm()
ctx = {'form': form, 'info': info}
return render_to_response('home/newaccount.html', ctx, context_instance=RequestContext(request))
else:
info = ":( no save... grown data"
form = NewAccountForm()
ctx = {'form': form, 'info': info}
return render_to_response('home/newaccount.html', ctx, context_instance=RequestContext(request))
else:
form = NewAccountForm()
ctx = {'form': form}
return render_to_response('home/newaccount.html', ctx, context_instance=RequestContext(request))
def create_user(self, request=None, random_password=False):
"""
Given a validated form, return a new User.
Takes care of referrals too (if an HttpRequest object is passed).
"""
cd = self.cleaned_data
# Create user
user = User()
user.username = cd['username']
user.first_name = cd['first_name']
user.last_name = cd['last_name']
user.email = cd['email']
user.save()
if random_password:
user.random_password = "".join(random.sample(string.lowercase, 8))
user.set_password(user.random_password)
else:
user.set_password(cd['password'])
user.save()
if request is not None:
# If we have a referral code, set the profile's 'referral' field to it.
# Note: there *should* be a profile here, as a signal will have created it automatically.
name = request.session.get('referral', '').strip()
if name:
referral, _ = enginemodels.Referral.objects.get_or_create(name__iexact=name)
profile = user.get_profile()
profile.referral = referral
profile.save()
return user
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = User()
user.username = data['username']
user.set_password(data['password1'])
user.email = data['email']
user.save()
# Send signal
if settings.ENABLE_ACHIEVEMENTS:
user_signup.send(sender=user)
# Send email
messages.success(request,
"You are now part of the crew. Please confirm your account before login in")
else:
form = SignupForm()
context = {
'form': form,
}
return render_to_response('userprofile/signup.html',
context,
context_instance=RequestContext(request))
def post(self, request, *args, **kwargs):
# =============================================== #
# Calling the api for creating the borrower
# =============================================== #
lo_client = PerfectLOClient()
response = lo_client.create_borrower(request.POST)
borrower_id = response["success_data"]
if not borrower_id and response['error'] and response['error_text']:
messages.error(request, response['error_text'])
return HttpResponseRedirect("/app/create_questionnaire/")
new_base_user_instance = User()
new_borrower_instance = CustomUser()
# Django auth user table
new_base_user_instance.username = request.POST.get('BorrowerEmail')
new_base_user_instance.email = request.POST.get('BorrowerEmail')
new_base_user_instance.set_password(request.POST.get('BorrowerPWD'))
new_base_user_instance.save()
# Our custom user table
new_borrower_instance.user = new_base_user_instance
new_borrower_instance.uuid = borrower_id
new_borrower_instance.first_name = request.POST.get(
'BorrowerFirstName')
new_borrower_instance.middle_name = request.POST.get(
'BorrowerMiddleInitial')
new_borrower_instance.last_name = request.POST.get('BorrowerLastName')
new_borrower_instance.suffix = request.POST.get('BorrowerSuffix')
new_borrower_instance.phone = request.POST.get('BorrowerHomePhone')
new_borrower_instance.mobilephone = request.POST.get(
'BorrowerCellPhone')
new_borrower_instance.save()
# =============================================== #
# Calling the api for creating the questionnaire
# =============================================== #
lo_client = PerfectLOClient()
response = lo_client.create_questionnaire(request.POST,
new_borrower_instance)
questionnaire_id = response["success_data"]
if not questionnaire_id and response['error']:
messages.error(request, response['error_text'])
app_url = "/app/create_questionnaire/"
# Check the status
if questionnaire_id:
custom_loan_officer = CustomUser.objects.get(
uuid=settings.LOAN_OFFICER_UUID)
questionnaire_instance = Questionnaire()
questionnaire_instance.questionnaire_uuid = questionnaire_id
questionnaire_instance.borrower = new_borrower_instance
questionnaire_instance.created_by = custom_loan_officer
questionnaire_instance.save()
app_url = '/app/edit_questions/' + questionnaire_instance.questionnaire_uuid
return HttpResponseRedirect(app_url)
file = open('../db.json')
dados = json.load(file)
users = dados['users']
for u in users:
u['address'].pop('geo')
address = Address(**u['address'])
address.save()
user = User()
user.username = u['username']
user.email = u['email']
user.password = '******'
user.address = address
user.save()
profile = Profile()
profile.user = user
profile.address = address
profile.save()
posts = dados['posts']
for p in posts:
post = Post()
post.profile = Profile.objects.get(user=User.objects.get(id=p['userId']))
post.body = p.get('body') or 'sem corpo'
def read_excel_file(res, type=None):
fname = res
if not os.path.isfile(fname):
return {'code': 0, 'msg': 'File is not found!'}
data = xlrd.open_workbook(fname) # 打开fname文件
data.sheet_names() # 获取xls文件中所有sheet的名称
table = data.sheet_by_index(0) # 通过索引获取xls文件第0个sheet
nrows = table.nrows # 获取table工作表总行数
update_fields = ['username', 'email']
update_fields1 = ['state', 'role', 'group']
msg = ''
for i in range(nrows):
try:
if i + 1 < nrows:
user = User()
user.username = table.cell_value(
i + 1,
0,
) # 获取第i行中第j列的值
user.set_password('123456')
update_fields.append('password')
user.email = table.cell_value(
i + 1,
1,
)
user.id
user.save()
if type == 'stock':
user_file = UserProfile()
user_file.id = user.userprofile.id
user_file.role = 99
user_file.state = 1
user_file.save(update_fields=['role'])
else:
if table.cell_value(
i + 1,
4,
):
group_obj = UserProfile.objects.filter(
user__username=table.cell_value(
i + 1,
4,
))
else:
group_obj = UserProfile.objects.filter(id=1)
roles = table.cell_value(
i + 1,
3,
)
status = table.cell_value(
i + 1,
2,
)
user_file = UserProfile()
user_file.id = user.userprofile.id
user_file.user_id = user.id
if roles == 'member':
user_file.role = 0
elif roles == 'leader':
user_file.role = 1
else:
user_file.role = 2
if status == 'active':
user_file.state = 1
else:
user_file.state = 0
if group_obj:
user_file.group = group_obj[0]
else:
user_file.group = UserProfile.objects.filter(id=1)[0]
user_file.save(update_fields=update_fields1)
except:
msg += '第%s行添加有误。<br>' % i
continue
return {'code': 1, 'msg': msg}
def main():
from django.contrib.auth.models import User
from course.models import Course, CourseInstance, CourseModule
from course.models import Enrollment, StudentGroup, LearningObjectCategory
from exercise.exercise_models import BaseExercise
from exercise.submission_models import Submission
now = timezone.now()
year_later = now + timedelta(days=365)
user0 = User(id=500)
user0.username = '******'
user0.first_name = 'Perry'
user0.last_name = 'Cash'
user0.email = '*****@*****.**'
user0.set_password('percash0')
user0.save()
user1 = User(id=501)
user1.username = '******'
user1.first_name = 'Zorita'
user1.last_name = 'Alston'
user1.email = '*****@*****.**'
user1.set_password('zoralst1')
user1.save()
user2 = User(id=502)
user2.username = '******'
user2.first_name = 'Cameron'
user2.last_name = 'Stein'
user2.email = '*****@*****.**'
user2.set_password('camstei2')
user2.save()
user3 = User(id=503)
user3.username = '******'
user3.first_name = 'Brynne'
user3.last_name = 'Pollard'
user3.email = '*****@*****.**'
user3.set_password('brypoll3')
user3.save()
user4 = User(id=504)
user4.username = '******'
user4.first_name = 'Allistair'
user4.last_name = 'Blackburn'
user4.email = '*****@*****.**'
user4.set_password('allblac4')
user4.save()
user5 = User(id=505)
user5.username = '******'
user5.first_name = 'Zachary'
user5.last_name = 'Bolton'
user5.email = '*****@*****.**'
user5.set_password('zacbolt5')
user5.save()
user6 = User(id=506)
user6.username = '******'
user6.first_name = 'Kelsie'
user6.last_name = 'Wolf'
user6.email = '*****@*****.**'
user6.set_password('kelwolf6')
user6.save()
user7 = User(id=507)
user7.username = '******'
user7.first_name = 'John'
user7.last_name = 'McCarty'
user7.email = '*****@*****.**'
user7.set_password('johmcca7')
user7.save()
user8 = User(id=508)
user8.username = '******'
user8.first_name = 'Sheila'
user8.last_name = 'Rodriquez'
user8.email = '*****@*****.**'
user8.set_password('sherodr8')
user8.save()
user9 = User(id=509)
user9.username = '******'
user9.first_name = 'Cassady'
user9.last_name = 'Stanley'
user9.email = '*****@*****.**'
user9.set_password('casstan9')
user9.save()
course0 = Course()
course0.name = 'Test Course'
course0.url = 'test-course'
course0.save()
instance0 = CourseInstance(id=100, course=course0)
instance0.instance_name = 'Test Instance'
instance0.url = 'test-instance'
instance0.starting_time = now
instance0.ending_time = year_later
instance0.save()
Enrollment.objects.create(course_instance=instance0, user_profile=user0.userprofile)
Enrollment.objects.create(course_instance=instance0, user_profile=user1.userprofile)
Enrollment.objects.create(course_instance=instance0, user_profile=user2.userprofile)
Enrollment.objects.create(course_instance=instance0, user_profile=user3.userprofile)
Enrollment.objects.create(course_instance=instance0, user_profile=user4.userprofile)
Enrollment.objects.create(course_instance=instance0, user_profile=user5.userprofile)
Enrollment.objects.create(course_instance=instance0, user_profile=user6.userprofile)
Enrollment.objects.create(course_instance=instance0, user_profile=user7.userprofile)
Enrollment.objects.create(course_instance=instance0, user_profile=user8.userprofile)
Enrollment.objects.create(course_instance=instance0, user_profile=user9.userprofile)
group0 = StudentGroup.objects.create(id=200, course_instance=instance0)
group0.members.add(user0.userprofile)
group0.members.add(user1.userprofile)
group0.save()
group1 = StudentGroup.objects.create(id=201, course_instance=instance0)
group1.members.add(user0.userprofile)
group1.members.add(user2.userprofile)
group1.members.add(user3.userprofile)
group1.save()
group2 = StudentGroup.objects.create(id=202, course_instance=instance0)
group2.members.add(user1.userprofile)
group2.members.add(user4.userprofile)
group2.save()
group3 = StudentGroup.objects.create(id=203, course_instance=instance0)
group3.members.add(user5.userprofile)
group3.members.add(user6.userprofile)
group3.members.add(user7.userprofile)
group3.members.add(user8.userprofile)
group3.save()
module0 = CourseModule(course_instance=instance0)
module0.name = "First module"
module0.url = "first-module"
module0.opening_time = now
module0.closing_time = year_later
module0.save()
module1 = CourseModule(course_instance=instance0)
module1.name = "Second module"
module1.url = "second-module"
module1.opening_time = now
module1.closing_time = year_later
module1.save()
category0 = LearningObjectCategory(course_instance=instance0)
category0.name = "Some category"
category0.save()
exercise0 = BaseExercise(id=300, course_module=module0, category=category0)
exercise0.name = "Easy exercise"
exercise0.url = 'easy-exercise'
exercise0.max_submissions = 10
exercise0.max_group_size = 4
exercise0.max_points = 100
exercise0.points_to_pass = 50
exercise0.save()
exercise1 = BaseExercise(id=301, course_module=module0, category=category0)
exercise1.name = "Hard exercise"
exercise1.url = 'hard-exercise'
exercise1.max_submissions = 5
exercise0.max_group_size = 2
exercise1.max_points = 100
exercise1.points_to_pass = 100
exercise1.save()
exercise2 = BaseExercise(id=302, course_module=module1, category=category0)
exercise2.name = "Nice exercise"
exercise2.url = 'nice-exercise'
exercise2.max_submissions = 0
exercise2.max_points = 10
exercise2.points_to_pass = 0
exercise2.save()
submission0 = Submission.objects.create(id=400, exercise=exercise0)
submission0.submitters.add(user0.userprofile)
submission0.submitters.add(user1.userprofile)
submission0.feedback = '<html><body>Not bad.</body></html>'
submission0.set_points(40, 100)
submission0.set_ready()
submission0.save()
submission1 = Submission.objects.create(id=401, exercise=exercise0)
submission1.submitters.add(user0.userprofile)
submission1.submitters.add(user1.userprofile)
submission1.feedback = '<html><body>Good.</body></html>'
submission1.set_points(60, 100)
submission1.set_ready()
submission1.save()
submission2 = Submission.objects.create(id=402, exercise=exercise0)
submission2.submitters.add(user1.userprofile)
submission2.submitters.add(user4.userprofile)
submission2.feedback = '<html><body>Good.</body></html>'
submission2.set_points(50, 100)
submission2.set_ready()
submission2.save()
submission3 = Submission.objects.create(id=403, exercise=exercise2)
submission3.submitters.add(user0.userprofile)
submission3.feedback = '<html><body>Excellent.</body></html>'
submission3.set_points(10, 10)
submission3.set_ready()
submission3.save()
def post(self, request):
"""
:param request: email and password, confirm_password are mandatory to this api
:return: sends success message if signup success, else display error messages
"""
email = request.POST.get('email')
password = request.POST.get('password')
first_name = request.POST.get('first_name')
last_name = request.POST.get('last_name')
c_password = request.POST.get('password_confirmation')
if c_password != password:
context = {
"signup_page": "active",
"messages": {
"level": "danger",
"short": "Error!",
"msg": "Password doesn't match with confirm password"
}
}
return render(request,
template_name='signup.html',
context=context)
user = User.objects.filter(username=email)
if user.exists():
context = {
"signup_page": "active",
"messages": {
"level": "danger",
"short": "Error!",
"msg": "Email address already exists"
}
}
return render(request,
template_name='signup.html',
context=context)
elif email and password:
u = User()
u.username = email
u.email = email
u.first_name = first_name
u.last_name = last_name
u.set_password(password)
u.is_active = False
u.save()
#email part
mail_subject = 'Activate your user account.'
current_site = get_current_site(request)
message = render_to_string(
'acc_active_email.html', {
'user': u,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(u.pk)),
'token': account_activation_token.make_token(u),
})
to_email = email
email = EmailMessage(mail_subject, message, to=[to_email])
email.send()
context = {
"signup_page": "active",
"messages": {
"level":
"success",
"short":
"Success! ",
"msg":
"Please confirm your email address to "
"complete the registration"
}
}
return render(request,
template_name='signup.html',
context=context)
return
def register(request):
if request.method == 'GET':
return render(request, 'website/user/register.html', {})
if request.method == 'POST':
#TODO clean data
username = request.POST.get('username')
email = request.POST.get('email')
password = request.POST.get('password')
confirm_password = request.POST.get('confirm_password')
#data validation
if not username and not email and not password and not confirm_password:
return render(request, 'website/user/register.html',
{'message': 'Registration fields are required'})
if not username:
return render(request, 'website/user/register.html',
{'message': 'username is required'})
if not email:
return render(request, 'website/user/register.html', {
'message': 'email is required',
})
if not validate_email(email):
return render(request, 'website/user/register.html',
{'message': 'a valid email address is required'})
if not password:
return render(request, 'website/user/register.html',
{'message': 'password is required'})
if not confirm_password:
return render(request, 'website/user/register.html',
{'message': 'confirm password is required'})
if password != confirm_password:
return render(request, 'website/user/register.html',
{'message': 'passwords do not match'})
#check if username already exits
username_exists = False
try:
exists = User.objects.get(username=username)
except User.DoesNotExist:
username_exists = True
if not username_exists:
return render(request, 'website/user/register.html',
{'message': 'username already exists'})
#check if email already exists
email_exists = False
try:
exists = User.objects.get(email=email)
except User.DoesNotExist:
email_exists = True
if not email_exists:
return render(request, 'website/user/register.html',
{'message': 'email already exists'})
#save user
user = User()
user.username = username
user.password = password
user.email = email
user.save()
if user.id > 0:
#add all registering users to the members role
group = Group.objects.get(name='member')
group.user_set.add(user)
return HttpResponseRedirect('/user/profile/')
return render(request, 'website/user/register.html', {'message': ''})
def upload_view(request):
if not request.user.is_superuser:
raise exceptions.PermissionDenied
if request.method == 'POST': # if form submitted...
form = UploadProfileForm(request.POST, request.FILES)
if form.is_valid():
request.FILES['upload_file'].open("rb")
csv_file = csv.DictReader(request.FILES['upload_file'].file)
required_fields = ['username', 'firstname', 'lastname', 'email']
results = []
try:
for row in csv_file:
# check all required fields defined
all_defined = True
for rf in required_fields:
if rf not in row or row[rf].strip() == '':
result = {}
result['username'] = row['username']
result['created'] = False
result['message'] = _(u'No %s set' % rf)
results.append(result)
all_defined = False
if not all_defined:
continue
user = User()
user.username = row['username']
user.first_name = row['firstname']
user.last_name = row['lastname']
user.email = row['email']
auto_password = False
if 'password' in row:
user.set_password(row['password'])
else:
password = User.objects.make_random_password()
user.set_password(password)
auto_password = True
try:
user.save()
up = UserProfile()
up.user = user
for col_name in row:
setattr(up, col_name, row[col_name])
up.save()
result = {}
result['username'] = row['username']
result['created'] = True
if auto_password:
result['message'] = _(
u'User created with password: %s' % password)
else:
result['message'] = _(u'User created')
results.append(result)
except IntegrityError as ie:
result = {}
result['username'] = row['username']
result['created'] = False
result['message'] = _(u'User already exists')
results.append(result)
continue
except:
result = {}
result['username'] = None
result['created'] = False
result['message'] = _(u'Could not parse file')
results.append(result)
else:
results = []
form = UploadProfileForm()
return render(request, 'oppia/profile/upload.html', {
'form': form,
'results': results
})
def approve_preRegistration(request, pk):
perm = general_methods.control_access(request)
if not perm:
logout(request)
return redirect('accounts:login')
basvuru = PreRegistration.objects.get(pk=pk)
if basvuru.status != PreRegistration.APPROVED:
mail = basvuru.email
if not (User.objects.filter(email=mail) or ReferenceCoach.objects.exclude(status=ReferenceCoach.DENIED).filter(
email=mail) or ReferenceReferee.objects.exclude(status=ReferenceReferee.DENIED).filter(email=mail)):
user = User()
user.username = basvuru.email
user.first_name = unicode_tr(basvuru.first_name).upper()
user.last_name = unicode_tr(basvuru.last_name).upper()
user.email = basvuru.email
user.is_active = True
user.is_staff = basvuru.is_staff
group = Group.objects.get(name='KlupUye')
password = User.objects.make_random_password()
user.set_password(password)
user.save()
user.groups.add(group)
user.save()
# person kaydet
person = Person()
person.tc = basvuru.tc
person.birthplace = basvuru.birthplace
person.motherName = basvuru.motherName
person.fatherName = basvuru.fatherName
person.profileImage = basvuru.profileImage
person.birthDate = basvuru.birthDate
person.bloodType = basvuru.bloodType
if basvuru.gender == 'Erkek':
person.gender = Person.MALE
else:
person.gender = Person.FEMALE
person.save()
# Communication kaydet
com = Communication()
com.postalCode = basvuru.postalCode
com.phoneNumber = basvuru.phoneNumber
com.phoneNumber2 = basvuru.phoneNumber2
com.address = basvuru.address
com.city = basvuru.city
com.country = basvuru.country
com.save()
Sportclup = SportClubUser()
Sportclup.user = user
Sportclup.person = person
Sportclup.communication = com
Sportclup.role = basvuru.role
Sportclup.save()
comclup = Communication()
comclup.postalCode = basvuru.clubpostalCode
comclup.phoneNumber = basvuru.clubphoneNumber
comclup.phoneNumber2 = basvuru.clubphoneNumber2
comclup.address = basvuru.clubaddress
comclup.city = basvuru.clubcity
comclup.country = basvuru.clubcountry
comclup.save()
# SportClup
clup = SportsClub()
clup.name = basvuru.name
clup.shortName = basvuru.shortName
clup.foundingDate = basvuru.foundingDate
clup.clubMail = basvuru.clubMail
clup.logo = basvuru.logo
clup.isFormal = basvuru.isFormal
clup.petition = basvuru.petition
clup.communication = comclup
clup.save()
clup.clubUser.add(Sportclup)
clup.save()
# burada kadik
if basvuru.isCoach:
coach = Coach()
coach.user = user
coach.person = person
coach.communication = com
coach.iban = basvuru.iban
coach.save()
group = Group.objects.get(name='Antrenor')
user.groups.add(group)
user.save()
grade = Level(
startDate=basvuru.kademe_startDate,
dekont=basvuru.kademe_belge,
branch=EnumFields.HALTER.value)
try:
grade.definition = CategoryItem.objects.get(name=basvuru.kademe_definition)
except:
grade.definition = CategoryItem.objects.get(name='1.Kademe')
grade.levelType = EnumFields.LEVELTYPE.GRADE
grade.status = Level.APPROVED
grade.isActive = True
grade.save()
coach.grades.add(grade)
coach.save()
clup.coachs.add(coach)
clup.save()
basvuru.status = PreRegistration.APPROVED
basvuru.save()
fdk = Forgot(user=user, status=False)
fdk.save()
html_content = ''
subject, from_email, to = 'Bilgi Sistemi Kullanıcı Bilgileri', '*****@*****.**', user.email
html_content = '<h2>TÜRKİYE BADMİNTON FEDERASYONU BİLGİ SİSTEMİ</h2>'
html_content = html_content + '<p><strong>Kullanıcı Adınız :' + str(fdk.user.username) + '</strong></p>'
html_content = html_content + '<p> <strong>Site adresi:</strong> <a href="http://sbs.badminton.gov.tr/newpassword?query=' + str(
fdk.uuid) + '">http://sbs.badminton.gov.tr/sbs/profil-guncelle/?query=' + str(fdk.uuid) + '</p></a>'
msg = EmailMultiAlternatives(subject, '', from_email, [to])
msg.attach_alternative(html_content, "text/html")
msg.send()
messages.success(request, 'Başari ile kaydedildi')
log = str(clup) + " Klup basvurusu onaylandi"
log = general_methods.logwrite(request, request.user, log)
# try:
# # user kaydet
# print()
# except:
# messages.warning(request, 'Lütfen sistem yöneticisi ile görüşünüz ')
# log = str(basvuru.name) + " Klup basvurusu hata oldu"
# log = general_methods.logwrite(request, request.user, log)
else:
messages.warning(request, 'Mail adresi sistem de kayıtlıdır.')
else:
messages.warning(request, 'Bu basvuru sisteme kaydedilmistir.')
prepegidtration = PreRegistration.objects.all()
return render(request, 'kulup/kulupBasvuru.html',
{'prepegidtration': prepegidtration})
context = {
'error': error,
}
return render_to_response('visitor/signup.html', context,
RequestContext(request))
fn = request.POST.get('fn')
ln = request.POST.get('ln')
new = User()
new.username = isd + username
new.first_name = fn
new.last_name = ln
new.save()
new.set_password(password)
new.email = email
new.save()
profile = VisitorProfile()
profile.user = new
profile.password = password
profile.save()
user = authenticate(username=isd + username, password=password)
if user is not None:
if user.is_active:
login(request, user)
request.session['userid'] = user.id
print 'logged in'
return HttpResponseRedirect('/user/sendotp/')
def addStaffPage(request):
pageTitle = 'Add Staff'
# userForm = UserForm()
staffForm = StaffForm()
if request.method == 'POST':
staffForm = StaffForm(request.POST)
if staffForm.is_valid():
if Staff.objects.filter(
phone_number=request.POST['phone_number']).exists():
messages.warning(request, "Staff Exist Already")
return redirect('adminaddstaff')
else:
staff = Staff()
now = datetime.datetime.now()
staffId = str(now.year) + str(random.randint(10, 99))
staff.staff_id = int(staffId)
staff.firstname = request.POST['firstname']
staff.middlename = request.POST['middlename']
staff.surname = request.POST['surname']
staff.dob = request.POST['dob']
staff.gender = request.POST['gender']
staff.marital_status = request.POST['marital_status']
staff.phone_number = request.POST['phone_number']
staff.email = request.POST['email']
staff.group = Group.objects.get(id=request.POST['group'])
staff.address = request.POST['address']
staff.city_town = request.POST['city_town']
staff.state = request.POST['state']
staff.zipcode = request.POST['zipcode']
staff.save()
isUser = request.POST.get('usercheck')
if isUser == 'usercheck':
user = User()
firstname = request.POST['firstname']
surname = request.POST['surname']
uname = firstname[0] + surname[0] + str(
random.randrange(10, 99)) + 'AMS'
user.username = uname
user.first_name = firstname
user.last_name = surname
user.email = request.POST['email']
password = ''.join(
secrets.choice(string.ascii_letters + string.digits)
for x in range(8))
password1 = password
user.set_password(password1)
user.save()
group = Group.objects.get(id=request.POST['group'])
user.groups.add(group)
staff = Staff.objects.get(id=staff.id)
staff.user = User.objects.get(id=user.id)
staff.save()
send_mail(
'AMS',
'Username: '******' and Password: '******'*****@*****.**', [
request.POST['email'],
])
messages.success(request, "Staff Saved successfully")
return redirect('adminaddstaff')
context = {
'pageTitle': pageTitle,
'staffForm': staffForm,
}
return render(request, 'admin/add-staff.html', context)
def setUp(self):
user = User()
user.username = "******"
user.email = "*****@*****.**"
user.set_password("password")
user.save()
return render_to_response('register.html',RequestContext(request,{'username':username,'email':email,'errors':errors}))
# return render_to_response('register.html',{'errors':errors},context_instance=RequestContext(request))
filterResult=User.objects.filter(username=username)
if len(filterResult)>0:
errors.append("用户名已存在")
return render_to_response('register.html',RequestContext(request,{'username':username,'email':email,'errors':errors}))
filterResult=User.objects.filter(email=email)
if len(filterResult)>0:
errors.append("电邮已注册")
return render_to_response('register.html',RequestContext(request,{'username':username,'email':email,'errors':errors}))
user=User()
user.username=username
user.email=email
user.set_password(password1)
user.save()
codeObj = InviteCode.objects.get(code=ivc)
codeObj.guest=user.id
codeObj.flag = 1
codeObj.save()
return render_to_response('login.html',RequestContext(request,{'is_from_register':True}))
@login_required
def showInviteCode(request):
if not request.user.is_superuser:
return HttpResponseRedirect("/")
def run():
from accounts.models import Course
accounts_course_1 = Course()
accounts_course_1.code = u'MCA'
accounts_course_1.name = u'MCA'
accounts_course_1.duration = 3L
accounts_course_1.level = u'PG'
try:
accounts_course_1.save()
except IntegrityError:
pass
from accounts.models import Batch
accounts_batch_1 = Batch()
accounts_batch_1.code = u'09mca'
accounts_batch_1.course = accounts_course_1
accounts_batch_1.year = 2009L
accounts_batch_1.name = u'MCA 2009-2012 Batch'
try:
accounts_batch_1.save()
except IntegrityError:
pass
from django.contrib.auth.models import User
auth_user_2 = User()
auth_user_2.username = settings.TEST_USERNAME
auth_user_2.first_name = u'Test'
auth_user_2.last_name = u'User'
auth_user_2.email = u''
auth_user_2.is_staff = False
auth_user_2.is_active = True
auth_user_2.is_superuser = False
try:
auth_user_2.save()
except IntegrityError:
pass
auth_user_2 = User.objects.get(username=settings.TEST_USERNAME)
auth_user_2.set_password(settings.TEST_USER_PASSWORD)
auth_user_2.save()
from accounts.models import Profile
accounts_profile_1 = Profile()
accounts_profile_1.user = auth_user_2
accounts_profile_1.course = accounts_course_1
accounts_profile_1.year_of_joining = Decimal('2009')
accounts_profile_1.college_email_id = u'*****@*****.**'
accounts_profile_1.personal_email_id = u'*****@*****.**'
accounts_profile_1.google_account_created = True
accounts_profile_1.gender = u'M'
accounts_profile_1.actual_date_of_birth = datetime.date(2009, 6, 1)
try:
accounts_profile_1.save()
except IntegrityError:
pass
def add_directory_member(request):
perm =general_methods.control_access(request)
if not perm:
logout(request)
return redirect('accounts:login')
user_form = UserForm()
person_form = PersonForm()
communication_form = CommunicationForm()
member_form = DirectoryForm()
if request.method == 'POST':
user_form = UserForm(request.POST)
person_form = PersonForm(request.POST, request.FILES)
communication_form = CommunicationForm(request.POST)
member_form = DirectoryForm(request.POST)
if user_form.is_valid() and person_form.is_valid() and communication_form.is_valid() and member_form.is_valid():
user = User()
user.username = user_form.cleaned_data['email']
user.first_name = user_form.cleaned_data['first_name']
user.last_name = user_form.cleaned_data['last_name']
user.email = user_form.cleaned_data['email']
group = Group.objects.get(name='Yonetim')
password = User.objects.make_random_password()
user.set_password(password)
user.save()
user.groups.add(group)
user.save()
person = person_form.save(commit=False)
communication = communication_form.save(commit=False)
person.save()
communication.save()
directoryMember = DirectoryMember(user=user, person=person, communication=communication)
directoryMember.role = member_form.cleaned_data['role']
directoryMember.commission = member_form.cleaned_data['commission']
directoryMember.save()
subject, from_email, to = 'WUSHU - Yönetim/Federasyon Bilgi Sistemi Kullanıcı Giriş Bilgileri', '*****@*****.**', user.email
text_content = 'Aşağıda ki bilgileri kullanarak sisteme giriş yapabilirsiniz.'
html_content = '<p> <strong>Site adresi: </strong> <a href="http://sbs.twf.gov.tr/"></a>sbs.twf.gov.tr</p>'
html_content = html_content + '<p><strong>Kullanıcı Adı: </strong>' + user.username + '</p>'
html_content = html_content + '<p><strong>Şifre: </strong>' + password + '</p>'
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_content, "text/html")
msg.send()
messages.success(request, 'Yönetim Kurulu Üyesi Başarıyla Kayıt Edilmiştir.')
return redirect('wushu:kurul-uyeleri')
else:
for x in user_form.errors.as_data():
messages.warning(request, user_form.errors[x][0])
return render(request, 'yonetim/kurul-uyesi-ekle.html',
{'user_form': user_form, 'person_form': person_form, 'communication_form': communication_form, 'member_form':member_form})
def return_add_athlete(request):
perm = general_methods.control_access(request)
if not perm:
logout(request)
return redirect('accounts:login')
user_form = UserForm()
person_form = PersonForm()
communication_form = CommunicationForm()
# lisans ekleme baslangıç
# klüp üyesi sadece kendi klüplerini görebiliyor
user = request.user
license_form = LicenseForm(request.POST, request.FILES or None)
if user.groups.filter(name='KulupUye'):
sc_user = SportClubUser.objects.get(user=user)
clubs = SportsClub.objects.filter(clubUser=sc_user)
clubsPk = []
for club in clubs:
clubsPk.append(club.pk)
license_form.fields['sportsClub'].queryset = SportsClub.objects.filter(
id__in=clubsPk)
elif user.groups.filter(name__in=['Yonetim', 'Admin']):
license_form.fields['sportsClub'].queryset = SportsClub.objects.all()
# lisan ekleme son alani bu alanlar sadece form bileselerinin sisteme gidebilmesi icin post ile gelen veride gene ayni şekilde karşılama ve kaydetme islemi yapilacak
if request.method == 'POST':
user_form = UserForm(request.POST)
person_form = PersonForm(request.POST, request.FILES)
communication_form = CommunicationForm(request.POST)
license_form = LicenseForm(request.POST, request.FILES or None)
if user_form.is_valid() and person_form.is_valid(
) and license_form.is_valid() and communication_form.is_valid():
user = User()
user.username = user_form.cleaned_data['email']
user.first_name = user_form.cleaned_data['first_name'].upper()
user.last_name = user_form.cleaned_data['last_name'].upper()
user.email = user_form.cleaned_data['email']
group = Group.objects.get(name='Sporcu')
password = User.objects.make_random_password()
user.set_password(password)
user.is_active = False
user.save()
user.groups.add(group)
user.save()
person = person_form.save(commit=False)
communication = communication_form.save(commit=False)
person.save()
communication.save()
athlete = Athlete(
user=user,
person=person,
communication=communication,
)
# lisans kaydedildi kakydetmeden id degeri alamayacagi icin önce kaydedip sonra ekleme islemi yaptık
license = license_form.save()
athlete.save()
athlete.licenses.add(license)
# subject, from_email, to = 'WUSHU - Sporcu Bilgi Sistemi Kullanıcı Giriş Bilgileri', '*****@*****.**', user.email
# text_content = 'Aşağıda ki bilgileri kullanarak sisteme giriş yapabilirsiniz.'
# html_content = '<p> <strong>Site adresi: </strong> <a href="https://www.twf.gov.tr/"></a>https://www.twf.gov.tr/</p>'
# html_content = html_content + '<p><strong>Kullanıcı Adı: </strong>' + user.username + '</p>'
# html_content = html_content + '<p><strong>Şifre: </strong>' + password + '</p>'
# msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
# msg.attach_alternative(html_content, "text/html")
# msg.send()
messages.success(request, 'Sporcu Başarıyla Kayıt Edilmiştir.')
return redirect('sbs:sporcular')
else:
for x in user_form.errors.as_data():
messages.warning(request, user_form.errors[x][0])
return render(
request, 'sporcu/sporcu-ekle.html', {
'user_form': user_form,
'person_form': person_form,
'license_form': license_form,
'communication_form': communication_form
})
def user_register(request, num):
"""
Create db according to user input and choosing account type.
Args:
request - user request.
num - account type identification number.
Returns:
---
"""
# Create verification code for sending emails
verification_code = str_tools.random_str(10)
subject = 'Verification email'
text = "Welcome to Torus family.\nPlease verify your account by entering in app\n\nVerification Code - %s" % verification_code
user = User()
# all data corresponding user input
data = json.loads(request.body.decode('utf-8'))
if num == 0:
# Full name from user input
first_name = data['name']
# Get email for user
email = data['email'].lower()
# Get password for user
password = data['password']
try:
# Get profile picture
image = data['image']
except KeyError as valerr:
image = ''
# Check user exist or not
if get_or_none(User, email=email):
return HttpResponse(json.dumps({'status': 'error', 'error':\
{'code': 1, 'text': 'Username already registered'},}),
status=500, content_type='application/json')
user.first_name = first_name
user.username = email
user.email = email
user.password = password
user.is_active = False
user.save()
IndividualUser.objects.create(user=user, profile_picture=image)
print("START SENDING EMAIL\n")
email_tools.send_email(email, subject, text, user.id)
print("END SENDING EMAIL\n")
content = {'id': user.id, 'first_name': first_name, 'email' : email,
'password': password, 'online': user.is_active}
jwt_token = {'token': jwt.encode(content, "SECRET_KEY").decode("utf-8")}
return HttpResponse(json.dumps(jwt_token), status=200, content_type='application/json')
elif num == 1:
# Full name from user input
first_name = data['name']
# Get email for user
email = data['email']
# Get password for user
password = data['password']
# Get verified account link
verified_account = data['verified_account']
try:
# Get profile picture
image = data['image']
except KeyError as valerr:
image = ''
# Check user exist or not
if get_or_none(User, email=email):
return HttpResponse(json.dumps({'status': 'error', 'error':\
{'code': 1, 'text': 'Username already registered'},
}), status=500, content_type='application/json')
user.first_name = first_name
user.email = email
user.username = email
user.password = password
user.is_active = False
user.save()
ProfessionalUser.objects.create(user=user, profile_picture=image, verified_account_link=verified_account)
print("START SENDING EMAIL\n")
email_tools.send_email(email, subject, text, user.id)
print("END SENDING EMAIL\n")
content = {'id': user.id, 'first_name': first_name, 'email' : email,
'password': password, 'online': user.is_active}
jwt_token = {'token': jwt.encode(content, "SECRET_KEY").decode("utf-8")}
return HttpResponse(json.dumps(jwt_token), status=200, content_type='application/json')
elif num == 2:
# Get email for user
email = data['email']
# Get password for user
password = data['password']
# Company name from user input
company_name = data['name']
# Get corporate link address
corporate_link = data['corporate_link']
try:
# Get profile picture
image = data['image']
except KeyError as valerr:
image = ''
# Check user exist or not
if get_or_none(User, email=email):
return HttpResponse(json.dumps({'status': 'error', 'error': \
{'code': 1, 'text': 'Username already registered'},
}), status=500, content_type='application/json')
user.email = email
user.password = password
user.is_active = False
user.save()
# Create corporate user
corporate = CorporateUser()
CorporateUser.objects.create(user=user, company_name=company_name, profile_picture=image,
corporate_link=corporate_link)
print("START SENDING EMAIL\n")
email_tools.send_email(email, subject, text, user.id)
print("END SENDING EMAIL\n")
content = {'id': user.id, 'company_name': company_name, 'email' : email,
'password': password, 'online': user.is_active}
jwt_token = {'token': jwt.encode(content, "SECRET_KEY").decode("utf-8")}
return HttpResponse(json.dumps(jwt_token), status=200, content_type='application/json')
def add(request, form_class=DonationForm, template_name="donations/add.html"):
use_captcha = get_setting('site', 'global', 'captcha')
if request.method == "POST":
form = form_class(request.POST, user=request.user)
captcha_form = CaptchaForm(request.POST)
if not use_captcha:
del captcha_form.fields['captcha']
if form.is_valid() and captcha_form.is_valid():
donation = form.save(commit=False)
donation.payment_method = donation.payment_method.lower()
# we might need to create a user record if not exist
if request.user.is_authenticated():
user = request.user
else:
try:
user = User.objects.get(email=donation.email)
except:
user = request.user
if not user.is_anonymous():
donation.user = user
donation.creator = user
donation.creator_username = user.username
else:
# this is anonymous user donating and we didn't find their user record in the system,
# so add a new user
user = User()
user.first_name = donation.first_name
user.last_name = donation.last_name
user.email = donation.email
user.username = get_unique_username(user)
user.set_password(User.objects.make_random_password(length=8))
user.is_active = 0
user.save()
profile_kwarg = {
'user': user,
'company': donation.company,
'address': donation.address,
'address2': donation.address2,
'city': donation.city,
'state': donation.state,
'zipcode': donation.zip_code,
'country': donation.country,
'phone': donation.phone
}
if request.user.is_anonymous():
profile_kwarg['creator'] = user
profile_kwarg['creator_username'] = user.username
profile_kwarg['owner'] = user
profile_kwarg['owner_username'] = user.username
else:
profile_kwarg['creator'] = request.user
profile_kwarg['creator_username'] = request.user.username
profile_kwarg['owner'] = request.user
profile_kwarg['owner_username'] = request.user.username
profile = Profile.objects.create(**profile_kwarg)
profile.save()
donation.save(user)
# create invoice
invoice = donation_inv_add(user, donation)
# updated the invoice_id for mp, so save again
donation.save(user)
if request.user.profile.is_superuser:
if donation.payment_method in ['paid - check', 'paid - cc']:
# the admin accepted payment - mark the invoice paid
invoice.tender(request.user)
invoice.make_payment(request.user,
donation.donation_amount)
# send notification to administrators
# get admin notice recipients
if not donation.payment_method.lower() in [
'cc', 'credit card', 'paypal'
]:
# email to admin (if payment type is credit card email is not sent until payment confirmed)
recipients = get_notice_recipients('module', 'donations',
'donationsrecipients')
if recipients:
if notification:
extra_context = {
'donation': donation,
'invoice': invoice,
'request': request,
}
notification.send_emails(recipients, 'donation_added',
extra_context)
# email to user
email_receipt = form.cleaned_data['email_receipt']
if email_receipt:
donation_email_user(request, donation, invoice)
EventLog.objects.log(instance=donation)
# redirect to online payment or confirmation page
if donation.payment_method.lower() in [
'cc', 'credit card', 'paypal'
]:
return HttpResponseRedirect(
reverse('payment.pay_online',
args=[invoice.id, invoice.guid]))
else:
return HttpResponseRedirect(
reverse('donation.add_confirm', args=[donation.id]))
else:
form = form_class(user=request.user)
captcha_form = CaptchaForm()
currency_symbol = get_setting("site", "global", "currencysymbol")
if not currency_symbol: currency_symbol = "$"
return render_to_response(template_name, {
'form': form,
'captcha_form': captcha_form,
'use_captcha': use_captcha,
'currency_symbol': currency_symbol
},
context_instance=RequestContext(request))
def form(request, object_id=None):
"""
Register a new User
object_id : Person.id
"""
person = Person.objects.get(
pk=object_id, organization=request.user.get_profile().org_active)
permissions = [] # to check in template, checkbox permissions
errors = False
# update
if hasattr(person, 'profile'):
profile = Profile.objects.get(
person=object_id,
person__organization=request.user.get_profile().org_active)
# store permissions
for x in profile.user.groups.all():
permissions.append(u"%s" % x.name)
# save form
if request.POST:
permissions = request.POST.getlist('perms')
username = slugify(request.POST.get('username'))
if not permissions:
messages.error(request, _('Select one or more group permission.'))
errors = True
if not username:
messages.error(request, _('Invalid Username'))
errors = True
# update
if hasattr(person, 'profile'):
if not errors:
profile.user.username = slugify(request.POST.get('username'))
profile.user.save()
set_permission(request, profile, permissions)
messages.success(request, _('User updated successfully'))
return HttpResponseRedirect('/user/%s/' % person.id)
# new
if not hasattr(person, 'profile'):
password = request.POST.get('password')
pwd_conf = request.POST.get('pwd_conf')
email = request.POST.get('email_send_user')
# temp
user = User()
user.username = username
user.password = password # temp
user.email = email
profile = Profile()
profile.user = user
person.profile = profile
if User.objects.filter(username=username):
messages.error(request,
_("Username already exists, try another."))
errors = True
if not password == pwd_conf or not password:
user.password = ""
messages.error(
request,
_('Password confirmation does not match. Please try again')
)
errors = True
if not email:
messages.error(request, _('Email address do not match'))
errors = True
if not errors:
site_url = "https://%s" % get_current_site(request).domain
# overwrite user
user = RegistrationProfile.objects.create_inactive_user(
username, email, password, site_url)
user.set_password(password)
user.save()
profile.user = user
profile.org_active = request.user.get_profile().org_active
profile.save()
person.profile = set_permission(request, profile, permissions)
person.save()
# return success to form
messages.success(
request,
_('User created successfully. An email will be sent to the user with instructions on how to finish the registration process.'
))
return HttpResponseRedirect('/user/%s/' % person.id)
# mount form, error, new or update
return render_to_response('users/users_form.html', {
'person': person,
'permissions': permissions,
},
context_instance=RequestContext(request))
def register_school(request, conference_slug):
conference = get_object_or_404(Conference, url_name=conference_slug)
if request.method == 'POST':
school_form = NewSchoolForm(request.POST)
sponsor_form = NewFacultySponsorForm(request.POST)
captcha_response = get_recaptcha_response(request)
if school_form.is_valid():
if request.user.is_authenticated() or sponsor_form.is_valid():
if captcha_response.is_valid or not settings.ENABLE_CAPTCHA:
new_school = School()
new_school.name = school_form.cleaned_data['school_name']
new_school.url_name = slugify(school_form.cleaned_data['school_name'])
new_school.address_line_1 = school_form.cleaned_data['school_address_line_1']
new_school.address_line_2 = school_form.cleaned_data['school_address_line_2']
new_school.city = school_form.cleaned_data['school_city']
new_school.state = school_form.cleaned_data['school_state']
new_school.zip = school_form.cleaned_data['school_zip']
new_school.address_country = school_form.cleaned_data['school_address_country']
new_school.access_code = User.objects.make_random_password()
new_school.save()
new_school.conferences.add(conference)
new_sponsor = FacultySponsor()
new_sponsor.school = new_school
if hasattr(sponsor_form, 'cleaned_data'):
new_sponsor.phone = sponsor_form.cleaned_data['sponsor_phone']
new_user = request.user
if not request.user.is_authenticated():
new_user = User()
new_user.username = sponsor_form.cleaned_data['sponsor_username']
new_user.first_name = sponsor_form.cleaned_data['sponsor_first_name']
new_user.last_name = sponsor_form.cleaned_data['sponsor_last_name']
new_user.email = sponsor_form.cleaned_data['sponsor_email']
new_user.set_password(sponsor_form.cleaned_data['sponsor_password'])
new_user.save()
else:
try:
# delete any existing faculty sponsor ties
existing_sponsor = FacultySponsor.objects.get(user=new_user)
new_sponsor.phone = existing_sponsor.phone
existing_sponsor.delete()
except ObjectDoesNotExist:
pass
new_sponsor.user = new_user
new_sponsor.save()
new_sponsor.conferences.add(conference)
return HttpResponseRedirect(reverse(school_admin,
args=(conference.url_name, new_school.url_name,)))
else:
school_form._errors.setdefault("school_name", ErrorList()).append("The reCAPTCHA wasn't entered correctly.")
else:
try:
school = request.user.faculty_sponsor.school
try:
school.conferences.get(id=conference.id)
except Conference.DoesNotExist:
school.conferences.add(conference)
try:
request.user.faculty_sponsor.conferences.get(id=conference.id)
except Conference.DoesNotExist:
request.user.faculty_sponsor.conferences.add(conference)
return HttpResponseRedirect(reverse(school_admin,
args=(conference.url_name, school.url_name,)))
except:
school_form = NewSchoolForm()
sponsor_form = NewFacultySponsorForm()
return render_response(request, 'register-new-school.html', {
'school_form': school_form, 'sponsor_form': sponsor_form, 'conference' : conference
})
def post(self, request):
print(request.data)
accesstoken = request.data.get('accesstoken')
expiration_time = request.data.get('expiration_time')
print(expiration_time)
userID = request.data.get('userID')
if (int(expiration_time) < int(time.time())):
content = {"status": 404}
return Response(content)
else:
url = "https://graph.facebook.com/{}".format(userID)
parameters = {
'fields': 'name,email,picture',
'access_token': accesstoken
}
idInfo = r.get(url=url, params=parameters).json()
email = idInfo['email']
name = idInfo['name']
email = email
name = name
image = idInfo['picture']['data']['url']
try:
user = User.objects.get(email=email)
player = UserScore.objects.filter(user=user)[
0] #FB profile pic at higher priority than google.
player.imgurl = image #However this generates an issue: Anyone who swtiches to fb from google
player.save(
) #have his last modified time, changed to now(). So he might lose a couple
except User.DoesNotExist: #places on the leaderboard. Solution: Make a custom save option/ Change auto_now= false
user = User()
user.username = email
user.email = email
# provider random default password
user.password = make_password(
BaseUserManager().make_random_password())
user.save()
score = UserScore(
user=user,
name=name,
imgurl=image,
email=user.email,
current_question=1,
last_modified=datetime.datetime.now().replace(tzinfo=utc))
score.save()
z = UserScore.lboardSave(UserScore)
token = RefreshToken.for_user(
user) # generate token without username & password
response = {}
response['username'] = user.username
response['access_token'] = str(token.access_token)
response['refresh_token'] = str(token)
response['image'] = image[0]
#adding quiz_finished tag for users who have finished the level
player = UserScore.objects.filter(user=user)[0]
active = config.quiz_active(config)
curr_config = config.current_config(config)
if active:
day = curr_config.current_day
curr_day = player.today
curr_question = player.current_question
if curr_day > day:
response['quiz_finished'] = True
else:
response['quiz_finished'] = False
else:
response['error'] = "No active quizes"
#end
return Response(response)
# Run the following commands in the Django shell `python3 manage.py shell`
# Trying to create a new article. This will result in an error.
from cms.models import Article
article1 = Article()
article1.title = "New Article"
article1.content = "Test content"
article1.slug = "new-article"
article1.save()
# Creating a new user.
from django.contrib.auth.models import User
author1 = User()
author1.first_name = 'Aruna'
author1.last_name = 'Tank'
author1.email = '*****@*****.**'
author1.set_password('apassword')
author1.save()
# The above article can be saved now tha tis has an author attached.
article1.author = author1
article1.save()
def register(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/register/')
if request.method=='POST':
data=json.loads( request.body.decode('utf-8') )
print(data['college'])
recaptcha_response = data['captcha']
url = 'https://www.google.com/recaptcha/api/siteverify'
values = {
'secret': '6LcNq10UAAAAAJVLztulO5FzlWynQ6p93k1rLnuk',
'response': recaptcha_response
}
#### uncomment for python 2 #####
#data2 = urllib.urlencode(values)
#req = urllib2.Request(url, data2)
#response = urllib2.urlopen(req)
#result = json.load(response)
#################################
#### comment for python 2 #######
data2 = urllib.parse.urlencode(values).encode()
req = urllib.request.Request(url, data=data2)
response = urllib.request.urlopen(req)
result = json.loads(response.read().decode())
#################################
if result['success']:
pass
else:
return JsonResponse({'error': "Invalid CAPTCHA. Please try again."})
for idno in data['sport_id']:
sp=Sport.objects.get(pk=int(idno))
if data['register_as']!='C' and data['gender']!=sp.gender and sp.gender!='both':
return JsonResponse({'error': 'Selected gender does not fit the gender requirement of the selected sports'})
team = Team.objects.get(pk=data['college'])
up=User()
up.username=data['username']
up.name=data['name']
up.set_password(data['password'])
try:
up.save()
except IntegrityError:
state="Duplicacy in Username"
return JsonResponse({'error':state})
if data['register_as']=='C' :
if len(data['sport_id'])>1:
return JsonResponse({'error':"coach cannot register in more than 1 sport"})
else:
for idno in data['sport_id']:
sp=Sport.objects.get(pk=idno)
up.sport.add(sp)
up.coach=idno
up.sportid=replaceindex(up.sportid,idno,'1')
elif data['register_as']=='L' :
if len(data['sport_id'])>1:
return JsonResponse({'error':"captain cannot initially register in more than 1 sport"})
else:
for idno in data['sport_id']:
sp=Sport.objects.get(pk=idno)
up.sport.add(sp)
up.captain=idno
up.sportid=replaceindex(up.sportid,idno,'1')
else:
for idno in data['sport_id']:
sp=Sport.objects.get(pk=int(idno))
up.sport.add(sp)
up.sportid=replaceindex(up.sportid,int(idno),'1')
up.phone=data['phone']
if re.match(r"[^@]+@[^@]+\.[^@]+", data['email'])==None:
state="Invalid Email Address"
#return render(request,'register.html',{'state':state})
return JsonResponse({'error':state})
up.gender=data['gender']
up.email=data['email']
up.grp_leader = 1
up.team = team
if team.activate==1:
up.deleted=1
up.is_active=False
up.save()
to_email = up.email
current_site = get_current_site(request)
message = render_to_string('register/msg.html', {
'user':up,
'domain':current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(up.pk)),
'token': account_activation_token.make_token(up),
})
mail_subject = 'Registration for BOSM \'19'
#mail.send_mail(mail_subject, message,'*****@*****.**',[to_email])
email = EmailMessage(mail_subject, message, to=[to_email])
email.content_subtype = "html"
try:
email.send()
except:
return JsonResponse({'error':'activation mail could not be sent please try again'})
#return HttpResponseRedirect('login/')
switch_data = [8,4]
pusher_client.trigger('my-channel8', 'my-event8', switch_data)
return JsonResponse({'error':'activation mail has been sent. please activate your account and wait for further correspondence'})
return HttpResponseRedirect('/register/')
def api_add_rp(data):
"""Create a recurrring payment account. Accepted format: json
Input fields:
email - required
description - required
payment_amount - required
billing_period - optional, default to 'month'
billing_frequency - optional, default to 1
billing_start_dt - optional, default to today
num_days - optional, default to 0
has_trial_period - optional, default to False
trial_period_start_dt - optional, default to today
trial_period_end_dt - optional, default to today
trial_amount - optional, default to 0
Output:
rp_id - a recurring payment id
result_code
"""
ALLOWED_FIELES = (
'email',
'description',
'payment_amount',
'billing_period',
'billing_frequency',
'billing_start_dt',
'num_days',
'has_trial_period',
'trial_period_start_dt',
'trial_period_end_dt',
'trial_amount',
)
from tendenci.apps.base.utils import validate_email
import dateutil.parser as dparser
from tendenci.apps.imports.utils import get_unique_username
email = data.get('email', '')
payment_amount = data.get('payment_amount', '')
try:
payment_amount = Decimal(payment_amount)
except:
payment_amount = 0
if not all(
[validate_email(email), 'description' in data, payment_amount > 0]):
return False, {}
rp = RecurringPayment()
for key, value in data.items():
if key in ALLOWED_FIELES:
if hasattr(rp, key):
setattr(rp, key, value)
if rp.billing_start_dt:
try:
rp.billing_start_dt = dparser.parse(rp.billing_start_dt)
except:
rp.billing_start_dt = datetime.now()
else:
rp.billing_start_dt = datetime.now()
if rp.trial_period_start_dt:
try:
rp.trial_period_start_dt = dparser.parse(rp.trial_period_start_dt)
except:
rp.trial_period_start_dt = datetime.now()
if rp.trial_period_end_dt:
try:
rp.trial_period_end_dt = dparser.parse(rp.trial_period_end_dt)
except:
rp.trial_period_end_dt = datetime.now()
rp.payment_amount = Decimal(rp.payment_amount)
try:
rp.billing_frequency = int(rp.billing_frequency)
except:
rp.billing_frequency = 1
try:
rp.num_days = int(rp.num_days)
except:
rp.num_days = 1
if rp.has_trial_period in ['True', '1', True, 1] and all(
[rp.trial_period_start_dt, rp.trial_period_end_dt]):
rp.has_trial_period = True
else:
rp.has_trial_period = False
# start the real work
# # get or create a user account with this email
# users = User.objects.filter(email=email)
# if users:
# u = users[0]
# else:
# always create a new user account - This is very important!
# it is to prevent hacker from trying to use somebody else's account.
u = User()
u.email = email
u.username = data.get('username', '')
if not u.username:
u.username = email.split('@')[0]
u.username = get_unique_username(u)
raw_password = data.get('password', '')
if not raw_password:
raw_password = User.objects.make_random_password(length=8)
u.set_password(raw_password)
u.first_name = data.get('first_name', '')
u.last_name = data.get('last_name', '')
u.is_staff = False
u.is_superuser = False
u.save()
# profile = Profile.objects.create(
# user=u,
# creator=u,
# creator_username=u.username,
# owner=u,
# owner_username=u.username,
# email=u.email
# )
# add a recurring payment entry for this user
rp.user = u
# activate it when payment info is received
rp.status_detail = 'inactive'
rp.save()
return True, {'rp_id': rp.id}
]
last_names = [
'Arthur', 'Becks', 'Clark', 'Dennis', 'Ernst', 'Fredericks', 'Greene',
'Harris', 'Jones', 'Kennedy', 'Long', 'Mason', 'North', 'Ortiz', 'Peters',
'Queenan', 'Ramos', 'Shaw', 'Tate', 'Underhill', 'Vetger', 'White'
]
for f in first_names:
for l in last_names:
uname = "%s.%s" % (f, l)
u = User()
u.username = uname
u.first_name = f
u.last_name = l
u.email = '*****@*****.**' % uname
u.save()
users = User.objects.all()
for c in companies:
company = Company(name=c)
company.save()
comps = Company.objects.all()
for d in divisions:
for c in comps:
div = Division(name=d, company=c)
div.save()
def register_employee(csv_path: str) -> None:
"""
Registers lecturers in the platform.
Iterates over the rows of a CSV file
collecting the information to be used
for the account creation.
Parameters
----------
csv_path: str
String containing the path to the
file.
TODO
----------
1. Function do check the information
used during creation is accurate.
"""
msg = ""
columns = [
'id', 'password', 'first_name', 'last_name', 'email', 'department',
'position'
]
with open(csv_path, 'r') as csv_file:
rows = list(csv.reader(csv_file))
if validate_header(columns, rows[0]) == False:
msg = 'Headers are wrong, headers should be: {}'.format(columns)
return False, msg
# Check empty values
for idx, row in enumerate(rows):
if is_empty(row):
msg = 'File has an empty cell at index: {}'.format(idx)
return False, msg
# Checks all cells exist
for idx, row in enumerate(rows):
if len(row) < len(columns):
msg = 'File has missing cells at index: {}'.format(idx)
return False, msg
with open(csv_path, 'r') as csv_file:
reader = csv.DictReader(csv_file, fieldnames=columns)
for idx, row in enumerate(reader): # For each row
if idx != 0: # If row isn't the header
crt_dict = {}
for column in columns:
crt_dict[column] = row[column]
user1 = User.objects.filter(username=crt_dict['id'])
if user1.exists() == False:
user = User()
user.set_password(crt_dict['password'])
user.username = crt_dict['id']
user.first_name = crt_dict['first_name']
user.last_name = crt_dict['last_name']
user.email = crt_dict['email']
user.save()
employee = Employee(user=user,
dpt=crt_dict['department'],
pstn=crt_dict['position'])
employee.save()
return True, msg
def api_rp_setup(data):
"""Create a recurrring payment account. Accepted format: json
Input fields:
email - required
description - required
amount - required
cp_id - customer profile id, required
pp_id - customer payment profile id, required
billing_cycle_start_dt - required
billing_cycle_end_dt - required
response_str - required
login_name
login_password
url
first_name
last_name
billing_period - optional, default to 'month'
billing_frequency - optional, default to 1
billing_start_dt - optional, default to today
num_days - optional, default to 0
has_trial_period - optional, default to False
trial_period_start_dt - optional, default to today
trial_period_end_dt - optional, default to today
trial_amount - optional, default to 0
Output:
rp_id - a recurring payment id
rp_url - url to rp
username
result_code
"""
from tendenci.apps.base.utils import validate_email
import dateutil.parser as dparser
from tendenci.apps.imports.utils import get_unique_username
email = data.get('email', '')
description = data.get('description', '')
url = data.get('url')
payment_amount = data.get('amount', '')
taxable = data.get('taxable', 0)
if taxable in ('True', 'true', '1', 1):
taxable = 1
else:
taxable = 0
try:
tax_rate = Decimal(data.get('tax_rate', 0))
if tax_rate > 1: tax_rate = 0
except:
tax_rate = 0
tax_exempt = data.get('tax_exempt', 0)
if tax_exempt in ('True', 'true', '1', 1):
tax_exempt = 1
else:
tax_exempt = 0
try:
payment_amount = Decimal(payment_amount)
except:
payment_amount = 0
cp_id = data.get('cp_id')
pp_id = data.get('pp_id')
billing_cycle_start_dt = data.get('billing_cycle_start_dt')
if billing_cycle_start_dt:
billing_cycle_start_dt = dparser.parse(billing_cycle_start_dt)
billing_cycle_end_dt = data.get('billing_cycle_end_dt')
if billing_cycle_end_dt:
billing_cycle_end_dt = dparser.parse(billing_cycle_end_dt)
direct_response_str = data.get('response_str')
if not all([
validate_email(email), description, payment_amount > 0, cp_id,
pp_id, billing_cycle_start_dt, billing_cycle_end_dt,
direct_response_str
]):
return False, {}
# 1) get or create user
username = data.get('login_name')
# check if user already exists based on email and username
users = User.objects.filter(email=email, username=username)
if users:
u = users[0]
else:
# create user account
u = User()
u.email = email
u.username = username
if not u.username:
u.username = email.split('@')[0]
u.username = get_unique_username(u)
raw_password = data.get('login_password')
if not raw_password:
raw_password = User.objects.make_random_password(length=8)
u.set_password(raw_password)
u.first_name = data.get('first_name', '')
u.last_name = data.get('last_name', '')
u.is_staff = False
u.is_superuser = False
u.save()
Profile.objects.create(user=u,
creator=u,
creator_username=u.username,
owner=u,
owner_username=u.username,
email=u.email)
# 2) create a recurring payment account
rp = RecurringPayment()
rp.user = u
rp.description = description
rp.url = url
rp.payment_amount = payment_amount
rp.taxable = taxable
rp.tax_rate = tax_rate
rp.tax_exempt = tax_exempt
rp.customer_profile_id = cp_id
rp.billing_start_dt = billing_cycle_start_dt
has_trial_period = data.get('has_trial_period')
trial_period_start_dt = data.get('trial_period_start_dt')
trial_period_end_dt = data.get('trial_period_end_dt')
if has_trial_period in ['True', '1', True, 1] and all(
[trial_period_start_dt, trial_period_end_dt]):
rp.has_trial_period = True
rp.trial_period_start_dt = dparser.parse(trial_period_start_dt)
rp.trial_period_end_dt = dparser.parse(trial_period_end_dt)
else:
rp.has_trial_period = False
rp.status_detail = 'active'
rp.save()
# 3) create a payment profile account
payment_profile_exists = PaymentProfile.objects.filter(
customer_profile_id=cp_id, payment_profile_id=pp_id).exists()
if not payment_profile_exists:
PaymentProfile.objects.create(customer_profile_id=cp_id,
payment_profile_id=pp_id,
owner=u,
owner_username=u.username)
# 4) create rp invoice
billing_cycle = {
'start': billing_cycle_start_dt,
'end': billing_cycle_end_dt
}
rp_invoice = rp.create_invoice(billing_cycle, billing_cycle_start_dt)
rp_invoice.invoice.tender(rp.user)
# 5) create rp transaction
now = datetime.now()
payment = Payment()
payment.payments_pop_by_invoice_user(rp.user, rp_invoice.invoice,
rp_invoice.invoice.guid)
payment_transaction = PaymentTransaction(
recurring_payment=rp,
recurring_payment_invoice=rp_invoice,
payment_profile_id=pp_id,
trans_type='auth_capture',
amount=rp_invoice.invoice.total,
status=True)
payment = payment_update_from_response(payment, direct_response_str)
payment.mark_as_paid()
payment.save()
rp_invoice.invoice.make_payment(rp.user, Decimal(payment.amount))
rp_invoice.invoice.save()
rp_invoice.payment_received_dt = now
rp_invoice.save()
rp.last_payment_received_dt = now
rp.num_billing_cycle_completed += 1
rp.save()
payment_transaction.payment = payment
payment_transaction.result_code = data.get('result_code')
payment_transaction.message_code = data.get('message_code')
payment_transaction.message_text = data.get('message_text')
payment_transaction.save()
site_url = get_setting('site', 'global', 'siteurl')
return True, {
'rp_id':
rp.id,
'rp_url':
'%s%s' %
(site_url, reverse('recurring_payment.view_account', args=[rp.id])),
'username':
rp.user.username
}
def update_profile(user: User, first_name: str, last_name: str, email: str):
user.first_name = first_name
user.last_name = last_name
user.email = email
user.save()
def register(request):
# A boolean value for telling the template whether the registration was successful.
# Set to False initially. Code changes value to True when registration succeeds.
# If it's a HTTP POST, we're interested in processing form data.
if request.method == 'POST':
# Attempt to grab information from the raw POST information.
studentUser = Student()
standardUser = User()
message = []
isregistered = False
firstname = request.POST['firstname']
lastname = request.POST['lastname']
username = request.POST['email']
email = request.POST['email']
password1 = request.POST['password1']
password2 = request.POST['password2']
# studentID = request.POST['idnum'] # No ID number provided
if username == "":
message.append("Please enter a valid username")
if password1 == "" or password2 == "":
message.append("Please fill in both password blocks")
if firstname == "" or lastname == "":
message.append("Please fully fill in your name and last name")
if email == "" or '@' not in str(email):
message.append("Please fill in the email address block")
# if studentID is None or len(studentID) > 8 or len(studentID) < 7:
# message.append("The ID Number provided is invalid")
if (password1 == password2) and (message == []):
# Everything checks out and is all working fine :)
# Create the Standard User first and try storing it in the database
standardUser.set_password(password1)
standardUser.username = username
standardUser.email = email
standardUser.first_name = firstname
standardUser.last_name = lastname
standardUser.is_active = False
standardUser.is_staff = False
standardUser.is_superuser = False
try:
standardUser.save() # Save the Django user in the Database.
# Now let's try putting that Student user in the DB
studentUser.user = standardUser
newRecord = StudentRecord()
newRecord.save()
studentUser.academicRecord = newRecord
only_option = AcademicProgram.objects.get(pk=5) # SOEN!
# # We need to create and save a main schedule as well to the student
studentUser.save()
isregistered = True
# send an email with an SSH hash of the user as a confirmation link:
# since it will cause errors on Windows and most development is being done on windows,
# first check that we are on Linux before attempting to send email.
# Else, just register with no confirmation.
if "inux" in platform.system():
subject, from_email, to = 'Echelon Planner Confirmation', '*****@*****.**', str(standardUser.email)
hasheduser = str(hashlib.sha256(standardUser.email.encode()).hexdigest())
authLink = str(request.get_host()+"/confirm/" + hasheduser)
html_content = '<p>Please click on the following link to confirm your Echelon Planner account: </p><p><a href='+authLink+'>'+authLink+'</a></p>'
msg = EmailMultiAlternatives(subject, html_content, from_email, [standardUser.email])
msg.content_subtype = "html"
msg.send()
else:
standardUser.is_active = True
standardUser.save()
except IntegrityError as problem:
# Student or auth_user was duplicate
isregistered = False
logger.warn(str(problem.args))
message.append("User already Exists!")
# end last If check
if isregistered:
if standardUser.is_active:
return render(request,
'app/login.html',
{'hasMessage': True, 'message': ['Registration is successful.'], 'registered': isregistered})
else:
return render(request,
'app/login.html',
{'hasMessage': True, 'message': ['Registration is successful. Please check your email for a confirmation link before you login.'], 'registered': isregistered})
else: # User was not registered
return render_to_response(
'app/register.html',
{'hasMessage': True, 'message': message, 'registered': isregistered},
context_instance=RequestContext(request))
# end If Request==Post
else: # Request is not Post, just serve the damn page
return render(request,
'app/register.html')
def deal_checkout(request, slug):
'''
FIXME: Clean this mess
@param request:
@param slug: deal slug
'''
try:
deal = Deal.objects.get(slug=slug)
except:
messages.error(request, _('Cannot load requested deal.'))
return HttpResponseRedirect('/')
must_login_error = False
must_login_email = None
user = None
form = None
if request.method == 'POST': # If the form has been submitted...
# try create user
if request.user.is_authenticated():
user = request.user
else:
form = DealCheckoutForm(request.POST)
if form.is_valid():
try:
# FIXME: use form's cleaned_data not raw POST
user = User.objects.get(email=form.cleaned_data['email'])
must_login_error = True
must_login_email = request.POST['email']
form = DealCheckoutForm(initial={})
user_msg = 'An account already exists for ' + user.email + '. Please sign in first.'
user = User()
user.username = form.cleaned_data[
'email'] #str(uuid.uuid4())[:30]
user.first_name = form.cleaned_data['full_name']
user.email = form.cleaned_data['email']
user.set_password(form.cleaned_data['password'])
user.save()
user = authenticate(username=user.username,
password=form.cleaned_data['password'])
if user is not None:
if user.is_active:
login(request, user)
else:
messages.add_message(
request, messages.ERROR,
"Unable to login with these credentails.")
user = None
# Return a 'disabled account' error message
else:
messages.add_message(request, messages.ERROR,
"Cannot create/auth user.")
# Return an 'invalid login' error message.
pass
except Exception, e:
logging.warning("Exception: %s" % e)
user = None
else:
user = None
logging.warning("Invalid form")
def import_profile():
call_command('reset', 'auth', interactive=False)
OLD_USERPIC_PATH = os.path.join('userpic', 'large')
fields = ['jos_users.id', 'jos_users.username', 'jos_users.email', \
'jos_users.registerDate','jos_users.lastvisitDate',
'jos_users.name', 'jos_comprofiler.lastname', \
'jos_comprofiler.avatar', 'jos_comprofiler.cb_sex', \
'jos_comprofiler.cb_dr', 'jos_comprofiler.country', \
'jos_comprofiler.city', 'jos_comprofiler.website',
'jos_comprofiler.location', 'jos_comprofiler.occupation', \
'jos_comprofiler.company', 'jos_comprofiler.address', \
'jos_comprofiler.phone', 'jos_comprofiler.cb_interest', \
'jos_comprofiler.interests', 'jos_users.password']
sql = "SELECT %s FROM jos_users JOIN jos_comprofiler\
ON jos_users.id=jos_comprofiler.user_id" % ', '.join(fields)
cursor = db.cursor()
cursor.execute(sql)
all_users = cursor.fetchall()
count = 0
bar = progressbar.ProgressBar(maxval=len(all_users),
widgets=[
'import profile: ',
progressbar.SimpleProgress(),
]).start()
decode = lambda x: unicode(x, 'utf8')
for row in all_users:
username = decode(row[1])
cyrillic = sum(1 for char in username
if u'\u0400' <= char <= u'\u04FF')
if cyrillic > 0:
try:
username = decode(pytils.translit.translify(username))
except ValueError:
username = str(datetime.now())
username = re.sub(r'[^A-Za-z0-9_]', '_', username)
username = check_username(username)
if User.objects.filter(pk=row[0]):
continue
user = User(pk=row[0], username=username)
try:
user.last_login = datetime.strptime(str(row[4]), \
'%Y-%m-%d %H:%M:%S')
except ValueError:
pass
try:
user.date_joined = datetime.strptime(str(row[3]), \
'%Y-%m-%d %H:%M:%S')
except ValueError:
pass
try:
user.first_name = decode(row[5][:30])
except:
pass
try:
user.email = decode(row[2][:128])
except:
pass
try:
user.save()
except:
print user.id
old_auth = OldAuth(user=user, password=row[20])
old_auth.save()
userpic = row[7]
if userpic:
path = os.path.join(OLD_USERPIC_PATH, userpic)
user.profile.userpic = path
if row[8] == 'женский':
user.profile.sex = 'female'
elif row[8] == 'мужской':
user.profile.sex = 'male'
user.profile.birthday = row[9]
try:
user.profile.country = decode(row[10][:50])
except:
pass
try:
user.profile.city = decode(row[11][:50])
except:
pass
try:
user.profile.web_site = row[12]
except:
pass
try:
user.profile.icq = decode(row[13][:15])
except:
pass
try:
user.profile.profession = decode(row[14])
except:
pass
try:
user.profile.company = decode(row[15])
except:
pass
try:
user.profile.address = decode(row[16])
except:
pass
try:
user.profile.phone_number = decode(row[17][:50])
except:
pass
try:
user.profile.interest = decode(str(row[18]))
except:
pass
try:
user.profile.about = decode(row[19])
except:
pass
user.profile.save()
count += 1
bar.update(count)
bar.finish()
magog = User.objects.get(pk=1791)
magog.is_staff, magog.is_superuser = True, True
magog.save()
