def post(self, request, *args, **kwargs):
context = super(StaffFormView, self).get_context_data(**kwargs)
context['departments'] = CompanyDepartments.objects.all()
profile_form = UserProfileFrom(request.POST)
form = UserCreateForm(request.POST)
if form.is_valid() and profile_form.is_valid():
new_user = form.save()
new_user.email = request.POST.get('username')
new_user.save()
try:
department_id = CompanyDepartments.objects.get(uuid=request.POST.get('department'))
except CompanyDepartments.DoesNotExist:
department_id = None
user_profile = UserProfile(
user_id=new_user,
phone=request.POST.get('phone'),
home_phone=request.POST.get('home_phone'),
work_phone=request.POST.get('office_phone'),
department=department_id,
designation=request.POST.get('designation')
)
user_profile.save()
return HttpResponseRedirect("/staff-list/")
else:
context['form'] = form
context['profile_form'] = profile_form
return render(request, self.template_name, context)
def user_create(request):
from hashlib import sha1
ctx = {}
username = request.REQUEST.get("username")
password = request.REQUEST.get("password")
signature = request.REQUEST.get("signature")
email = request.REQUEST.get("email", "")
m = sha1()
m.update(":" + username + ":" + password + ":" + settings.SHARED_SECRET +
":")
if m.hexdigest() != signature:
ctx["ok"] = False
return ctx
(user, created) = User.objects.get_or_create(username=username)
user.is_active = True
user.email = email
user.set_password(password)
user.save()
pro = UserProfile()
pro.user = user
pro.save()
p = Polity.objects.get(id=1)
p.members.add(user)
ctx["ok"] = True
ctx["username"] = user.username
ctx["id"] = user.id
return ctx
def create(self, validated_data):
user = User.objects.create_user(**validated_data.pop('user'),
is_staff=True)
_profile = UserProfile(**validated_data, user=user)
_profile.save()
return _profile
def user_create(request):
from hashlib import sha1
ctx = {}
username = request.REQUEST.get("username")
password = request.REQUEST.get("password")
signature = request.REQUEST.get("signature")
email = request.REQUEST.get("email", "")
m = sha1()
m.update(":" + username + ":" + password + ":" + settings.SHARED_SECRET + ":")
if m.hexdigest() != signature:
ctx["ok"] = False
return ctx
(user, created) = User.objects.get_or_create(username=username)
user.is_active = True
user.email = email
user.set_password(password)
user.save()
pro = UserProfile()
pro.user = user
pro.save()
p = Polity.objects.get(id=1)
p.members.add(user)
ctx["ok"] = True
ctx["username"] = user.username
ctx["id"] = user.id
return ctx
def create_inactive_user(self, username, email, password,
first_name,
last_name,
career, favorite, gender, age, address, phone, city, state, country, zip,
send_email=True,
profile_callback=None ):
"""
Create a new, inactive ``User``, generate a
``RegistrationProfile`` and email its activation key to the
``User``, returning the new ``User``.
By default, an activation email will be sent to the new
user. To disable this, pass ``send_email=False``.
"""
new_user = User.objects.create_user(username, email, password)
new_user.email = email
new_user.first_name = first_name
new_user.last_name = last_name
new_user.is_active = False
"""
set default user_group when registration
"""
new_user.save()
new_profile = UserProfile(user=new_user,
career=career,
gender=gender,
age=age,
address=address,
phone=phone,
city=city,
state=state,
country=country,
zip=zip
)
new_profile.save()
registration_profile = self.create_profile(new_user)
if send_email:
from django.core.mail import send_mail
current_site = Site.objects.get_current()
subject = render_to_string('registration/activation_email_subject.txt',
{ 'site': current_site })
# Email subject *must not* contain newlines
subject = ''.join(subject.splitlines())
fullname = new_user.last_name + " " + new_user.first_name
message = render_to_string('registration/activation_email.txt',
{ 'activation_key': registration_profile.activation_key,
'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS,
'site': current_site,
'fullname': fullname,
})
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [new_user.email])
return new_user
def populate_users():
print("Populating users...")
users = [{
"username": "******",
"first_name": "",
"last_name": "",
"email": "",
"password": make_password("admin"),
"is_staff": True,
"is_admin": True,
"is_superuser": True
}, {
"username": "******",
"first_name": "Bobby",
"last_name": "Renson",
"email": "*****@*****.**",
"password": make_password("test"),
"is_staff": False,
"is_admin": False,
"is_superuser": False
}, {
"username": "******",
"first_name": "Meghan",
"last_name": "Bright",
"email": "*****@*****.**",
"password": make_password("test"),
"is_staff": False,
"is_admin": False,
"is_superuser": False
}, {
"username": "******",
"first_name": "Victoire",
"last_name": "Vert",
"email": "*****@*****.**",
"password": make_password("test"),
"is_staff": False,
"is_admin": False,
"is_superuser": False
}]
for data in users:
user, created = User.objects.get_or_create(username=data['username'])
if created:
user.first_name = data['first_name']
user.last_name = data['last_name']
user.email = data['email']
user.password = data['password']
user.is_staff = data['is_staff']
user.is_admin = data['is_admin']
user.is_superuser = data['is_superuser']
user.save()
profile = UserProfile(
user=User.objects.get(username=data['username']),
profile_pic="profile_images/" + data['username'].lower() +
"-profile.jpg")
profile.save()
def save(self, commit=True):
user = super(SgzUserCreationForm, self).save(commit=False)
user.email = '{}@neverland.cc'.format(user.username)
if commit:
user.save()
profile = UserProfile(user=user)
profile.save()
return user
def login(request,
template_name='registration/login.html',
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=AuthenticationForm,
current_app=None,
extra_context=None):
"""
Displays the login form and handles the login action.
"""
redirect_to = request.POST.get(redirect_field_name,
request.GET.get(redirect_field_name, ''))
if request.method == "POST":
form = authentication_form(request, data=request.POST)
if form.is_valid():
# Ensure the user-originating redirection url is safe.
if not is_safe_url(url=redirect_to, host=request.get_host()):
redirect_to = resolve_url(settings.LOGIN_REDIRECT_URL)
# Okay, security check complete. Log the user in.
auth_login(request, form.get_user())
# Make sure that profile exists
try:
UserProfile.objects.get(user=request.user)
except UserProfile.DoesNotExist:
profile = UserProfile()
profile.user = request.user
profile.save()
if hasattr(settings, 'SAML_1'): # Is SAML 1.2 support enabled?
if not request.user.userprofile.verified_ssn:
return HttpResponseRedirect(settings.SAML_1['URL'])
if hasattr(settings, 'ICEPIRATE'): # Is IcePirate support enabled?
configure_external_member_db(request.user,
create_if_missing=False)
return HttpResponseRedirect(redirect_to)
else:
form = authentication_form(request)
current_site = get_current_site(request)
context = {
'form': form,
redirect_field_name: redirect_to,
'site': current_site,
'site_name': current_site.name,
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request,
template_name,
context,
current_app=current_app)
def create(self, validated_data):
user_data = validated_data.pop('user')
# create user profile
user = User.objects.create_user(**user_data)
# create user profile
user_profile = UserProfile(**validated_data, user=user)
user_profile.save()
return user_profile
def setUp(self):
self.user = UserProfile(email='*****@*****.**',
name='Test',
url='https://test.com/postback/',
password='******')
self.user.save()
self.obj = StatusProcess(user_profile=self.user,
id_process='12345678901',
status_process='Em análise')
self.obj.save()
def login(request, template_name='registration/login.html',
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=AuthenticationForm,
current_app=None, extra_context=None):
"""
Displays the login form and handles the login action.
"""
redirect_to = request.POST.get(redirect_field_name,
request.GET.get(redirect_field_name, ''))
if request.method == "POST":
form = authentication_form(request, data=request.POST)
if form.is_valid():
# Ensure the user-originating redirection url is safe.
if not is_safe_url(url=redirect_to, host=request.get_host()):
redirect_to = resolve_url(settings.LOGIN_REDIRECT_URL)
# Okay, security check complete. Log the user in.
auth_login(request, form.get_user())
# Make sure that profile exists
try:
UserProfile.objects.get(user=request.user)
except UserProfile.DoesNotExist:
profile = UserProfile()
profile.user = request.user
profile.save()
request.session[LANGUAGE_SESSION_KEY] = request.user.userprofile.language
if hasattr(settings, 'SAML_1'): # Is SAML 1.2 support enabled?
if not request.user.userprofile.user_is_verified():
return HttpResponseRedirect(settings.SAML_1['URL'])
if hasattr(settings, 'ICEPIRATE'): # Is IcePirate support enabled?
configure_external_member_db(request.user, create_if_missing=False)
return HttpResponseRedirect(redirect_to)
else:
form = authentication_form(request)
current_site = get_current_site(request)
context = {
'form': form,
redirect_field_name: redirect_to,
'site': current_site,
'site_name': current_site.name,
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request, template_name, context,
current_app=current_app)
def forwards(self, orm):
"Whitelist any user who has whitelisted projects."
for project in Project.objects.all():
if project.whitelisted:
# If user doesn't have a profile, create one
try:
profile = project.user.get_profile()
except ObjectDoesNotExist:
profile = UserProfile(user=project.user)
# Whitelist the user's profile
profile.whitelisted = True
profile.save()
def process_request(self, request):
if request.user.is_authenticated():
try:
request.session['django_language'] = request.user.get_profile().language
except AttributeError:
# pass
pro = UserProfile()
pro.user = request.user
pro.language = settings.LANGUAGE_CODE
pro.save()
request.session['django_language'] = pro.language
else:
request.session['django_language'] = "is"
def create_user(self, is_active, device_id, email=None):
consumer_id = generate_unique_customer_id()
password = consumer_id + settings.PASSWORD_POSTFIX
user_obj = User.objects.create(username=consumer_id)
user_obj.set_password(password)
user_obj.is_active = is_active
if email:
user_obj.email = email
user_obj.save(using=settings.BRAND)
bituser_obj = UserProfile(user=user_obj, device_id=device_id)
bituser_obj.save()
return {'bituser_obj': bituser_obj}
def adduser(request, ssn=None, name=None, email=None, added=None, username=None):
if ssn is None:
assert(request.GET.get('key') == settings.ICEPIRATE['key'])
# Parse args...
ssn = ssn or request.GET.get('ssn')
name = name or request.GET.get('name')
email = email or request.GET.get('email')
added = added or request.GET.get('added')
username = username or request.GET.get('username')
if added:
added = datetime.strptime(added, '%Y-%m-%d %H:%M:%S')
else:
added = timezone.now()
# Look up all the users that match
users = []
if ssn:
users.extend(User.objects.filter(userprofile__verified_ssn=ssn))
if username:
users.extend(User.objects.filter(username=username))
if email:
users.extend(User.objects.filter(email=email))
# Update or create user
try:
user = users[0]
# Sanity checks...
assert(len([u for u in users if u != user]) == 0)
if user.userprofile.verified_ssn:
assert(user.userprofile.verified_ssn == ssn)
else:
# User exist, is not verified! Just update SSN.
user.userprofile.verified_ssn = ssn
user.userprofile.save()
except IndexError:
# User does not exist. Create user, yay!
if not username:
username = _make_username(name, email)
user = User(username=username, email=email)
user.save()
prof = UserProfile(user=user, verified_ssn=ssn, joined_org=added)
prof.save()
response_data = _icepirate_user_data(user)
response_data.update({
'reset_url': _password_reset_url(user),
'success': True})
return HttpResponse(
json.dumps(response_data), content_type='application/json')
def load_users(file):
print '\nimporting users'
for e in json.load(file):
try:
user = User.objects.filter(username=e['username']).get()
except User.DoesNotExist:
user = User.objects.create_user(e['username'], e['email'], 'asdfgh')
user.save()
profile = UserProfile(user=user)
profile.save()
print '.',
sys.stdout.flush()
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
new_user = form.save()
username = new_user.username
email = new_user.email
password = request.POST['password1']
salt = hashlib.sha1(str(random.random())).hexdigest()[:5]
activation_key = hashlib.sha1(salt + email).hexdigest()
key_expires = datetime.datetime.today() + datetime.timedelta(2)
#Get user by username
user = get_user_model().objects.get(username=username)
# Create and save user profile
new_profile = UserProfile(user=user,
activation_key=activation_key,
key_expires=key_expires)
new_profile.save()
# Send email with activation key
email_subject = 'Account confirmation'
email_body = "Hey %s, thanks for signing up. To activate your account, click this link within \
48hours http://ivebeenfound-dev2.elasticbeanstalk.com/accounts/confirm/%s" % (
username, activation_key)
send_mail(email_subject,
email_body,
'*****@*****.**', [email],
fail_silently=False)
context = RequestContext(request, {
'request': request,
'user': request.user,
'email': email
})
return render_to_response('public/confirm_sent.html',
context_instance=context)
else:
pass
context = RequestContext(request, {
'request': request,
'user': request.user
})
return render_to_response('public/registration_form.html',
context_instance=context)
def search_people(self):
qu = self.request.get('q', '')
index = search.Index(name='profileIndex')
query = index.search(qu)
profiles = [UserProfile.get_by_id(int(result.doc_id)) for result in query.results]
return self.render('app/search_people_result.html', profiles=profiles, search_term=qu)
def update_members(self, year):
with in_database(str(year), write=True):
try:
members = ws.get(url=self.WS_URL_DETAIL % (self.code, year),
use_redis=False)[0]['miembros']
except KeyError:
logger.warn(self.type + " " + self.code +
" does not exist in WS_URL_DETAIL for year " +
year)
return # This happens if the webservices are not that good.
for member in members:
try:
up = UserProfile.objects.get(
rrhh_code=member['cod_persona'])
except UserProfile.DoesNotExist:
response = ws.get(st.WS_DOCUMENT % member['cod_persona'])
document = response['numero_documento'] + response['letra']
up = UserProfile.get_or_create_user(document,
document)[0].profile
up.rrhh_code = member['cod_persona']
up.save()
up.user.first_name = member['cod_persona__nombre']
up.user.last_name = (member['cod_persona__apellido1'] +
" " +
member['cod_persona__apellido2'])[:30]
up.user.save()
ReportMember.objects.get_or_create(user_profile=up)
setattr(up.reportmember, self.type, self)
up.reportmember.cce = member['cod_cce__descripcion']
up.reportmember.save()
def __init__(self, request, *args, **kwargs):
super(SystemObject, self).__init__(request,
admin=True,
*args,
**kwargs)
self.manager = AdminManager()
self.manager.fetchOptions = {
'active': self.requester.rData['selectedactivity'],
'activesite': self.requester.rData['activesite']
}
self.urls.add = 'core.view.userprofileadmin.add_item'
self.urls.edit = 'core.view.userprofileadmin.edit_item'
self.urls.show_items = 'core.view.userprofileadmin.show_items'
self.manager.model = UserProfile()
self.manager.modelLanguage = None
self.manager.form_class = AdmItemForm().__class__
self.manager.language_form_class = None
self.manager.order = 'username'
self.manager.debugger.filename = 'userprofileadmin.py'
self.manager.moduleName = '__adm_Sheet_Files__'
self.data.update({
'filter_activity':
reverse('core.view.userprofileadmin.show_items')
})
toppanel = {
#reverse('core.view.sheetadmin.show_items'): '__adm_Sheets__',
#reverse('core.view.userprofileadmin.show_items'): '__adm_User_Profiles__'
}
self.data.update({'toppanel': toppanel})
self.data.update({
'savebutton': 1,
'saveaddbutton': 1,
'copybutton': 1,
'addbutton': 1
})
def get_investigadores(self, unit, title):
if unit is None:
return NotImplemented
unit_content = ws.get(self.WS_URL_DETAIL % (unit, self.year))[0]
if unit_content["unidad"] == {}:
try:
unit_name = filter(lambda x: x['code'] == unit,
self.unit_names)[0]['name']
except (AttributeError, KeyError):
unit_name = unicode(unit)
logger.warn(u"La unidad " + unit_name +
u" no tiene información en " + unicode(self.year))
return [], [], unit_name
investigadores = []
usuarios = []
for inv in unit_content['miembros']:
inv = self._check_inves(inv)
investigadores.append(inv)
try:
up = UserProfile.objects.get(rrhh_code=inv['cod_persona'])
except UserProfile.DoesNotExist:
response = ws.get(st.WS_DOCUMENT % inv['cod_persona'])
document = response['numero_documento'] + response['letra']
up = UserProfile.get_or_create_user(document,
document)[0].profile
up.rrhh_code = inv['cod_persona']
up.save()
up.user.first_name = inv['cod_persona__nombre']
up.user.last_name = (inv['cod_persona__apellido1'] + " " +
inv['cod_persona__apellido2'])[:30]
up.user.save()
usuarios.append(up)
if title is None:
title = unit_content['unidad']['nombre']
return investigadores, usuarios, title
def signup(request):
from forms import SignupForm
if request.method == 'POST':
# process signup form and create account
form = SignupForm(request.POST)
if form.is_valid():
user = User()
user.username = form.cleaned_data['username']
user.set_password(form.cleaned_data['password1'])
user.email = form.cleaned_data['email']
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.is_active = True
user.save()
profile = UserProfile(paid_user=True, user=user)
profile.save()
# send a mail with registration details
from django.template.loader import render_to_string
from django.core.mail import EmailMessage
email = EmailMessage('Welcome to Trackpattern',
render_to_string('registration/welcome_mail.txt',
{'username': user.username,
'first_name': user.first_name}),
from_email='*****@*****.**',
to=[user.email])
email.send()
_out = {'username':user.username,'email':user.email,'first_name':user.first_name,'last_name':user.last_name,'Would you like to sign up to our mailing list to receive free information about analytics and data driven marketing?' : form.cleaned_data['question_1'],'ts':str(datetime.datetime.now())}
emailtoadmin = EmailMessage('Trackpattern - New user has registered',body=json.dumps(_out),from_email="*****@*****.**",to=["*****@*****.**",'*****@*****.**'])
emailtoadmin.send()
#reset = True
# return redirect(
# 'https://trackpattern.chargify.com/h/46549/subscriptions/new/?reference=%s&first_name=%s&last_name=%s&email=%s' % (
# user.id, user.first_name, user.last_name, user.email))
login_user = authenticate(username=user.username, password=form.cleaned_data['password1'])
auth_login(request, login_user)
return redirect('/home/')
else:
form = SignupForm(initial={'question_1': True})
return render_to_response('registration/signup.html',
{'form': form, },
context_instance=RequestContext(request))
def notify_followers_new_content(course):
followers = UserProfile.query(UserProfile.followed_courses == course)
for follower in followers:
notify = Notification(text='Novo conteúdo adicionado %s' %(course.get().title),
profile=follower.key,
ntype='icon-warning-sign'
)
notify.put()
def form_valid(self, form):
'''
Creates a new user
'''
team = form.save()
username = form.instance.name.lower().replace(' ', '')
password = password_generator(8)
user = User.objects.create_user(username=username, password=password)
profile = UserProfile()
profile.team = team
profile.user = user
profile.save()
self.request.session['new_user'] = {'username': username, 'password': password}
return super(TeamAddView, self).form_valid(form)
def authenticate(self, oauth_token=None):
if oauth_token is None:
return None
user_info = None
try:
api = TroveAPI(settings.TROVE_APP_KEY, settings.TROVE_APP_SECRET, ["photos"], oauth_token)
user_info = api.get_user_info()
except:
return None
try:
trove_profile = UserProfile.objects.get(trove_user_id=user_info["trove_internal_id"])
return trove_profile.user
except UserProfile.DoesNotExist:
user = User()
if user_info.has_key("trove_username"):
user.username = user_info["trove_username"]
else:
user.username = user_info["trove_internal_id"] # We use the trove internal id if there is no user name
user.first_name = user_info["first_name"]
user.last_name = user_info["last_name"]
user.save()
trove_profile = UserProfile()
trove_profile.trove_user_id = user_info["trove_internal_id"]
trove_profile.trove_access_token_key = oauth_token.key
trove_profile.trove_access_token_secret = oauth_token.secret
trove_profile.user = user
trove_profile.save()
return user
def myregister(request):
form = UserRegisterForm()
if request.method == 'POST':
form = UserRegisterForm(request.POST)
if form.is_valid():
user = form.save()
username = form.cleaned_data.get('username')
email = form.cleaned_data.get('email')
fname = form.cleaned_data.get('first_name')
lname = form.cleaned_data.get('last_name')
htmly = get_template('user/email.html')
d = {'username': username}
subject, from_email, to = 'Welcome', '*****@*****.**', email
html_content = htmly.render(d)
msg = EmailMultiAlternatives(subject, html_content, from_email,
[to])
msg.attach_alternative(html_content, 'text/html')
msg.send()
profile = UserProfile()
profile.user = user
profile.fname = fname
profile.lname = lname
profile.save()
messages.success(request,
'Your Account has been successfully created!')
return redirect('login')
context = {'form': form}
return render(request, 'user/signup.html', context)
def register(self, request, **cleaned_data):
"""Register a new user, saving the User and UserProfile data."""
user = User()
for field in user._meta.fields:
if field.name in cleaned_data:
setattr(user, field.name, cleaned_data[field.name])
# the password has been validated by the form
user.set_password(cleaned_data["password2"])
user.save()
profile = UserProfile(user=user)
for field in profile._meta.fields:
if field.name in cleaned_data:
setattr(profile, field.name, cleaned_data[field.name])
print "request data: image field"
img_data = request.POST.get("image")
# If none or len 0, means illegal image data
if img_data == None or len(img_data) == 0:
pass
# Decode the image data
img_data = base64.b64decode(img_data)
filename = "%s.png" % uuid.uuid4()
# XXX make the upload path a fixed setting in models, since it's
# reference in two places
upload_path = "data/avatars/%s/" % user.username
upload_abs_path = os.path.join(settings.MEDIA_ROOT, upload_path)
if not os.path.exists(upload_abs_path):
os.makedirs(upload_abs_path)
full_file_name = os.path.join(upload_abs_path, filename)
with open(full_file_name, "wb") as f:
f.write(img_data)
f.close()
profile.image = full_file_name
profile.save()
new_user = authenticate(username=user.username, password=cleaned_data["password2"])
login(request, new_user)
signals.user_activated.send(sender=self.__class__, user=new_user, request=request)
return new_user
def register(self, request, **cleaned_data):
'''Register a new user, saving the User and UserProfile data.'''
user = User()
for field in user._meta.fields:
if field.name in cleaned_data:
setattr(user, field.name, cleaned_data[field.name])
# the password has been validated by the form
user.set_password(cleaned_data['password2'])
user.save()
profile = UserProfile(user=user)
for field in profile._meta.fields:
if field.name in cleaned_data:
setattr(profile, field.name, cleaned_data[field.name])
print "request data: image field"
img_data = request.POST.get("image")
# If none or len 0, means illegal image data
if img_data == None or len(img_data) == 0:
pass
# Decode the image data
img_data = base64.b64decode(img_data)
filename = "%s.png" % uuid.uuid4()
# XXX make the upload path a fixed setting in models, since it's
# reference in three places
upload_path = "data/avatars/%s/" % user.username
upload_abs_path = os.path.join(settings.MEDIA_ROOT, upload_path)
if not os.path.exists(upload_abs_path):
os.makedirs(upload_abs_path)
full_file_name = os.path.join(upload_abs_path, filename)
with open(full_file_name, 'wb') as f:
f.write(img_data)
f.close()
profile.image = full_file_name
profile.save()
new_user = authenticate(username=user.username, password=cleaned_data['password2'])
login(request, new_user)
signals.user_activated.send(sender=self.__class__, user=new_user, request=request)
return new_user
def profile_by_user(self, profile_id):
profile = UserProfile.get_by_id(int(profile_id))
if not profile:
self.abort(404)
can_edit = self.logged == profile
return self.render('app/profile.html', profile=profile, can_edit=can_edit)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
new_user = form.save()
username = new_user.username
email = new_user.email
password = request.POST['password1']
salt = hashlib.sha1(str(random.random())).hexdigest()[:5]
activation_key = hashlib.sha1(salt+email).hexdigest()
key_expires = datetime.datetime.today() + datetime.timedelta(2)
#Get user by username
user=get_user_model().objects.get(username=username)
# Create and save user profile
new_profile = UserProfile(user=user, activation_key=activation_key,
key_expires=key_expires)
new_profile.save()
# Send email with activation key
email_subject = 'Account confirmation'
email_body = "Hey %s, thanks for signing up. To activate your account, click this link within \
48hours http://ivebeenfound-dev2.elasticbeanstalk.com/accounts/confirm/%s" % (username, activation_key)
send_mail(email_subject, email_body, '*****@*****.**',
[email], fail_silently=False)
context = RequestContext(request,
{'request': request,
'user': request.user,
'email': email
})
return render_to_response('public/confirm_sent.html', context_instance=context)
else:
pass
context = RequestContext(request,
{'request': request,
'user': request.user
})
return render_to_response('public/registration_form.html', context_instance=context)
def protweet_registration(request):
if request.method == "POST":
form = ProTweetRegistrationForm(request.POST)
msg = {'form': form}
if form.is_valid():
correct_data = form.cleaned_data
#1. Creating the User
try:
user = User.objects.create_user (
username = correct_data['tweet_handle'].lower(),
first_name = correct_data['name'],
last_name = 'none',
email = correct_data['email']
)
user.set_password(correct_data['password'])
user.save()
except Exception, e:
print 'Unable to Create User'
print e
return HttpResponseRedirect('/')
#2. Initializing UserProfile
try:
user_profile = UserProfile(user = user)
user_profile.save()
except Exception, e:
print 'Unable to Initialize UserProfile'
print e
#ToDo: Remove the previous failed user from db
return HttpResponseRedirect('/')
#3. Authentication User
username = correct_data.get('tweet_handle')
password = correct_data.get('password')
user = authenticate(username = username, password = password)
#5. Loggin in the user
login(request, user)
return HttpResponseRedirect('/home')
def save(self):
user = User(
username=self.validated_data['username'],
first_name=self.validated_data['first_name'],
last_name=self.validated_data['last_name'],
email=self.validated_data['email'],
)
password = self.validated_data['password']
password2 = self.validated_data['password2']
if password != password2:
raise serializers.ValidationError(
{'password': '******'})
user.set_password(password)
userprofile = UserProfile(user=user,
user_description="Modifie ton profil",
city="Modifie ton profil")
user.save()
userprofile.save()
return user
def signup(request):
"""View that handles user registration."""
if request.user.is_authenticated():
return HttpResponseRedirect("/")
if request.method == "GET":
form = SignupForm() # Create an empty form if the method is GET.
elif request.method == "POST":
form = SignupForm(request.POST) # Populate the form with POST data.
if form.is_valid():
# Get the form data.
username = form.cleaned_data["username"]
email = form.cleaned_data["email"]
password = form.cleaned_data["password"]
first_name = form.cleaned_data["first_name"]
last_name = form.cleaned_data["last_name"]
# Create a new user and profile.
user = User.objects.create_user(username, email, password)
user.first_name = first_name
user.last_name = last_name
user.save() # Save the user.
new_profile = UserProfile()
new_profile.new(user, form.cleaned_data["phone"], get_remote_ip(request))
# Send an email with the confirmation link
site = Site.objects.get_current()
subject = "%s User Activation" % site.name
body = (
"Hello, %s, and thanks for signing up for an account at %s!"
"\n\nTo activate your account, click this link within 48 hours:"
"\n\nhttp://%s/login/%s" % (user.username, site.domain, site.domain, new_profile.activation_key)
)
send_mail(subject, body, "settings.EMAIL_HOST_USER", [user.email])
# Redirect to a confirmation page.
return HttpResponseRedirect("/signup/confirmed/")
# Load signup.html on GET request and POST error.
return load_page(request, "signup.html", {"form": form})
class StatusProcessModelTest(TestCase):
def setUp(self):
self.user = UserProfile(email='*****@*****.**',
name='Test',
url='https://test.com/postback/',
password='******')
self.user.save()
self.obj = StatusProcess(user_profile=self.user,
id_process='12345678901',
status_process='Em análise')
self.obj.save()
def test_create(self):
self.assertTrue(StatusProcess.objects.exists())
self.assertTrue(UserProfile.objects.exists())
def test_str(self):
self.assertEqual('Em análise', str(self.obj))
self.assertEqual('*****@*****.**', str(self.user))
def register(self, request, **cleaned_data): '''Register a new user, saving the User and UserProfile data.''' user = User() for field in user._meta.fields: if field.name in cleaned_data: setattr(user, field.name, cleaned_data[field.name]) # the password has been validated by the form user.set_password(cleaned_data['password2']) user.save() profile = UserProfile(user=user) for field in profile._meta.fields: if field.name in cleaned_data: setattr(profile, field.name, cleaned_data[field.name]) profile.save() new_user = authenticate(username=user.username, password=cleaned_data['password2']) login(request, new_user) signals.user_activated.send(sender=self.__class__, user=new_user, request=request) return new_user
def register(self, request, **cleaned_data): '''Register a new user, saving the User and UserProfile data.''' user = User() for field in user._meta.fields: if field.name in cleaned_data: setattr(user, field.name, cleaned_data[field.name]) # the password has been validated by the form user.set_password(cleaned_data['password2']) user.save() profile = UserProfile(user=user) for field in profile._meta.fields: if field.name in cleaned_data: setattr(profile, field.name, cleaned_data[field.name]) profile.save() new_user = authenticate(username=user.username, password=cleaned_data['password2']) login(request, new_user) signals.user_activated.send(sender=self.__class__, user=new_user, request=request) return new_user
def subscribe(request):
try:
data = request.POST
if request.method == 'POST':
if not User.objects.filter(email=data['email']):
user_obj = User(username=data['email'],
first_name=data['name'],
email=data['email'])
user_obj.save()
dob_tuple = (int(data['dob'].split('/')[1]),
int(data['dob'].split('/')[0]))
dob = datetime.datetime.strptime(data['dob'], '%d/%m/%Y')
zodiac = get_sign_from_date(dob_tuple)
user_prof_obj = UserProfile(user=user_obj,
zodiac=zodiac,
dob=dob)
user_prof_obj.save()
today = time.strftime("%Y-%m-%d")
zodiacs = Zodiac.objects.filter(date=today)
prediction = 'None'
if zodiacs:
predictions = zodiacs[0].zodiac.filter(
zodiac__iexact=zodiac)
if predictions:
prediction = predictions[0].prediction
context = {
'zodiac': zodiac,
'prediction': prediction,
'today': datetime.datetime.now(),
'status': True
}
else:
context = {'status': False}
return render(request, 'core/success.html', context)
else:
return HttpResponseRedirect('/')
except Exception as e:
logger.error(traceback.format_exc())
return HttpResponseRedirect('/')
def create_foursquare_user(foursquare_id, access_token):
# Since we don't have a username, just generate one
username = "******" + foursquare_id
fake_email = username + "@example.com" # Don't know why we have to do this
user = User.objects.create_user(username=username,email=fake_email,password=None)
user.save()
try:
user_profile = UserProfile(
user = user,
foursquare_id = foursquare_id,
foursquare_access_token = access_token)
user_profile.save()
except Exception:
# If profile creation fails, clean up the user too
user.delete()
# Reraise exception
raise
return user
def setup_user_account(strategy, backend, request, details, *args, **kwargs):
username = details['username'].replace(' ', '')
user = User.objects.get(username=username)
# New user supplied email and is new
if kwargs['is_new'] and details['email']:
UserProfile.user_creation(user)
welcome_new_user_fb_notification(details['username'], details['email'])
elif not details['email']:
if user.email is '' and not request.get('email', None):
return HttpResponseRedirect('/request_email')
elif user.email is '' and request.get('email', None):
user.email = request['email']
user.save()
UserProfile.user_creation(user)
welcome_new_user_fb_notification(details['username'], request['email'])
return {'email': request['email']}
return
def register(self, request, **cleaned_data):
'''Register a new user, saving the User and UserProfile data.'''
# We can't use RegistrationManager.create_inactive_user()
# because it doesn't play nice with saving other information
# in the same transaction.
user = User(is_active=False)
for field in user._meta.fields:
if field.name in cleaned_data:
setattr(user, field.name, cleaned_data[field.name])
user.save()
profile = UserProfile(user=user)
for field in profile._meta.fields:
if field.name in cleaned_data:
setattr(profile, field.name, cleaned_data[field.name])
profile.save()
registration_profile = RegistrationProfile.objects.create_profile(user)
registration_profile.send_activation_email(Site.objects.get_current())
signals.user_registered.send(sender=self.__class__, user=user, request=request)
def subscribe(request):
try:
data = request.POST
if request.method == 'POST':
if not User.objects.filter(email=data['email']):
user_obj = User(username=data['email'],
first_name=data['name'],
email=data['email'])
user_obj.save()
dob_tuple = (int(data['dob'].split('/')[1]),int(data['dob'].split('/')[0]))
dob = datetime.datetime.strptime(data['dob'], '%d/%m/%Y')
zodiac = get_sign_from_date(dob_tuple)
user_prof_obj = UserProfile(user=user_obj,zodiac=zodiac,dob=dob)
user_prof_obj.save()
today = time.strftime("%Y-%m-%d")
zodiacs = Zodiac.objects.filter(date=today)
prediction = 'None'
if zodiacs:
predictions = zodiacs[0].zodiac.filter(zodiac__iexact=zodiac)
if predictions:
prediction = predictions[0].prediction
context = {
'zodiac' : zodiac,
'prediction' : prediction,
'today' :datetime.datetime.now(),
'status' : True
}
else:
context = {
'status' : False
}
return render(request,'core/success.html',context)
else:
return HttpResponseRedirect('/')
except Exception as e:
logger.error(traceback.format_exc())
return HttpResponseRedirect('/')
def user_profile(request, username):
"""
Displays the user profile of the user with the specified username.
"""
user = get_object_or_404(User, username=username)
profile, created = UserProfile.get_or_create(user)
errors = request.session.pop('form_errors', None)
context = {
'profile': profile,
'form_errors': errors,
'explore': 'user_profile'
}
return render(request, 'core/users/user_profile.html', context)
def register(request):
error_messages = list();
if request.method == 'GET':
return render(request,'index/signup.html',{'error_messages':error_messages})
#email format verfication should be done in FE
email = request.POST.get("email","").strip()
passwd = request.POST.get("pass_confirmation", "").strip()
passwd_confirm = request.POST.get("pass", "")
name = request.POST.get("name", "").strip()
if len(email)==0 or len(passwd)==0 or passwd != passwd_confirm:
error_messages.append("Invalid email or password.")
return render(request,'index/signup.html',{'error_messages':error_messages})
try:
validate_email(email)
except ValidationError as e:
error_messages.append("Invalid email.")
return render(request,'index/signup.html',{'error_messages':error_messages})
#first need to check whether email had been registered already or not
if User.objects.filter(email=email).count() > 0:
error_messages.append("User already exists.")
return render(request,'index/signup.html',{'error_messages':error_messages})
try:
user = User.objects.create_user(username=email, email=email, password=passwd)
user.save()
profile = UserProfile(user=user, name=name)
profile.save()
user = authenticate(username=email,password=passwd)
login(request,user)
return redirect('/')
except Exception,e:
raise e
error_messages.append("Cannot create user.");
return render(request,'index/signup.html',{'error_messages':error_messages})
def register(self):
fname = self.request.get('name')
email = self.request.get('email')
passwd = self.request.get('passwd')
registered = UserProfile.get_by_auth_id(email)
if registered:
errors = ['User "%s" already registered.' %registered.email]
return self.render('login.html', errors=errors, username=registered.email)
names = fname.split()
self._create_new_user(email, email, passwd, name=names[0], last_name=' '.join(names[1:]))
return self.redirect_to('dashboard')
def test_daily_norms_calculation_hemodialysis(self):
user = UserFactory()
profile = UserProfile(user=user,
dialysis=DialysisType.Hemodialysis,
date_of_birth=date(1960, 1, 1),
height_cm=180,
diabetes_type=DiabetesType.Type1)
calculator = AdultDailyNormsCalculator(profile, urine_ml=123)
self.assertEqual(calculator.calculate_potassium_mg(), 3123)
self.assertEqual(calculator.calculate_proteins_mg(), 93677)
self.assertEqual(calculator.calculate_sodium_mg(), 2300)
self.assertEqual(calculator.calculate_phosphorus_mg(), 1000)
self.assertIsNone(calculator.calculate_energy_kcal())
self.assertEqual(calculator.calculate_liquids_g(), 1123)
def test_daily_norms_calculation_dialysis_not_performed_no_cd(self):
user = UserFactory()
profile = UserProfile(user=user,
dialysis=DialysisType.NotPerformed,
date_of_birth=date(1960, 1, 1),
height_cm=200,
diabetes_type=DiabetesType.No)
calculator = AdultDailyNormsCalculator(profile, urine_ml=455)
self.assertIsNone(calculator.calculate_potassium_mg())
self.assertEqual(calculator.calculate_proteins_mg(), 59689)
self.assertEqual(calculator.calculate_sodium_mg(), 2300)
self.assertEqual(calculator.calculate_phosphorus_mg(), 1000)
self.assertIsNone(calculator.calculate_energy_kcal())
self.assertIsNone(calculator.calculate_liquids_g())
def test_daily_norms_calculation_post_transplant(self):
user = UserFactory()
profile = UserProfile(user=user,
dialysis=DialysisType.PostTransplant,
date_of_birth=date(1960, 1, 1),
height_cm=160,
diabetes_type=DiabetesType.Type2)
calculator = AdultDailyNormsCalculator(profile, urine_ml=None)
self.assertIsNone(calculator.calculate_potassium_mg())
self.assertEqual(calculator.calculate_proteins_mg(), 45318)
self.assertEqual(calculator.calculate_sodium_mg(), 2300)
self.assertIsNone(calculator.calculate_phosphorus_mg())
self.assertIsNone(calculator.calculate_energy_kcal())
self.assertIsNone(calculator.calculate_liquids_g())
def forgot_password(self):
email = self.request.get("email")
user = UserProfile.get_by_auth_id(email)
if not user:
return self.render_json({'success': False, 'title': 'Sorry.', 'message': 'Nenhum usuário com o email "%s" foi encontrado.' %email})
new_password = security.generate_random_string(length=8)
user.set_password(new_password)
print 'New Password ======================> ', new_password
user.put()
deferred.defer(send_forgot_password_email, user=user, new_passwd=new_password, _queue='sendEmail') #TODO improve this queue params/conf
return self.render_json({'success': True, 'title': 'Senha reiniciada.', 'message': 'Enviamos um email para %s com sua nova senha' %email})
def authenticate(self, ticket, service, request):
"""Verifies CAS ticket and gets or creates User object"""
username, attributes = _verify(ticket, service)
# If we don't have the user's document we'll not allow him to do login
if (not attributes or not 'NumDocumento' in attributes
or attributes['NumDocumento'] is None):
st.CAS_RETRY_LOGIN = False
return None
# If type of account of the user isn't allow then
# we will not allow him to do login
if (attributes and 'TipoCuenta' in attributes
and attributes['TipoCuenta'] in st.CAS_TIPO_CUENTA_NOAUT):
st.CAS_RETRY_LOGIN = False
return None
request.session['attributes'] = attributes
documento = attributes['NumDocumento']
return UserProfile.get_or_create_user(username, documento)[0]
def authenticate(self, ticket, service, request):
"""Verifies CAS ticket and gets or creates User object"""
username, attributes = _verify(ticket, service)
# If we don't have the user's document we'll not allow him to do login
if (not attributes or not 'NumDocumento' in attributes
or attributes['NumDocumento'] is None):
st.CAS_RETRY_LOGIN = False
return None
# If type of account of the user isn't allow then
# we will not allow him to do login
if (attributes and 'TipoCuenta' in attributes
and attributes['TipoCuenta'] in st.CAS_TIPO_CUENTA_NOAUT):
st.CAS_RETRY_LOGIN = False
return None
request.session['attributes'] = attributes
documento = attributes['NumDocumento']
return UserProfile.get_or_create_user(username, documento)[0]
def handle(self, *args, **options):
database = (options['database']
if options['database'] is not None else 'default')
with in_database(database, write=True):
cvn_file = os.path.join(st_cvn.MIGRATION_ROOT,
'users_to_migrate.csv')
with open(cvn_file, 'rb') as csvfile:
lines = csv.reader(csvfile, dialect=st.CSV_DIALECT)
for line in lines:
user, created = UserProfile.get_or_create_user(
username=unicode(line[0]), documento=unicode(line[1]))
if created:
user.first_name = line[3]
user.last_name = line[4]
user.save()
# Reload user to have profile updated
user = User.objects.get(pk=user.profile.user.pk)
try:
pdf_file = os.path.join(st_cvn.MIGRATION_ROOT, line[2])
upload_file = open(pdf_file)
except IOError:
print(
u'[%s] \t \t ERROR: CVN No encontrado (%s - %s)' %
(lines.line_num, line[0], line[2]))
continue
cvn_file = SimpleUploadedFile(
upload_file.name,
upload_file.read(),
content_type="application/pdf")
upload_file.close()
try:
user.profile.cvn.remove()
user.profile.cvn.delete()
except ObjectDoesNotExist:
pass
form = UploadCVNForm(initial={'cvn_file': cvn_file},
user=user)
if form.is_valid():
cvn = form.save()
cvn.insert_xml()
print u'[%s] Usuario: %s - CVN: %s \t \t OK' % (
lines.line_num, line[0], line[2])
else:
print u'[%s] \t \t ERROR: CVN No válido (%s - %s)' % (
lines.line_num, line[0], line[2])
def create_profile(sender, **kw):
if 'instance' not in kw or not kw.get('created', False):
return
instance = kw['instance']
profile = UserProfile()
profile.user = instance
bc, im = create_barcode(u'USER-{0}'.format(instance.username[0]),
instance.id, instance.username)
profile.barcode = bc
content = ContentFile(im)
profile._barcode.save('{0}.png'.format(bc), content)
profile.save()
def register(self):
fname = self.request.get('name')
email = self.request.get('email')
passwd = self.request.get('passwd')
if not fname or not email or not passwd:
register_errors = ['Informe todos os dados.']
return self.render('login.html', register_errors=register_errors)
registered = UserProfile.get_by_auth_id(email)
if registered:
register_errors = ['Escolha outro email.' % registered.email]
return self.render('login.html', register_errors=register_errors, username=registered.email)
names = fname.split()
self._create_new_user(email, email, passwd, name=names[0], last_name=' '.join(names[1:]))
return self.redirect('/')
def test_daily_norms_calculation_peritoneal_dialysis(self):
for dialysis in (DialysisType.ManualPeritonealDialysis,
DialysisType.AutomaticPeritonealDialysis):
user = UserFactory()
profile = UserProfile(user=user,
dialysis=dialysis,
date_of_birth=date(1960, 1, 1),
height_cm=180,
diabetes_type=DiabetesType.No)
calculator = AdultDailyNormsCalculator(profile, urine_ml=None)
self.assertEqual(calculator.calculate_potassium_mg(), 4000)
self.assertEqual(calculator.calculate_proteins_mg(), 93677)
self.assertEqual(calculator.calculate_sodium_mg(), 2300)
self.assertEqual(calculator.calculate_phosphorus_mg(), 1000)
self.assertIsNone(calculator.calculate_energy_kcal())
self.assertEqual(calculator.calculate_liquids_g(), 1000)
def process_request(self, request):
if request.user.is_authenticated():
try:
request.session['django_language'] = request.user.get_profile(
).language
except AttributeError:
# pass
pro = UserProfile()
pro.user = request.user
pro.language = settings.LANGUAGE_CODE
pro.save()
request.session['django_language'] = pro.language
else:
request.session['django_language'] = "is"
def preferences(request):
"""
Either displays the preferences page or saves the user's preferences if GET or POST request respectively.
"""
profile, created = UserProfile.get_or_create(request.user)
saved = False
if request.method == 'POST':
# users is saving their preferences
form = SaveUserProfileForm(request.POST, instance=profile)
if form.is_valid():
form.save()
saved = True
else:
form = SaveUserProfileForm(instance=profile)
context = {
'profile': profile,
'form': form,
'saved': saved,
'explore': 'preferences'
}
return render(request, 'core/accounts/preferences.html', context)
def account(request):
user = request.user
try:
profile = UserProfile.objects.get(user=request.user)
except:
profile = UserProfile()
profile.new(user, ip_address=get_remote_ip(request))
profile.save()
form = AccountForm({"phone": profile.phone, "email": user.email})
error = ""
if request.method == "POST":
form = AccountForm(request.POST)
if form.is_valid():
# user.email = form.cleaned_data['email']
user.save()
profile.phone = form.cleaned_data["phone"]
profile.save()
return index(request, "Your account has successfully been edited.")
else:
error = form.errors
return load_page(request, "account.html", {"form": form, "error": error})
def test_selenium_cambio_incorrecto_dni(self):
user = UserProfile.get_or_create_user('invipas', '72693103Q')[0]
user.set_password("pruebasINV1")
user.is_staff = True
user.is_superuser = True
user.save()
driver = self.driver
driver.get(self.base_url + "/cas-1/login?service=http%3A%2F%2Flocalhost"
"%3A8081%2Finvestigacion%2Faccounts%2Flogin"
"%2F%3Fnext%3D%252Finvestigacion%252Fadmin"
"%252Flogin%252F%253Fnext%253D%252F"
"investigacion%252Fadmin%252F")
driver.find_element_by_id("username").clear()
driver.find_element_by_id("username").send_keys("invipas")
driver.find_element_by_id("password").clear()
driver.find_element_by_id("password").send_keys("pruebasINV1")
driver.find_element_by_name("submit").click()
driver.find_element_by_link_text("User profiles").click()
driver.find_element_by_id("searchbar").clear()
driver.find_element_by_id("searchbar").send_keys(user.username)
driver.find_element_by_css_selector("input[type=\"submit\"]").click()
driver.find_element_by_css_selector("tr.row1 > td.action-checkbox > "
"input[name=\"_selected_action\"]"
).click()
Select(driver.find_element_by_name("action")
).select_by_visible_text("Change user's DNI")
driver.find_element_by_name("index").click()
driver.find_element_by_id("id_new_dni").clear()
driver.find_element_by_id("id_new_dni").send_keys("88888888B")
driver.find_element_by_name("apply").click()
try:
result = driver.find_element_by_class_name("info").text
except NoSuchElementException:
result = ''
self.assertFalse(u'Successfully changed dni.' in result)
self.assertEqual("72693103Q", UserProfile.objects.get(
user__username='******').documento)
def setUp(self):
self.obj = UserProfile(stripe_customer_id="123456789",
one_click_purchasing=True)
