def setUp(self):
### USERS ###
self.password = '******'
ferromet = User()
ferromet.username = '******'
ferromet.first_name = 'FERROMET'
ferromet.set_password(self.password)
ferromet.save()
admin = User()
admin.username = '******'
admin.first_name = 'Главный куратор'
admin.set_password(self.password)
admin.save()
### PROFILES ###
profile1 = Profile()
profile1.user = admin
profile1.is_company = False
profile1.is_report = True
profile1.is_super_user = True
profile1.telefon = '+7 921 622 22 50'
profile1.save()
profile2 = Profile()
profile2.user = ferromet
profile2.save()
### COMPANYS ###
fer_com = Company()
fer_com.com_user = ferromet
fer_com.save()
### DEPS ###
dep1 = Departments()
dep1.pk = 1
dep1.company = fer_com
dep1.name = u'Основной'
dep1.save()
### PC ###
pc1 = CompanyPC()
pc1.id = 1
pc1.company = fer_com
pc1.departament = dep1
pc1.pc_nameId = '1'
pc1.pc_name = 'buh'
pc1.save()
### PC_OPTIONS ###
option1 = PcOptions()
option1.id = 1
option1.name = u'Процессор'
option1.save()
def create_profile(user, gender=None, lname=None):
if gender is None:
gender = get_random_gender()
fname = get_random_fname(gender)
if lname is None:
lname = get_random_lname()
zc = get_random_zip()
photo = adult_photo(gender)
profile = Profile()
profile.user = user
profile.first_name = fname
profile.last_name = lname
profile.zip_code = zc
profile.gender = gender
profile.save()
f = open(photo, 'r')
np = Photo(album=profile.album, caption="Profile", original_image=File(f))
np.save()
profile.set_profile_pic(np)
return profile
def create_profile(user, gender=None, lname=None):
if gender is None:
gender = get_random_gender()
fname = get_random_fname(gender)
if lname is None:
lname = get_random_lname()
zc = get_random_zip()
photo = adult_photo(gender)
profile = Profile()
profile.user = user
profile.first_name = fname
profile.last_name = lname
profile.zip_code = zc
profile.gender = gender
profile.save()
f = open(photo, 'r')
np = Photo(album=profile.album, caption="Profile", original_image=File(f))
np.save()
profile.set_profile_pic(np)
return profile
def thanks(request, redirect_url=settings.LOGIN_REDIRECT_URL):
# Now that we've got the magic tokens back from Twitter, we need to exchange
# for permanent ones and store them...
oauth_token = request.session['request_token']['oauth_token']
oauth_token_secret = request.session['request_token']['oauth_token_secret']
twitter = Twython(settings.TWITTER_KEY, settings.TWITTER_SECRET,
oauth_token, oauth_token_secret)
# Retrieve the tokens we want...
authorized_tokens = twitter.get_authorized_tokens(request.GET['oauth_verifier'])
# If they already exist, grab them, login and redirect to a page displaying stuff.
try:
user = User.objects.get(username=authorized_tokens['screen_name'])
except User.DoesNotExist:
# We mock a creation here; no email, password is just the token, etc.
user = User.objects.create_user(authorized_tokens['screen_name'], "*****@*****.**", authorized_tokens['oauth_token_secret'])
profile = Profile()
profile.user = user
profile.oauth_token = authorized_tokens['oauth_token']
profile.oauth_secret = authorized_tokens['oauth_token_secret']
profile.save()
user = authenticate(
username=authorized_tokens['screen_name'],
password=authorized_tokens['oauth_token_secret']
)
login(request, user)
redirect_url = request.session.get('next_url', redirect_url)
return HttpResponseRedirect("/")
def create_profile(user, fname, lname, zip):
profile = Profile()
profile.user = user
profile.first_name = fname
profile.last_name = lname
profile.zip_code = zip
profile.save()
return profile
def create_profile(user, fname, lname, zip):
profile = Profile()
profile.user = user
profile.first_name = fname
profile.last_name = lname
profile.zip_code = zip
profile.save()
return profile
def form_valid(self, form):
user = form.save(commit=False)
User.objects.create_user(username=user.username,
email=user.email,
password=user.password)
user = User.objects.get(username=user.username)
profile = Profile()
profile.user = user
profile.save()
messages.add_message(self.request, messages.SUCCESS,
_('Account registered successfully.'))
return super().form_valid(form)
def save(self, commit=True):
user = super(RegistrationForm, self).save(commit=False)
if commit:
user.backend='django.contrib.auth.backends.ModelBackend'
user.save()
user_profile = Profile()
user_profile.user = user
user_profile.phone = self.cleaned_data["phone"]
user_profile.save()
return user
def register_user(request):
if request.method == 'POST':
print(request.data)
user = RegisterForm(request.data)
if user.is_valid():
user.save()
username = user.cleaned_data['username']
user_ = User.objects.filter(username__iexact=username)[0]
profile = Profile()
profile.user = user_
profile.save()
return Response({'success': True})
else:
return Response({'success': False, 'errors': user.errors})
def activate_account(request,account_activation_key = None):
csrfContext = RequestContext(request)
try:
key = ConfirmationKey.objects.get(key = account_activation_key,function = 'signup')
except ConfirmationKey.DoesNotExist:
request.flash["error"] = _(u"The supplied key does not exist.")
raise Http404
if not key.is_valid:
return render_to_response('information.html',{'title':_(u"User account already activated"),'text':_(u"It seems that your user account has already been activated.")},csrfContext)
if User.objects.filter(email = key.email,profile__isnull = False).count():
return render_to_response('information.html',{'title':_(u"A user with this e-mail address already exists."),'text':_(u"We are sorry, but the e-mail address you have chosen is already associated to a user account.")},csrfContext)
else:
data = key.get_data()
user = User()
profile = Profile()
obsolete_users = User.objects.filter(email = key.email)
for obsolete_user in obsolete_users:
obsolete_user.email = ''
obsolete_user.save()
user.username = generate_random_key()
user.email = key.email
user.set_password(data["password"])
notify_staff({'title':'New user account','text':"Somebody with email %s has created a new user account." % key.email},notification_object = user)
user.save()
profile.user = user
profile.has_verified_email = True
profile.is_active = True
profile.has_beta_key = True
profile.save()
#We remove the sensitive password from the key's data.
del data["password"]
key.set_data(data)
key.invalidate()
_directly_login_user(request,profile.user)
csrfContext = RequestContext(request)
next_url = None
if 'next_url' in data:
next_url = data['next_url']
return render_to_response('profiles/activate_account.html', {'next_url':next_url},csrfContext)
def post(self, request):
user = request.data.get('user', {})
# The create serializer, validate serializer, save serializer pattern
# below is common and you will see it a lot throughout this course and
# your own work later on. Get familiar with it.
serializer = self.serializer_class(data=user)
serializer.is_valid(raise_exception=True)
userModel = serializer.save()
profile = Profile()
profile.user = userModel
profile.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def create_profile(self, user, commit=True):
community = Community.objects.get(pk=self.cleaned_data["community"])
disease = Disease.objects.get(pk=self.cleaned_data["disease"].id)
gender = self.cleaned_data["gender"]
profile = Profile()
profile.disease = disease
profile.community = community
profile.gender = gender
profile.birth_date = self.cleaned_data["birth_date"]
profile.user = user
if commit:
profile.save()
return profile
def create_profile(self, user=None, profile_data=None, commit=True):
profile = Profile()
if user is None:
raise NotImplementedError("SignupForm.create_profile requires a valid user")
profile.user = user
profile.first_name = profile_data["first_name"]
profile.last_name = profile_data["last_name"]
profile.zip_code = profile_data["zip_code"]
profile.gender = profile_data["gender"]
profile.source = profile_data["source"]
profile.save()
return profile
def create_profile(self, user=None, profile_data=None, commit=True):
profile = Profile()
if user is None:
raise NotImplementedError(
"SignupForm.create_profile requires a valid user")
profile.user = user
profile.first_name = profile_data["first_name"]
profile.last_name = profile_data["last_name"]
profile.zip_code = profile_data["zip_code"]
profile.gender = profile_data["gender"]
profile.source = profile_data["source"]
profile.save()
return profile
def save(self, commit=True):
user = super(RegistrationForm, self).save(commit=False)
if commit:
user.backend='django.contrib.auth.backends.ModelBackend'
user.save()
user_profile = Profile()
user_profile.user = user
user_profile.save()
department = Department.objects.get(department_Name=self.cleaned_data['department_name'])
department.department_Members.add(user)
return user
def inject_users(self):
logging.info('Injecting users...')
with open('utils/dbinjector/users.csv', newline='') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
for row in csv_reader:
if row[0] != 'gonza56d':
User.objects.create_user(username=row[0],
email=row[1],
password=row[2])
else:
User.objects.create_superuser(username=row[0],
email=row[1],
password=row[2])
user = User.objects.get(username=row[0])
profile = Profile()
profile.user = user
profile.save()
def create_profile(user, profile_data, commit=True):
profile = Profile()
if user is None:
raise NotImplementedError("SignupForm.create_profile requires a valid user")
profile.user = user
profile.first_name = profile_data["first_name"]
profile.last_name = profile_data["last_name"]
profile.fb_account_linked = profile_data["fb_account_linked"]
profile.fb_id = profile_data["fb_id"]
profile.fb_stream_publish = profile_data["fb_stream_publish"]
profile.source = profile_data["source"]
profile.gender = profile_data["gender"]
profile.fb_login = profile_data["fb_login"]
profile.zip_code = profile_data["zip_code"]
profile.save()
return profile
def create_profile(user, profile_data, commit=True):
profile = Profile()
if user is None:
raise NotImplementedError(
"SignupForm.create_profile requires a valid user")
profile.user = user
profile.first_name = profile_data["first_name"]
profile.last_name = profile_data["last_name"]
profile.fb_account_linked = profile_data["fb_account_linked"]
profile.fb_id = profile_data["fb_id"]
profile.fb_stream_publish = profile_data["fb_stream_publish"]
profile.source = profile_data["source"]
profile.gender = profile_data["gender"]
profile.fb_login = profile_data["fb_login"]
profile.zip_code = profile_data["zip_code"]
profile.save()
return profile
def setUp(self):
### USERS ###
self.password = '******'
ferromet = User()
ferromet.username = '******'
ferromet.first_name = 'FERROMET'
ferromet.set_password(self.password)
ferromet.save()
admin = User()
admin.username = '******'
admin.first_name = 'Главный куратор'
admin.set_password(self.password)
admin.save()
### PROFILES ###
profile1 = Profile()
profile1.user = admin
profile1.is_company = False
profile1.is_report = True
profile1.is_super_user = True
profile1.telefon = '+7 921 622 22 50'
profile1.save()
profile2 = Profile()
profile2.user = ferromet
profile2.save()
### COMPANYS ###
fer_com = Company()
fer_com.com_user = ferromet
fer_com.save()
### DEPS ###
dep1 = Departments()
dep1.pk = 1
dep1.company = fer_com
dep1.name = u'Основной'
dep1.save()
### PC ###
pc1 = CompanyPC()
pc1.id = 1
pc1.company = fer_com
pc1.departament = dep1
pc1.pc_nameId = '1'
pc1.pc_name = 'buh'
pc1.save()
### PC_OPTIONS ###
option1 = PcOptions()
option1.id = 1
option1.name = u'Процессор'
option1.save()
def api_user_create(request):
request_data = json.loads(request.POST['data'])
market = None
supervisor = None
markets = []
programs_base = []
response = {}
validator = Validator()
common_name = request_data.get('common_name', '')
first_name = request_data.get('first_name', '')
last_name = request_data.get('last_name', '')
email = request_data.get('email', '')
username = request_data.get('username', '')
password = request_data.get('password', '')
code = request_data.get('code', '').strip()
title = request_data.get('title', '')
supervisor_id = request_data.get('supervisor_id', 0)
market_id = request_data.get('market_id', 0)
commission_category_id = request_data.get('commission_category', None)
commission_start = request_data.get('commission_start', 0)
want_account = request_data.get('want_account', False)
is_active = to_boolean(request_data.get('is_active', '0'))
markets_mtm = request_data.get('markets_mtm', [])
programs_mtm = request_data.get('programs_mtm', [])
profile_picture = request.FILES.get('profile_picture', None)
# region Validations
user = get_user_model().objects.filter(username=username).first()
if user:
validator.errors.add('username', 'Is already in use.')
role = Role.objects.filter(code=request_data['role']).first()
if not role:
return JsonResponse({'general': ['Something went wrong. code: 2']},
status=500)
groups_required = groups_by_role(role.code)
groups = Group.objects.filter(name__in=groups_required)
if len(groups) != len(groups_required):
return JsonResponse({'general': ['Something went wrong. code: 1']},
status=500)
if role.code in [
'consultant', 'free_agent', 'supervisor', 'coordinator', 'info',
'trainee'
]:
consultant_profile = ConsultantProfile.objects.filter(
mnemonic=code).first()
if consultant_profile:
validator.errors.add('code', 'Is already in use.')
if role.code in ['consultant', 'free_agent', 'supervisor', 'trainee']:
supervisor = get_user_model().objects.filter(
is_active=True, pk=supervisor_id, role__code="supervisor").first()
if not supervisor:
validator.errors.add('supervisor', 'Invalid user.')
if role.code in ['consultant', 'free_agent', 'supervisor'
] and commission_category_id:
commission_category = CommissionCategory.objects.filter(
pk=commission_category_id).first()
if not commission_category:
validator.errors.add('commission_category',
'Invalid commission category.')
if role.code != 'program':
market = Market.objects.filter(pk=market_id).first()
if not market:
validator.errors.add('market', 'This field is required.')
if role.code == 'coordinator':
query_set = get_user_model().objects.filter(
consultantprofile__market=market, role__name='coordinator')
if query_set.exists():
validator.errors.add(
'general', 'The coordinator for this market already exist.')
if len(markets_mtm) > 0:
markets = Market.objects.filter(pk__in=markets_mtm)
if len(programs_mtm) > 0:
programs_base = ProgramBase.objects.filter(pk__in=programs_mtm)
if role.code != 'program':
parts = email.split('@')
if len(parts) != 2:
validator.errors.add('email', 'Invalid email.')
else:
if parts[1] != 'adastra.ca':
validator.errors.add('email', 'Must finish in @adastra.ca')
if validator.has_errors():
return JsonResponse(validator.get_errors(), status=400)
# endregion
try:
with transaction.atomic():
person = Person.objects.create(first_name=first_name,
last_name=last_name,
email=email)
user = get_user_model().objects.create(
common_name=common_name,
password=make_password(password),
username=username,
is_active=is_active,
title=title,
role=role,
person=person)
response['id'] = user.pk
for group in groups:
user.groups.add(group)
if not role == 'program':
consultant_profile = ConsultantProfile()
consultant_profile.consultant = user
if role.code in [
'consultant', 'free_agent', 'supervisor',
'coordinator', 'info', 'trainee'
]:
consultant_profile.mnemonic = code
consultant_profile.supervisor = supervisor
if role.code in ['consultant', 'free_agent', 'supervisor']:
consultant_profile.commission_start = commission_start
if 'probation_start_date' in request_data and 'probation_end_date' in request_data:
consultant_profile.probation_start_date = request_data[
'probation_start_date']
consultant_profile.probation_end_date = request_data[
'probation_end_date']
consultant_profile.probation = True
if commission_category_id:
consultant_profile.commission_category_id = commission_category_id
consultant_profile.save()
consultant_profile.market.add(market)
profile = Profile()
profile.user = person
if role.code == 'program':
profile.profile_picture = profile_picture
profile.save()
if role.code == 'visa':
visas_profile = VisasProfile.objects.create(user=user)
visas_profile.markets.add(market)
if role.code == 'program':
program_profile = ProgramProfile.objects.create(
user=user, program_base=programs_base[0])
for program in programs_base:
program_profile.programs_base.add(program)
for market in markets:
program_profile.markets.add(market)
# TODO: posiblemente agregar el switch para habilitar link
if role.code != 'program' and want_account:
mailbox, domain = email.split('@')
if settings.APP_ENV == 'production':
rackspace = RackSpace()
rackspace.add_mailbox(mailbox,
data={
'displayName':
person.get_full_name(),
'firstName': person.first_name,
'lastName': person.last_name,
'password': password,
'customID': user.pk,
'enabled': user.is_active
})
Mailbox.objects.create(name=mailbox, user=user)
except IntegrityError as e:
log.error('{}'.format(e))
return JsonResponse(
{
'general':
['The system could not create the user, please try again.']
},
status=400)
except WebServiceException as e:
log.error('{}'.format(e))
return JsonResponse(
{
'general': [
'It seems that the Rackspace service is busy, please try again.'
]
},
status=400)
except ValidationException as e:
return JsonResponse({'general': [e.errors]}, status=400)
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
log.info('{} at line: {}.'.format(e, exc_tb.tb_lineno))
return JsonResponse({}, status=500)
return JsonResponse(response, status=200)
def register(request, template_name="profiles/register.html"):
context = {
'recaptcha_key': settings.GOOGLE_RECAPTCHA_PUBLIC_KEY,
}
if request.method == 'POST':
context['full_name'] = request.POST.get('full_name')
context['username'] = request.POST.get('username')
context['email'] = request.POST.get('email')
context['password'] = request.POST.get('password')
context['accept_terms'] = (request.POST.get('accept_terms') == 'on')
if not context['accept_terms']:
context['register_status'] = 'invalid_terms'
elif not request.recaptcha_is_valid:
context['register_status'] = 'invalid_recaptcha'
elif User.objects.filter(username=context['username']).count() != 0:
context['register_status'] = 'username_taken'
elif User.objects.filter(email=context['email']).count() != 0:
context['register_status'] = 'email_taken'
elif not is_valid_full_name(context['full_name']):
context['register_status'] = 'invalid_full_name'
elif not is_valid_username(context['username']):
context['register_status'] = 'invalid_username'
elif not is_valid_email(context['email']):
context['register_status'] = 'invalid_email'
elif not is_valid_password(context['password']):
context['register_status'] = 'invalid_password'
else:
with transaction.atomic():
user = User()
user.username = context['username']
user.set_password(context['password'])
user.save()
group, created = Group.objects.get_or_create(name='DOCTOR_GROUP')
user.groups.add(group)
avatar_filename = user.username + "_avatar.svg"
avatar_media_path = media_file_path(user, avatar_filename)
avatar_system_path = os.path.join(settings.MEDIA_ROOT, avatar_media_path)
if not os.path.exists(os.path.dirname(avatar_system_path)):
os.makedirs(os.path.dirname(avatar_system_path))
avatar_generator_url = \
settings.AVATAR_PROVIDER + '{0}?theme=berrypie&numcolors=4&size=220&fmt=svg' \
.format(avatar_filename)
urllib.request.urlretrieve(avatar_generator_url, avatar_system_path)
profile = Profile()
profile.full_name = context['full_name']
profile.user = user
profile.email = context['email']
profile.avatar = avatar_media_path
profile.save()
context['register_status'] = 'registered'
login(request, user, backend='django.contrib.auth.backends.ModelBackend')
return HttpResponseRedirect(reverse('home'))
else:
context['register_status'] = 'registering'
return render_with_context(request, template_name, context)
