def register(request, registration_key):
if settings.CLOSED_NETWORK:
rc = RequestContext(request)
return render_to_response('auth/register_info.html', rc)
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = RegistrationForm(request.POST)
# check whether it's valid:
if form.is_valid():
username = form.cleaned_data.get('username')
email = form.cleaned_data.get('email')
password = form.cleaned_data.get('password')
registration_key = form.cleaned_data.get('registration_key')
u = User.objects.create_user(username=username,
email=email,
password=password)
user = djauth.authenticate(username=username, password=password)
if settings.CLOSED_NETWORK:
rk = InvitationKey.objects.get(key=registration_key)
p = UserProfile(user=u, invited_by=rk.user)
p.save()
rk.delete()
else:
p = UserProfile(user=u, invited_by=None)
p.save()
try:
wcm = WelcomeMail()
wcm.send(username=user.username, recipient_list=[email])
rbe_logger.info("Send welcome message to {}".format(email))
except Exception as e:
rbe_logger.exception(e)
djauth.login(request, user)
return HttpResponseRedirect(
reverse('profile', kwargs={'user_id': request.user.id}))
# if a GET (or any other method) we'll create a blank form
else:
form = RegistrationForm(initial={'registration_key': registration_key})
return render(request, 'auth/register.html', {
'form': form,
'closed_network': settings.CLOSED_NETWORK
})
def handle(self, *args, **options):
User.objects.filter(username='******').delete()
User.objects.filter(username='******').delete()
u = User.objects.create_superuser('sheepy', '*****@*****.**',
'aqwsderf')
p = UserProfile(user=u, invited_by=None)
p.save()
u = User.objects.create_superuser('sheepy2', '*****@*****.**',
'aqwsderf')
p = UserProfile(user=u, invited_by=None)
p.save()
self.stdout.write(self.style.SUCCESS('Successfully create test user!'))
def register(request):
self_register = SettingProperties.get_int(constants.OPPIA_ALLOW_SELF_REGISTRATION, settings.OPPIA_ALLOW_SELF_REGISTRATION)
if not self_register:
raise Http404
if request.method == 'POST': # if form submitted...
form = RegisterForm(request.POST)
if form.is_valid(): # All validation rules pass
# Create new user
username = form.cleaned_data.get("username")
email = form.cleaned_data.get("email")
password = form.cleaned_data.get("password")
first_name = form.cleaned_data.get("first_name")
last_name = form.cleaned_data.get("last_name")
user = User.objects.create_user(username, email, password)
user.first_name = first_name
user.last_name = last_name
user.save()
user_profile = UserProfile()
user_profile.user = user
user_profile.job_title = form.cleaned_data.get("job_title")
user_profile.organisation = form.cleaned_data.get("organisation")
user_profile.save()
u = authenticate(username=username, password=password)
if u is not None and u.is_active:
login(request, u)
return HttpResponseRedirect('thanks/')
return HttpResponseRedirect('thanks/') # Redirect after POST
else:
form = RegisterForm(initial={'next': filter_redirect(request.GET), })
return render(request, 'oppia/form.html',
{'form': form,
'title': _(u'Register'), })
def home_view(request):
if request.user.is_authenticated:
# create profile if none exists (for first admin user login and historical for very old users)
try:
request.user.userprofile
except UserProfile.DoesNotExist:
up = UserProfile()
up.user = request.user
up.save()
up = request.user.userprofile
# if user is student redirect to their scorecard
if up.is_student_only():
return HttpResponseRedirect(reverse('profile:user_activity',
args=[request.user.id]))
# is user is teacher redirect to teacher home
if up.is_teacher_only():
return HttpResponseRedirect(reverse('oppia:teacher_index'))
# admin/staff view
form, activity = home_view_admin_authenticated(request)
leaderboard = Points.get_leaderboard(10)
else:
activity = []
leaderboard = None
form = None
return render(request, 'oppia/home.html',
{'form': form,
'activity_graph_data': activity,
'leaderboard': leaderboard})
def get_user_from_uploaded_log(messages_delegate, user):
username = user['username']
for field in user:
if user[field] == "null":
user[field] = None
if not User.objects.filter(username=username).exists():
# User was registered offline, we create a new one
req_user = User(
username=username,
email=user['email'] if 'email' in user
and user['email'] is not None else '',
)
req_user.password = user['password'] \
if 'password' in user else make_password(None)
req_user.first_name = user.get('firstname', '')
req_user.last_name = user.get('lastname', '')
req_user.save()
user_profile = UserProfile(user=req_user)
messages_delegate.warning(
_(u"%(username)s did not exist previously, and was created."
% {'username': username}),
'danger')
else:
req_user = User.objects.filter(username=username).first()
user_profile, created = UserProfile.objects.get_or_create(
user=req_user)
return req_user, user_profile
def process_uploaded_file(request, json_data):
if 'users' in json_data:
for user in json_data['users']:
username = user['username']
print(_(u"processing activity log for %s" % username))
if User.objects.filter(username=username).count() == 0:
print(_(u"New user!"))
# User was registered offline, we create a new one
new_user = User(
username=username,
email=user['email'],
)
new_user.password = user[
'password'] if 'password' in user else make_password(None)
new_user.first_name = user['firstname']
new_user.last_name = user['lastname']
new_user.save()
user_profile = UserProfile()
user_profile.user = new_user
user_profile.phone_number = user[
'phoneno'] if 'phoneno' in user else None
user_profile.job_title = user[
'jobtitle'] if 'jobtitle' in user else None
user_profile.organisation = user[
'organisation'] if 'organisation' in user else None
user_profile.save()
messages.warning(
request,
_(u"%(username)s did not exist previously, and was created."
% {'username': username}), 'danger')
try:
user_api_key, created = ApiKey.objects.get_or_create(
user__username=username)
if (created):
messages.warning(
request,
_(u"Generated new ApiKey for %(username)s : %(apikey)s"
% {
'username': username,
'apikey': user_api_key.key
}), 'danger')
if 'trackers' in user:
process_uploaded_trackers(request, user, user_api_key)
if 'quizresponses' in user:
process_uploaded_quizresponses(request, user, user_api_key)
except ApiKey.DoesNotExist:
messages.warning(
request,
_(u"%(username)s not found. Please check that this file is being uploaded to the correct server."
% {'username': username}), 'danger')
print(_(u"No user api key found for %s" % user['username']))
def handle(self, *args, **options):
possibilities = list(
itertools.product([
'Anne', 'Robert', 'Marie', 'Tove', 'Jens', 'Ines', 'Lars',
'Karl'
], [
'Larson', 'Nilson', 'Weier', 'Mueller', 'Chu-Xi', 'Wa',
'Halakkai', 'Czetec'
]))
random.shuffle(possibilities)
tags = [
'banana', 'apple', 'fruit', 'ice', 'green', 'red', 'Anne',
'Robert', 'Marie', 'Tove', 'Jens', 'Ines', 'Lars', 'Karl',
'Larson', 'Nilson', 'Weier', 'Mueller', 'Chu-Xi', 'Wa', 'Halakkai',
'Czetec'
]
tags_obj = []
for t in tags:
tg = SlugPhrase.objects.get_or_create(value=t)[0]
tags_obj.append(tg)
usernames = [e[0] + " " + e[1] for e in possibilities[0:25]]
users = []
for name in usernames:
u = User.objects.create_user(
name, '{}@heleska.de'.format(name.replace(' ', '_')),
'aqwsderf')
iby = None
if len(users) > 0 and random.random() > 0.3:
iby = random.choice(users)
p = UserProfile(user=u, invited_by=iby)
p.about_me_text = "Some about me"
p.save()
long = str(random.randint(-900, 900) / 10.0)
lang = str(random.randint(-1800, 1800) / 10.0)
l = Location(user=u,
longitude=long,
latitude=lang,
position_updated=datetime.datetime.today())
l.save()
num = random.randint(0, len(tags))
for e in random.sample(tags_obj, num):
UserSlugs(user=u, slug=e).save()
users.append(u)
self.stdout.write(
self.style.SUCCESS('Successfully create a bunch of users!'))
def process_register_base_profile(self, bundle):
user_profile = UserProfile()
user_profile.user = bundle.obj
if 'jobtitle' in bundle.data:
user_profile.job_title = bundle.data['jobtitle']
if 'organisation' in bundle.data:
user_profile.organisation = bundle.data['organisation']
if 'phoneno' in bundle.data:
user_profile.phone_number = bundle.data['phoneno']
user_profile.save()
def post(self, request, *args, **kwargs):
pk = kwargs.get('pk')
self.get_object()
form = self.get_form()
if form.is_valid():
user_role_id = int(self.request.POST[u'role'])
unit_id = int(self.request.POST[u'organizationalunit'])
user = form.save()
user_role = UserRole.objects.get(pk=user_role_id)
unit = OrganizationalUnit.objects.get(pk=unit_id)
cd = form.cleaned_data
add_info = cd['additional_information']
# Create
if not pk:
user_profile = UserProfile(
user=user,
user_role=user_role,
organizationalunit=unit,
additional_information=add_info,
)
else:
# Update
user_profile = user.userprofile
user_profile.user = user
user_profile.user_role = user_role
user_profile.organizationalunit = unit
cd = form.cleaned_data
user_profile.additional_information = add_info
user_profile.save()
# Send email to newly created users
if not pk:
try:
KUEmailMessage.send_email(
EmailTemplateType.system__user_created, {
'user': user,
'password': form.cleaned_data['password1'],
}, [user], user)
except Exception as e:
print "Error sending mail to user: %s" % e
messages.add_message(request, messages.INFO,
_(u'Brugeren %s blev gemt' % user.username))
return super(CreateUserView, self).form_valid(form)
else:
return self.form_invalid(form)
def create_account(request):
try:
email = request.POST.get("email")
username = request.POST.get("username")
password = request.POST.get("password")
user = User.objects.create_user(username=username,
email=email,
password=password)
user.save()
#create userprofile
profile = UserProfile(user_id=user.id)
profile.save()
except:
print("profile could not be created")
#TODO: perform checks to see if they exist already!!
return TemplateResponse(request, 'main/index.html')
def register_form_process(form):
# Create new user
username = form.cleaned_data.get("username")
email = form.cleaned_data.get("email")
password = form.cleaned_data.get("password")
first_name = form.cleaned_data.get("first_name")
last_name = form.cleaned_data.get("last_name")
user = User.objects.create_user(username, email, password)
user.first_name = first_name
user.last_name = last_name
user.save()
# create UserProfile record
user_profile = UserProfile()
user_profile.user = user
user_profile.job_title = form.cleaned_data.get("job_title")
user_profile.organisation = form.cleaned_data.get("organisation")
user_profile.save()
# save any custom fields
custom_fields = CustomField.objects.all()
for custom_field in custom_fields:
if custom_field.type == 'int':
profile_field = UserProfileCustomField(
key_name=custom_field,
user=user,
value_int=form.cleaned_data.get(custom_field.id))
elif custom_field.type == 'bool':
profile_field = UserProfileCustomField(
key_name=custom_field,
user=user,
value_bool=form.cleaned_data.get(custom_field.id))
else:
profile_field = UserProfileCustomField(
key_name=custom_field,
user=user,
value_str=form.cleaned_data.get(custom_field.id))
if (form.cleaned_data.get(custom_field.id) is not None
and form.cleaned_data.get(custom_field.id) != '') \
or custom_field.required is True:
profile_field.save()
def process(self, request):
if request.user.is_authenticated:
# create profile if none exists (for first admin user login and
# historical for very old users)
try:
request.user.userprofile
except UserProfile.DoesNotExist:
up = UserProfile()
up.user = request.user
up.save()
up = request.user.userprofile
# if user is student redirect to their scorecard
if up.is_student_only():
return HttpResponseRedirect(
reverse('profile:user_activity', args=[request.user.id]))
# is user is teacher redirect to teacher home
if up.is_teacher_only():
return HttpResponseRedirect(reverse('oppia:teacher_index'))
if permissions.is_manager_only(request.user):
return HttpResponseRedirect(reverse('oppia:manager_index'))
# admin/staff view
form, activity = self.admin_authenticated(request)
leaderboard = Points.get_leaderboard(
constants.LEADERBOARD_HOMEPAGE_RESULTS_PER_PAGE)
else:
activity = []
leaderboard = None
form = None
return render(
request, 'oppia/home.html', {
'form': form,
'activity_graph_data': activity,
'leaderboard': leaderboard
})
def process_upload_file_save_user(self, row):
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:
password = row['password']
else:
password = User.objects.make_random_password()
auto_password = True
user.set_password(password)
try:
user.save()
except IntegrityError:
return {
'username': row['username'],
'created': False,
'message': _(u'User already exists')
}
up = UserProfile()
up.user = user
for col_name in row:
setattr(up, col_name, row[col_name])
up.save()
result = {
'created': True,
'username': row['username'],
}
if auto_password:
result['message'] = _(u'User created with password: %s' % password)
else:
result['message'] = _(u'User created')
return result
def create_profile(user, params):
try:
if user and user.is_authenticated:
raise Exception("Zaten giriş yapmış durumdasınız.")
if UserProfile.objects.filter(email=params["email"]).exists():
raise Exception('Lütfen başka bir e-posta adresi kullanın.')
password = params['password']
password_again = params['password_again']
if password != password_again:
raise Exception('Girdiğiniz parolalar aynı değil. Lütfen tekrar deneyiniz..')
else:
try:
password_validation.validate_password(password)
except ValidationError:
raise Exception('Girilen parololar doğru değil.')
params["password"] = make_password(str(password))
params.pop("password_again")
profile = UserProfile(email=params['email'], password=params['password'], name=params['name'],
surname=params['surname'], secret_answer=params['secret_answer'], type=params['type'])
profile.save()
except Exception as ex:
raise Exception(ex)
def dispatch(self, request, *args, **kwargs):
if request.user.is_authenticated:
# create profile if none exists (for first admin user login and
# historical for very old users)
try:
request.user.userprofile
except UserProfile.DoesNotExist:
up = UserProfile()
up.user = request.user
up.save()
up = request.user.userprofile
# if user is student redirect to their scorecard
if up.is_student_only():
return HttpResponseRedirect(reverse('profile:user_activity', args=[request.user.id]))
# is user is teacher redirect to teacher home
if up.is_teacher_only():
return HttpResponseRedirect(reverse('oppia:teacher_index'))
if permissions.is_manager_only(request.user):
return HttpResponseRedirect(reverse('oppia:manager_index'))
return super().get(request, *args, **kwargs)
def test_model_supports_twitter(self):
u = UserProfile()
self.assertTrue(hasattr(u, 'twitter'))
def obj_create(self, bundle, **kwargs):
self_register = SettingProperties.get_int(constants.OPPIA_ALLOW_SELF_REGISTRATION, settings.OPPIA_ALLOW_SELF_REGISTRATION)
if not self_register:
raise BadRequest(_(u'Registration is disabled on this server.'))
required = ['username', 'password', 'passwordagain', 'email', 'firstname', 'lastname']
check_required_params(bundle, required)
data = {'username': bundle.data['username'],
'password': bundle.data['password'],
'password_again': bundle.data['passwordagain'],
'email': bundle.data['email'] if 'email' in bundle.data else '',
'first_name': bundle.data['firstname'],
'last_name': bundle.data['lastname'], }
rf = RegisterForm(data)
if not rf.is_valid():
str = ""
for key, value in rf.errors.items():
for error in value:
str += error + "\n"
raise BadRequest(str)
else:
username = bundle.data['username']
password = bundle.data['password']
email = bundle.data['email']
first_name = bundle.data['firstname']
last_name = bundle.data['lastname']
try:
bundle.obj = User.objects.create_user(username, email, password)
bundle.obj.first_name = first_name
bundle.obj.last_name = last_name
bundle.obj.save()
user_profile = UserProfile()
user_profile.user = bundle.obj
if 'jobtitle' in bundle.data:
user_profile.job_title = bundle.data['jobtitle']
if 'organisation' in bundle.data:
user_profile.organisation = bundle.data['organisation']
if 'phoneno' in bundle.data:
user_profile.phone_number = bundle.data['phoneno']
user_profile.save()
u = authenticate(username=username, password=password)
if u is not None and u.is_active:
login(bundle.request, u)
# Add to tracker
tracker = Tracker()
tracker.user = u
tracker.type = 'register'
tracker.ip = bundle.request.META.get('REMOTE_ADDR', api.DEFAULT_IP_ADDRESS)
tracker.agent = bundle.request.META.get('HTTP_USER_AGENT', 'unknown')
tracker.save()
key = ApiKey.objects.get(user=u)
bundle.data['api_key'] = key.key
except IntegrityError:
raise BadRequest(_(u'Username "%s" already in use, please select another' % username))
del bundle.data['passwordagain']
del bundle.data['password']
del bundle.data['firstname']
del bundle.data['lastname']
return bundle
def test_model_supports_twitter_optout(self):
u = UserProfile()
self.assertTrue(hasattr(u, 'display_twitter'))
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, 'profile/upload.html', {
'form': form,
'results': results
})
def home_view(request):
activity = []
leaderboard = None
if request.user.is_authenticated:
# create profile if none exists (historical for very old users)
try:
up = request.user.userprofile
except UserProfile.DoesNotExist:
up = UserProfile()
up.user = request.user
up.save()
dashboard_accessed.send(sender=None, request=request, data=None)
# if user is student redirect to their scorecard
if up.is_student_only():
return HttpResponseRedirect(
reverse('profile_user_activity', args=[request.user.id]))
# is user is teacher redirect to teacher home
if up.is_teacher_only():
return HttpResponseRedirect(reverse('oppia_teacher_home'))
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
interval = 'days'
if request.method == 'POST':
form = DateRangeIntervalForm(request.POST)
if form.is_valid():
start_date = form.cleaned_data.get("start_date")
start_date = datetime.datetime.strptime(start_date, "%Y-%m-%d")
end_date = form.cleaned_data.get("end_date")
end_date = datetime.datetime.strptime(end_date, "%Y-%m-%d")
interval = form.cleaned_data.get("interval")
else:
data = {}
data['start_date'] = start_date
data['end_date'] = end_date
data['interval'] = interval
form = DateRangeIntervalForm(initial=data)
if interval == 'days':
no_days = (end_date - start_date).days + 1
tracker_stats = CourseDailyStats.objects.filter(
day__gte=start_date,
day__lte=end_date).values('day').annotate(count=Sum('total'))
for i in range(0, no_days, +1):
temp = start_date + datetime.timedelta(days=i)
count = next(
(dct['count']
for dct in tracker_stats if dct['day'] == temp.date()), 0)
activity.append([temp.strftime("%d %b %Y"), count])
else:
delta = relativedelta(months=+1)
no_months = 0
tmp_date = start_date
while tmp_date <= end_date:
tmp_date += delta
no_months += 1
for i in range(0, no_months, +1):
temp = start_date + relativedelta(months=+i)
month = temp.strftime("%m")
year = temp.strftime("%Y")
count = CourseDailyStats.objects.filter(
day__month=month,
day__year=year).aggregate(total=Sum('total')).get(
'total', 0)
activity.append(
[temp.strftime("%b %Y"), 0 if count is None else count])
leaderboard = Points.get_leaderboard(10)
else:
form = None
return render(request, 'oppia/home.html', {
'form': form,
'activity_graph_data': activity,
'leaderboard': leaderboard
})
