def test_create_view_edit_profile(self):
"""
when user enter his favorite channels and Favorite team, in view profile he can see his last entered choices.
So I check create Profile reponse request.POST and data which is storing in DB(leads to view profile).
After so many attempts came to know that, request.POST data is not getting saved, so created data manually and
testing.If the values don't match test case will fail
"""
channel = "Hallow23"
team = "XXC"
comment = "manual insert"
form = UserProfile(id = 1, mainUser_id = 1, FavoriteChannel =\
"Hallow23", \
FavoriteTeam = "XXC", Comment = "manual insert")
form.save()
profile = UserProfile.objects.filter(mainUser_id = 1). \
order_by('-id')[0]
#checking Channel user enter in
#createProfile(),or editProfile(),saving in
#UserProfile table, and it is getting retriev from DB
#to show the data in View Profile
print("profile.FavoriteChANEL", profile.FavoriteChannel)
self.assertEqual(channel, profile.FavoriteChannel)
self.assertEqual(team, profile.FavoriteTeam)
self.assertEqual(comment, profile.Comment)
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 create_user(username, email, password):
u = User.objects.create_user(username=username, email=email, password=password)
user = djauth.authenticate(username=username, password=password)
p = UserProfile(user=u)
p.save()
g, created = Group.objects.get_or_create(name='all_users')
g.user_set.add(u)
ve = EmailVerification(user=user, key=uuid.uuid4().hex)
ve.save()
return user
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 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 render_response(self, _template, context = None):
# Renders a template and writes the result to the response.
if context is None:
context = self.context
# Put things that are needed in all templates here
context["profile"] = UserProfile.get_current_user()
rv = self.jinja2.render_template(_template, **context)
self.response.write(rv)
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 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 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 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 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 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 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 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 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 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 register_publicuser(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.
registered = False
user_group = 'User'
args = {}
args.update(csrf(request))
# If it's a HTTP POST, we're interested in processing form data.
if request.method == 'POST':
# Attempt to grab information from the raw form information.
# Note that we make use of both UserForm and UserProfileForm.
user_form = UserForm(data=request.POST)
user_profile_form = UserProfileForm(data=request.POST)
args['user_form'] = user_form
# If the two forms are valid...
if user_form.is_valid() and user_profile_form.is_valid():
# Save the user's form data to the database.
user = user_form.save()
# Now we hash the password with the set_password method.
# Once hashed, we can update the user object.
username = user_form.cleaned_data['username']
email = user_form.cleaned_data['email']
user.set_password(user.password)
user.is_active = False
user.save()
# Now sort out the UserProfile instance.
# Since we need to set the user attribute ourselves, we set commit=False.
# This delays saving the model until we're ready to avoid integrity problems.
profile = user_profile_form.save(commit=False)
profile.user = user
# Generate activation key
salt = hashlib.sha1(str(random.random()).encode('utf-8')).hexdigest()[:5]
activation_key = hashlib.sha1((salt+email).encode('utf-8')).hexdigest()
key_expires = datetime.datetime.today() + datetime.timedelta(2)
profile = UserProfile(user=user, activation_key=activation_key, key_expires=key_expires)
# Now we save the UserProfile model instance.
profile.save()
# Set user group - for this, we set it to 'User'
g = Group.objects.get(name = user_group)
g.user_set.add(user)
#Empty public user profile
publicprofile = PublicUserProfile(userprofile = profile, allergies = "", height = 0, weight = 0)
publicprofile.save()
# Update our variable to tell the template registration was successful.
registered = True
emailnotify("publicuser", username, email, activation_key)
# Invalid form or forms - mistakes or something else?
# Print problems to the terminal.
# They'll also be shown to the user.
else:
print(user_form.errors, user_profile_form.errors)
# Not a HTTP POST, so we render our form using two ModelForm instances.
# These forms will be blank, ready for user input.
else:
user_form = UserForm()
user_profile_form = UserProfileForm()
# Render the template depending on the context.
return render_to_response(
'registration/public-signup.html',
{'user_form': user_form, 'user_profile_form': user_profile_form, 'registered': registered},
RequestContext(request))
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 twitter_return(request, window_type):
"""
A user gets redirected here after hitting Twitter and authorizing your
app to use their data.
This is the view that stores the tokens you want
for querying data. Pay attention to this.
"""
# Now that we've got the magic tokens back from Twitter, we need to exchange
# for permanent ones and store them...
api = Twython(
twitter_token = CONSUMER_KEY,
twitter_secret = CONSUMER_SECRET,
oauth_token = request.session['request_token']['oauth_token'],
oauth_token_secret = request.session['request_token']['oauth_token_secret']
)
# Retrieve the tokens we want...
twitter_tokens = api.get_authorized_tokens()
api = get_authorized_twython(twitter_tokens)
username = '******'.join([str(twitter_tokens['user_id']), 'twitter'])
request.session['twitter_tokens'] = twitter_tokens
# No need to call authorize because of get_authorized_tokens()
# Probable bug - need to fix when TwitterUserProfile already exists without
# user having logged in.
try:
user = User.objects.get(username=username)
up = UserProfile.objects.get(user=user)
twitter_user = TwitterUserProfile.objects.get(user=up)
except:
# Create User, UserProfile, TwitterUserProfile
twitter_user = api.verifyCredentials()
if 'error' in twitter_user:
del request.session['access_token']
del request.session['request_token']
return HttpResponse("Unable to authenticate you!")
name = twitter_user['name'].split()
if(len(name) > 0):
first_name = name[0]
else:
first_name = "Unknown User"
if(len(name) > 1):
last_name = name[1]
else:
last_name = ""
user = User(username=username, first_name=first_name, last_name=last_name)
user.set_unusable_password()
user.save()
up = UserProfile(user=user)
# whale = Whale(species=WhaleSpecies.getDefaultSpecies())
# whale.save()
# up.whale = whale
up.save()
try:
tp = TwitterUserProfile.objects.get(user_id=user.id)
except TwitterUserProfile.DoesNotExist:
tp = TwitterUserProfile()
tp.__dict__.update(twitter_user)
tp.user = up
tp.oauth_token = twitter_tokens['oauth_token']
tp.oauth_secret = twitter_tokens['oauth_token_secret']
tp.active_classifier = DEFAULT_CLASSIFIER
tp.classifier_version = DEFAULT_CLASSIFIER_VERSION
tp.save()
# Hack so don't have to call authenticate
user.backend = 'twitter.auth.TwitterAuthentication'
login(request, user)
if window_type == 'popup':
return render_to_response("twitter/twitter_return.html", {'twitter_user': twitter_user},
context_instance=RequestContext(request))
elif window_type == 'api':
return HttpResponse()
else:
return HttpResponseRedirect("/")
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 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})
def test_model_supports_twitter(self):
u = UserProfile()
self.assertTrue(hasattr(u, 'twitter'))
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
})
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'],
'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
