def home(request):
if request.user.is_authenticated():
s = Session.objects.get(session_key=request.session.session_key)
t = Tracker.objects.create(session=s, source='2')
if request.user.userprofile.workplace_type in ['A', 'B']:
return render(request, 'home.html')
elif request.user.userprofile.workplace_type in ['C', 'O']:
return redirect('/feed')
else:
return redirect('/set/')
else:
q = request.GET.get('q')
try:
s = Session.objects.get(session_key=request.session.session_key)
except Exception:
s = None
t = Tracker.objects.create(session=s, source=q)
if request.GET.get('audience') == 'team':
return render(request, 'cover_team.html', {
'form_signup': SignupForm(),
'form_login': LoginForm()
})
else:
return render(request, 'cover.html', {
'form_signup': SignupForm(),
'form_login': LoginForm()
})
def obj_create(self, bundle, **kwargs):
#Validate that the needed fields exist
validator = CustomFormValidation(form_class=UserForm, model_type=self._meta.resource_name)
errors = validator.is_valid(bundle)
if isinstance(errors, ErrorDict):
raise BadRequest(errors.as_text())
#Extract needed fields
username, password, email = bundle.data['username'], bundle.data['password'], bundle.data['email']
data_dict = {'username' : username, 'email' : email, 'password' : password, 'password1' : password, 'password2' : password}
#Pass the fields to django-allauth. We want to use its email verification setup.
signup_form = SignupForm()
signup_form.cleaned_data = data_dict
try:
try:
user = signup_form.save(bundle.request)
profile, created = UserProfile.objects.get_or_create(user=user)
except AssertionError:
#If this fails, the user has a non-unique email address.
user = User.objects.get(username=username)
user.delete()
raise BadRequest("Email address has already been used, try another.")
#Need this so that the object is added to the bundle and exists during the dehydrate cycle.
html = complete_signup(bundle.request, user, "")
bundle.obj = user
except IntegrityError:
raise BadRequest("Username is already taken, try another.")
return bundle
def obj_create(self, bundle, **kwargs):
#Validate that the needed fields exist
validator = CustomFormValidation(form_class=UserForm, model_type=self._meta.resource_name)
errors = validator.is_valid(bundle)
if isinstance(errors, ErrorDict):
raise BadRequest(errors.as_text())
#Extract needed fields
username, password, email = bundle.data['username'], bundle.data['password'], bundle.data['email']
data_dict = {'username' : username, 'email' : email, 'password' : password, 'password1' : password, 'password2' : password}
#Pass the fields to django-allauth. We want to use its email verification setup.
signup_form = SignupForm()
signup_form.cleaned_data = data_dict
try:
try:
user = signup_form.save(bundle.request)
profile, created = UserProfile.objects.get_or_create(user=user)
except AssertionError:
#If this fails, the user has a non-unique email address.
user = User.objects.get(username=username)
user.delete()
raise BadRequest("Email address has already been used, try another.")
#Need this so that the object is added to the bundle and exists during the dehydrate cycle.
html = complete_signup(bundle.request, user, "")
bundle.obj = user
except IntegrityError:
raise BadRequest("Username is already taken, try another.")
return bundle
def create_allauth_user(email, username, password='', phonenumber='' ):
# Create dictionary with given required params to generate signin_request
post_dic = get_post_dic(email, username, password)
# Generate signin_request that contains dictionary in POST params
signin_request = get_signin_request(post_dic)
# POST data as kwargs for signupForm
signup_form_kwargs = {"files": {}, "initial": {},
"data": signin_request.POST}
# SignUpForm Instatiation with post data
# makes SignupView.form_valid method activate
signup_form = SignupForm(**signup_form_kwargs)
signup_form.cleaned_data = post_dic # Csrf token not neccesary either
# Generates a user object from the form data
user = signup_form.save(signin_request)
# If phone number supplied add it to the model
user.phone_number = phonenumber
user.save()
# Sends allauth.signed_up signal
signals.user_signed_up.send(sender=user.__class__,
request=signin_request,
user=user,
signal_kwargs={})
return user
# With `ACCOUNT_AUTHENTICATION_METHOD = "email"`
#allauth_regular_user = create_allauth_user("*****@*****.**")
def test_signup_form(self):
form = SignupForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'password',
'password2': 'password'
})
self.assertTrue(form.is_valid())
def _invalid_questionnaire(self, req):
req.method = 'GET' # very dirty hacking
res = account_signup(req)
form = AccountSignupForm(req.POST)
form.is_valid()
res.context_data['form'] = form
res.context_data['questionnaire_form'] = self.questionnaire_form
return redirect(reverse('dateprofile:account_signup'))
def test_signup_form(self):
form = SignupForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'password',
'password2': 'password'
})
self.assertTrue(form.is_valid())
def test_duplicate_email(self):
User.objects.create_user("test1", "*****@*****.**", "testpass")
form = SignupForm(
{"username": "******", "email": "*****@*****.**", "password1": "password", "password2": "password"}
)
self.assertFalse(form.is_valid())
self.assertIn("email", form.errors)
def test_password_mismatch(self):
form = SignupForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'password',
'password2': 'passwordmismatch'
})
self.assertFalse(form.is_valid())
self.assertIn('__all__', form.errors)
self.assertIn('You must type the same password each time.',
form.errors['__all__'])
def validate(self, attrs):
self.signup_form = SignupForm(attrs)
if False == self.signup_form.is_valid():
errors = OrderedDict()
form_errors = dict(self.signup_form.errors)
for error_field in form_errors.keys():
errors[error_field] = form_errors[error_field]
raise serializers.ValidationError(errors)
return serializers.Serializer.validate(self, attrs)
def test_duplicate_email(self):
User.objects.create_user('test1', '*****@*****.**', 'testpass')
form = SignupForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'password',
'password2': 'password'
})
self.assertFalse(form.is_valid())
self.assertIn('email', form.errors)
def test_duplicate_email(self):
User.objects.create_user('test1', '*****@*****.**', 'testpass')
form = SignupForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'password',
'password2': 'password'
})
self.assertFalse(form.is_valid())
self.assertIn('email', form.errors)
def test_password_mismatch(self):
form = SignupForm(
{
"username": "******",
"email": "*****@*****.**",
"password1": "password",
"password2": "passwordmismatch",
}
)
self.assertFalse(form.is_valid())
self.assertIn("__all__", form.errors)
self.assertIn("You must type the same password each time.", form.errors["__all__"])
def test_non_ascii_username(self):
form = SignupForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'password',
'password2': 'password',
})
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['username'], [
'Enter a valid username. This value may contain only '
'English letters, numbers, and @/./+/-/_ characters.'
])
def modal_signup(request, **kwargs):
if request.method == "POST":
signup_form = SignupForm(request.POST)
if signup_form.is_valid():
user = signup_form.save(request)
next = request.POST.get("next","/food/")
complete_signup(request, user, "/food/")
return HttpResponse(next)
redirect_field_name, redirect_field_value = "next", request.referer
response = render(request, "signup_error.html", locals())
response.status_code = 400
return response
def test_password_mismatch(self):
form = SignupForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'password',
'password2': 'passwordmismatch'
})
self.assertFalse(form.is_valid())
self.assertIn('__all__', form.errors)
self.assertIn(
'You must type the same password each time.',
form.errors['__all__']
)
def signup(self, request, **kwargs):
self.method_check(request, allowed=['post'])
data = self.deserialize(
request, request.body,
format=request.META.get('CONTENT_TYPE', 'application/json'))
try:
form = SignupForm(data)
if not form.is_valid():
return self.create_response(request, {
'success': False,
'reason': 'form',
'error_type': 'dict',
'error': form.errors,
}, HttpBadRequest)
user = form.save(request)
response = complete_signup(request, user,
app_settings.EMAIL_VERIFICATION,
success_url='/')
if response.status_code not in [200, 201, 301, 302]:
return self.create_response(request, {
'success': False,
'reason': 'status',
'error_type': 'str',
'error': 'Got bad status code {}'.format(response.status_code),
})
# Set session expiry
request.session.set_expiry(settings.SESSION_COOKIE_AGE)
return self.create_response(request, {
'success': True,
'id': user.id,
'resource_uri': self.get_resource_uri(user),
}, HttpCreated)
except ValidationError as e:
return self.create_response(request, {
'success': False,
'reason': 'invalid',
'error_type': 'list',
'error': e.messages,
}, HttpBadRequest)
except Exception as e:
return self.create_response(request, {
'success': False,
'reason': 'exception',
'error_type': 'str',
'error': '{}'.format(e),
}, HttpBadRequest)
def test_password_mismatch(self):
form = SignupForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'password',
'password2': 'passwordmismatch'
})
self.assertFalse(form.is_valid())
# Since django-allauth 0.27.0, the "You must type the same password
# each time" form validation error that can be triggered during
# signup is added to the 'password2' field instead of being added to
# the non field errors.
self.assertIn('password2', form.errors)
self.assertEqual(form.errors['password2'],
['You must type the same password each time.'])
def get_context_data(self, **kwargs):
context_data = super(StudentInfoView, self).get_context_data(**kwargs)
context_data.update({
'regInfo':
self.request.session[REG_VALIDATION_STR].get('regInfo', {}),
'payAtDoor':
self.request.session[REG_VALIDATION_STR].get('payAtDoor', False),
'currencySymbol':
getConstant('general__currencySymbol'),
})
# Add the Series, Event, and DanceRole objects to the context data based on what was submitted
# through the form.
subtotal = 0
for k, v in context_data['regInfo'].get('events', {}).items():
event = Event.objects.prefetch_related('pricingTier').get(id=k)
dropin_keys = [x for x in v.keys() if x.startswith('dropin_')]
if dropin_keys:
name = _('DROP IN: %s' % event.name)
base_price = event.getBasePrice(dropIns=len(dropin_keys))
else:
name = event.name
base_price = event.getBasePrice(
payAtDoor=context_data['payAtDoor'])
subtotal += base_price
if v.get('role'):
role_name = DanceRole.objects.get(id=v.get('role')).name
else:
role_name = None
context_data['regInfo']['events'][k].update({
'name':
name,
'role_name':
role_name,
'base_price':
base_price,
})
context_data['subtotal'] = subtotal
if context_data[
'payAtDoor'] or self.request.user.is_authenticated or not getConstant(
'registration__allowAjaxSignin'):
context_data['show_ajax_form'] = False
else:
# Add a login form and a signup form
context_data.update({
'show_ajax_form': True,
'login_form': LoginForm(),
'signup_form': SignupForm(),
})
return context_data
def get_context_data(self, **kwargs):
context_data = super(StudentInfoView, self).get_context_data(**kwargs)
reg = self.temporaryRegistration
context_data.update({
'reg':
reg,
'payAtDoor':
reg.payAtDoor,
'currencySymbol':
getConstant('general__currencySymbol'),
'subtotal':
sum([x.price for x in reg.temporaryeventregistration_set.all()]),
})
if reg.payAtDoor or self.request.user.is_authenticated or not getConstant(
'registration__allowAjaxSignin'):
context_data['show_ajax_form'] = False
else:
# Add a login form and a signup form
context_data.update({
'show_ajax_form': True,
'login_form': LoginForm(),
'signup_form': SignupForm(),
})
return context_data
def create_allauth_user(email, password):
post_dic = get_post_dic(email, password)
signin_request = get_signin_request(post_dic)
signup_form_kwargs = {"files": {}, "initial": {},
"data": signin_request.POST}
signup_form = SignupForm(**signup_form_kwargs)
signup_form.cleaned_data = post_dic # Csrf token not neccesary either
user = signup_form.save(signin_request)
# Sends sign up mail, alter to invite mail later on
signals.user_signed_up.send(sender=user.__class__,
request=signin_request,
user=user,
signal_kwargs={})
return user
def get_context_data(self, form, **kwargs):
context = super(PremierPasWizard, self).get_context_data(form=form,
**kwargs)
if self.steps.current == 'categorie_user':
if self.request.method == "POST":
form = SignupForm(self.request.POST)
form.save(self.request)
# form = self.get_form('signup')
# form.save()
elif self.steps.current == 'confirmation':
categorie_user = self.get_cleaned_data_for_step('categorie_user')
etude_user = self.get_cleaned_data_for_step('etude_user')
faculte = etude_user['faculte']
universite = etude_user['universite']
cours = Cours.objects.filter(faculte=faculte)
context.update({'cours': cours})
return context
def create_allauth_user(email):
post_dic = get_post_dic(email)
signin_request = get_signin_request(post_dic)
signup_form_kwargs = {"files": {}, "initial": {},
"data": signin_request.POST}
# From allauth.account.views.SignupView.form_valid
signup_form = SignupForm(**signup_form_kwargs)
signup_form.cleaned_data = post_dic # Csrf token not neccesary either
user = signup_form.save(signin_request)
# Sends sign up mail
signals.user_signed_up.send(sender=user.__class__,
request=signin_request,
user=user,
signal_kwargs={})
return user
def iap_signup(request):
if request.method == 'POST':
data = JSONParser().parse(request)
receipt = data['receipt']
if ZappyUser.objects.filter(apple_receipt=receipt).exists():
return JsonResponse({'error': 'This In App Purchase has already been used. Please contact [email protected]', 'kick_out': True},
status=400)
verify_url = 'https://buy.itunes.apple.com/verifyReceipt'
if 'debug' in data:
if data['debug']:
verify_url = 'https://sandbox.itunes.apple.com/verifyReceipt'
receipt_json = json.dumps(
{"receipt-data": receipt, 'password': env.str('APP_SHARED_SECRET', default='')})
response = requests.request(
method='POST',
url=verify_url,
headers={'Content-Type': 'application/x-www-form-urlencoded'},
data=receipt_json
)
res_json = response.json()
try:
request.POST._mutable = True
request.POST['email'] = data['email']
request.POST['password1'] = data['password']
form = SignupForm(request.POST)
form.is_valid()
user = form.save(request)
user.apple_product_id = res_json['latest_receipt_info'][-1]['product_id']
user.apple_expires_date = datetime.datetime.fromtimestamp(
int(res_json['latest_receipt_info'][-1]['expires_date_ms']) / 1000)
user.active_membership = True
user.apple_receipt = receipt
user.save()
token = Token.objects.create(user=user)
return JsonResponse({'token': str(token)}, status=201)
except IntegrityError:
return JsonResponse({'error': 'That email has already been taken'},
status=400)
except KeyError:
return JsonResponse({'error': 'We had problems verifying the receipt. Please contact [email protected]', 'kick_out': True},
status=400)
except Exception as e:
print(e)
return JsonResponse({'error': 'Something went wrong. Please contact [email protected]', 'kick_out': True},
status=400)
def get_context_data(self, **kwargs):
context = super(LandingView, self).get_context_data(**kwargs)
context['featured_everyday_cooks'] = Cook.objects.filter(is_featured=True, cook_type__name__icontains='Everyday Cook')[:3]
context['featured_special_cooks'] = Cook.objects.filter(is_featured=True, cook_type__name__icontains='Special Cook')[:3]
context['eventfood'] = EventFood.objects.order_by('-created_at')[:5]
context['everydayfood'] = EverydayFood.objects.order_by('-created_at')[:5]
context['bakedfood'] = BakedFood.objects.order_by('-created_at')[:5]
context['form'] = SignupForm()
return context
def sign_me_up(request, email, pw1, pw2):
"""
Given data for the signup form from somewhere, sign up a user
and return that user.
Arguments:
- `request`: Request
- `email`: str
- `pw1`: str
- `pw2`: str
Return: RMUser or form with errors (Wonky behaviour, but this shouldn't happen...)
Exceptions: None
"""
form = SignupForm(data=dict(email=email, password1=pw1, password2=pw2))
if form.is_valid():
return form.save(request)
return form
def sign_me_up(request, email, pw1, pw2):
"""
Given data for the signup form from somewhere, sign up a user
and return that user.
Arguments:
- `request`: Request
- `email`: str
- `pw1`: str
- `pw2`: str
Return: RMUser or form with errors (Wonky behaviour, but this shouldn't happen...)
Exceptions: None
"""
form = SignupForm(data=dict(email=email, password1=pw1, password2=pw2))
if form.is_valid():
return form.save(request)
return form
def get(self, request, *args, **kwargs):
# すでにログインしている場合はダッシュボード画面へリダイレクト
if request.user.is_authenticated:
return redirect(reverse('dashborad:index'))
context = {
'form': RegisterForm(),
'auth_formm': SignupForm(),
}
return render(request, 'accounts/register.html', context)
def get_context_data(self, **kwargs):
if 'form' in self.request.session and 'login_form' in self.request.session:
ctx = {}
if self.request.session['form']:
ctx['form'] = SignupForm(self.request.session['form'])
ctx['form'].is_valid()
else:
ctx['form'] = SignupForm()
if self.request.session['login_form']:
ctx['login_form'] = LoginForm(self.request.session['login_form'])
ctx['login_form'].is_valid()
else:
ctx['login_form'] = LoginForm()
del self.request.session['form']
del self.request.session['login_form']
else:
ctx = super(SignupView, self).get_context_data(**kwargs)
ctx['login_form'] = LoginForm()
return ctx
def create_allauth_user(email):
post_dic = get_post_dic(email)
signin_request = get_signin_request(post_dic)
signup_form_kwargs = {
"files": {},
"initial": {},
"data": signin_request.POST
}
# From allauth.account.views.SignupView.form_valid
signup_form = SignupForm(**signup_form_kwargs)
signup_form.cleaned_data = post_dic # Csrf token not neccesary either
user = signup_form.save(signin_request)
# Sends sign up mail
signals.user_signed_up.send(sender=user.__class__,
request=signin_request,
user=user,
signal_kwargs={})
return user
def test_newline_in_username(self):
# django-allauth's default regex doesn't match '\n' at the
# end of a string so as a result of this, users can signup
# with a user name like 'username\n'.
#
# This is a problem when a user can fill the form via curl
# and Content-Type header set to
# 'application/x-www-form-urlencoded'.
#
# See #1045 and test_newline_in_username in
# users/tests/test_views.py for details.
form = SignupForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'password',
'password2': 'password',
})
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors['username'],
['Please don\'t use whitespace characters in username.'])
def post(self, request):
serializer = RegisterInputSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
signup_data = dict(serializer.validated_data)
confirmation_query_args = signup_data.pop('confirmation_query_args',
{})
email = signup_data.pop('email')
signup_data['email'] = signup_data['email2'] = email
if not settings.SET_PASSWORD_ON_EMAIL_CONFIRMATION:
password = signup_data.pop('password')
signup_data['password1'] = signup_data['password2'] = password
email_verification = allauth_settings.EMAIL_VERIFICATION
with transaction.atomic(), clear_messages(request):
form = SignupForm(data=signup_data)
if settings.SET_PASSWORD_ON_EMAIL_CONFIRMATION:
form.fields.pop('password1', None)
form.fields.pop('password2', None)
form_valid_or_raise(form, {
'password1': 'password',
'password2': None,
'email2': None
})
user = form.save(request=request)
if email_verification != allauth_settings.EmailVerificationMethod.NONE and confirmation_query_args:
user.extra_confirmation_data[
AccountAdapter.
CONFIRMATION_QUERY_ARGS] = confirmation_query_args
user.save()
response = complete_signup(request,
user,
email_verification,
success_url=None)
token = handle_login_response(response, user, allow_disabled=True)
response_serializer = TokenResponseSerializer({'token': token})
return Response(response_serializer.data)
def login(request):
"""
A view to render the login page
"""
login_form = LoginForm()
signup_form = SignupForm()
context = {
'login_form': login_form,
'signup_form': signup_form,
}
return render(request, 'login.html', context)
def test_newline_in_username(self):
# django-allauth's default regex doesn't match '\n' at the
# end of a string so as a result of this, users can signup
# with a user name like 'username\n'.
#
# This is a problem when a user can fill the form via curl
# and Content-Type header set to
# 'application/x-www-form-urlencoded'.
#
# See #1045 and test_newline_in_username in
# users/tests/test_views.py for details.
form = SignupForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'password',
'password2': 'password',
})
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors['username'],
['Please don\'t use whitespace characters in username.']
)
def test_newline_in_username(self):
# Note that since Django 1.9, forms.CharField().strip is True
# and it strips all whitespace characters by default so there
# is no need to do anything on our side.
#
# django-allauth's default regex doesn't match '\n' at the
# end of a string so as a result of this, users can signup
# with a user name like 'username\n'.
#
# This is a problem when a user can fill the form via curl
# and Content-Type header set to
# 'application/x-www-form-urlencoded'.
#
# See #1045 and test_newline_in_username in
# users/tests/test_views.py for details.
form = SignupForm({
'username': '******',
'email': '*****@*****.**',
'password1': 'password',
'password2': 'password',
})
self.assertTrue(form.is_valid())
def user_signup(request):
"""
Функция авторизации по ajax
"""
if request.is_ajax:
signup_form = SignupForm(request.POST)
if signup_form.is_valid():
signup_form.save(request)
data = {'reload': True}
return JsonResponse(data)
context = {
'reload': False,
'login_form': LoginForm,
'signup_form': signup_form
}
context.update(csrf(request))
html_content = loader.render_to_string(
template_name='include/user/user.html', context=context)
data = {'html_content': html_content}
return JsonResponse(data)
else:
return Http404
class SignupSerializer(serializers.Serializer):
username = serializers.CharField()
email = serializers.EmailField()
password1 = serializers.CharField(write_only=True)
password2 = serializers.CharField(write_only=True)
def __init__(self, instance=None, data=empty, **kwargs):
serializers.Serializer.__init__(self,
instance=instance,
data=data,
**kwargs)
self.new_user = None
self.signup_form = None
def validate(self, attrs):
self.signup_form = SignupForm(attrs)
if False == self.signup_form.is_valid():
errors = OrderedDict()
form_errors = dict(self.signup_form.errors)
for error_field in form_errors.keys():
errors[error_field] = form_errors[error_field]
raise serializers.ValidationError(errors)
return serializers.Serializer.validate(self, attrs)
def save(self, **_kwargs):
request = self.context.get('request')
if self.signup_form is not None:
self.new_user = self.signup_form.save(request)
return self.new_user
def to_representation(self, _instance):
new_user = self.new_user
if new_user is None:
return dict()
return UserSerializer(instance=new_user).data
def video_signup(request, slug):
if not request.method == 'POST':
raise Exception('This view is meant to be called via a POST request.')
video, created = get_or_create_video(slug)
login_success = False
outbound_message = dict()
outbound_message[DATA_KEY] = {}
form = SignupForm(data=json.loads(request.raw_post_data))
if form.is_valid():
user = form.save(request)
perform_login(request, user)
login_success = True
action.send(user, verb='registered account', action_object=video)
action.send(user, verb='viewed video', action_object=video)
userSerializer = UserSerializer(user)
userSerialized = JSONRenderer().render(userSerializer.data)
outbound_message[DATA_KEY]['user'] = json.loads(userSerialized)
outbound_message[DATA_KEY]['share_url'] = reverse('profiles-share',
args=[
user.username,
slug,
])
else:
outbound_message[DATA_KEY]['errors'] = \
json.loads(errors_to_json(form.errors))
outbound_message[EVENT_TYPE_KEY] = 'FB_SIGNUP'
outbound_message[CHANNEL_KEY] = \
'/framebuzz/session/%s' % request.session.session_key
outbound_message[DATA_KEY]['login_success'] = login_success
return HttpResponse(json.dumps(outbound_message),
content_type="application/json")
def signup_paciente(request):
# return render(request, 'med_app/signup-paciente.html')
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
form.save(request)
username = form.cleaned_data.get('email')
raw_password = form.cleaned_data.get('password1')
user = authenticate(username=username, password=raw_password)
##login(request, user)
# return redirect('home')
else:
form = SignupForm()
return render(request, 'med_app/signup-paciente.html', {'form': form})
def index(request):
user = request.user
context = {}
if not user.is_authenticated:
form = SignupForm()
context['form'] = form
template = loader.get_template('home.html')
response = HttpResponse(template.render(context, request))
else:
socials = Social.objects.filter(account=user).order_by('-updated_at')
if not socials:
response = redirect('publisher:connect')
else:
response = redirect('publisher:content_create')
return response
def finance_website(request):
if request.method == "GET":
stock = finance_stock(request)
data = get_stock_price_data(stock)
script, div = create_stock_price_plot(data)
bid, ask, range_day, market_cap, beta, estimate, price = get_stock_summary_data(
stock)
movers = get_stock_movers(5)
watchlist_list = Watchlist.objects.filter(user=request.user.id)
feed = news_feed(stock)
login_form = LoginForm()
signup_form = SignupForm()
context = {
"stock": stock,
"bid": bid,
"ask": ask,
"range": range_day,
"market_cap": market_cap,
"beta": beta,
"estimate": estimate,
"the_script": script,
"the_div": div,
"movers": movers,
"watchlist_list": watchlist_list,
"news": feed,
"price": price,
"login_form": login_form,
"signup_form": signup_form
}
return render(request, "finance.html", context)
else:
form = WatchlistForm(request.POST)
form.save()
return redirect(request.get_full_path())
def post(self, request, *args, **kwargs):
logger.info("You're in post!!!")
# リクエストからフォームを作成
form = RegisterForm(request.POST)
auth_form = SignupForm(request.POST)
# バリデーション
if not form.is_valid():
# バリデーションNGの場合はアカウント登録画面のテンプレートを再表示
return render(request, 'accounts/register.html', {'form': form})
# 保存する前に一旦取り出す
user = form.save(commit=False)
# パスワードをハッシュ化してセット
user.set_password(form.cleaned_data['password'])
# ユーザーオブジェクトを保存
user.save()
# ログイン処理（取得した Userオブジェクトをセッションに保存 & Userデータを更新）
auth_login(request, user)
return redirect(settings.LOGIN_REDIRECT_URL)
def login(request, **kwargs):
success_url = kwargs.pop("success_url", None)
if success_url is None:
success_url = "/"
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
return form.login(request, redirect_url=success_url)
else:
form = LoginForm()
registerform = SignupForm()
ctx = {
"form": form,
"registerform": registerform,
"redirect_field_name": "next",
"redirect_field_value": request.REQUEST.get("next"),
"apps": SocialApp.objects.all(),
}
return render_to_response('users/login.html', RequestContext(request, ctx))
def test_signup_form(self):
form = SignupForm(
{"username": "******", "email": "*****@*****.**", "password1": "password", "password2": "password"}
)
self.assertTrue(form.is_valid())
def reservation(request, id):
service = get_object_or_404(Service, id=id)
chosen_employee = None
emp_size = 0
if not service.is_active():
raise Http404
minTime, maxTime = getMinMaxTime(service.service_provider)
#step2 = request.session['_step'] if '_step' in request.session
step2 = request.GET.get('step', None)
# POST
step = request.POST.get('step', None)
data = None
if step:
try:
data = pickle.loads(base64.b64decode(request.POST.get('data'))) # Serializes an object from request
except:
raise Http404
elif step2:
step = step2
if 'reservation_data' in request.session:
data = request.session['reservation_data']
else:
step = None
if (request.method != 'POST' and data is None) or step is None:
#form = ReservationForm(request, workingHours=None, service=None)
form = ReservationForm(request, workingHours=None, service=service)
data = {'service_provider_id': service.service_provider_id, 'service_id': service.id}
return render_to_response('reservations/reservation.html', locals(), context_instance=RequestContext(request))
workingHours = WorkingHours.objects.filter(service_provider_id=service.service_provider_id)
#formNonRegisteredUser = NonRegisteredUserForm(prefix='nonRegBtn')
formNonRegisteredUser = NonRegisteredUserForm(provider=service.service_provider)
loginForm = LoginForm(prefix='loginBtn')
signupForm = SignupForm(prefix='signupBtn')
if step == '1':
# Service, date, time
# form = ReservationForm(request.POST, workingHours='gergerre')
form = ReservationForm(request, request.POST, workingHours=workingHours, service=service)
if form.is_valid():
chosen_employee = form.cleaned_data['employees']
data['date'] = form.cleaned_data['date']
data['time'] = form.cleaned_data['time']
data['number'] = form.cleaned_data['number']
data['employees'] = form.cleaned_data['employees']
if request.user.is_authenticated():
data['user_id'] = request.user.id
data['name'] = request.user.get_full_name()
data['phone'] = request.user.phone
data['email'] = request.user.email
return render_to_response('reservations/confirmation.html', locals(),
context_instance=RequestContext(request))
return render_to_response('reservations/userinfo.html', locals(), context_instance=RequestContext(request))
return render_to_response('reservations/reservation.html', locals(), context_instance=RequestContext(request))
if step == '2':
if data.get('date') is None or data.get('time') is None:
raise Http404
if 'signupBtn' in request.POST:
signupForm = SignupForm(request.POST, prefix='signupBtn')
if signupForm.is_valid():
userr = signupForm.save(request)
data['user_id'] = userr.id
data['name'] = userr.get_full_name()
data['phone'] = userr.phone
data['email'] = userr.email
return render_to_response('reservations/confirmation.html', locals(),
context_instance=RequestContext(request))
if 'loginBtn' in request.POST:
loginForm = LoginForm(request.POST, prefix='loginBtn')
if loginForm.is_valid():
data['user_id'] = loginForm.user.id
data['name'] = loginForm.user.get_full_name()
data['phone'] = loginForm.user.phone
data['email'] = loginForm.user.email
request.session['reservation_data'] = data
return loginForm.login(request, redirect_url=reverse('reservation', args=[service.id]) + "?step=2a")
if 'nonRegBtn' in request.POST:
formNonRegisteredUser = NonRegisteredUserForm(request.POST, provider=service.service_provider)
if formNonRegisteredUser.is_valid():
data['name'] = formNonRegisteredUser.cleaned_data['name']
data['phone'] = formNonRegisteredUser.cleaned_data['phone']
data['email'] = formNonRegisteredUser.cleaned_data['email']
return render_to_response('reservations/confirmation.html', locals(),
context_instance=RequestContext(request))
return render_to_response('reservations/userinfo.html', locals(), context_instance=RequestContext(request))
if step == '2a':
if request.user.is_authenticated():
return render_to_response('reservations/confirmation.html', locals(),
context_instance=RequestContext(request))
if step == '3':
# Confirmation
if data.get('date') is None or data.get('time') is None: # or data.get('user_id') is None:
raise Http404
if data.get('user_id') is not None:
ruser = get_object_or_404(User, id=data.get('user_id'))
else:
ruser = None
sync(service.service_provider)
# Checking again if form for reservation is valid
chosen_employee = data.get('employees')
emp_id = None
if chosen_employee is not None and chosen_employee != '':
emp_id = chosen_employee.id
form = ReservationForm(request,
{'date': data.get('date'), 'time': data.get('time'), 'employees': emp_id},
workingHours=workingHours, service=service)
if form.is_valid():
form_emp = None
if chosen_employee != '':
form_emp = chosen_employee
reserve = Reservation(user=ruser, service=service, date=data['date'], time=data['time'],
employee=form_emp)
# Add backup fields
reserve.user_fullname = data.get('name')
reserve.user_phone = data.get('phone')
reserve.user_email = data.get('email')
reserve.service_provider = service.service_provider
reserve.service_name = service.name
reserve.service_duration = service.duration
reserve.service_price = service.discounted_price()
reserve.show_up = False
if chosen_employee is not None and chosen_employee != '':
reserve.employee = chosen_employee
else:
# if employees assigned to service, randomly choose one who is free
if service.employees.all().__len__() > 0:
today_r = Reservation.objects.filter(employee__in=service.employees.all(), date=reserve.date)
# find free employees
reserveDt = datetime.datetime.combine(reserve.date, reserve.time)
free_emp = list(service.employees.all())
free_emp_editable = list(service.employees.all())
for emp in free_emp:
emp_time = EmployeeWorkingHours.objects.filter(employee=emp.id)[0].get_for_day(emp,
reserve.date.weekday())
if not EmployeeWorkingHours.objects.filter(employee=emp.id)[0].get_for_day(emp,
reserve.date.weekday()):
free_emp_editable.remove(emp)
if reserve.time < emp_time.time_from or reserveDt + datetime.timedelta(
minutes=reserve.service_duration) > datetime.datetime.combine(reserve.date,
emp_time.time_to):
free_emp_editable.remove(emp)
for r in today_r:
rDt = datetime.datetime.combine(r.date, r.time)
if r.active_during(reserveDt):
if r.employee in free_emp:
free_emp_editable.remove(r.employee)
# choose random employee
if free_emp_editable:
random_employee = free_emp_editable[random.randint(0, len(free_emp_editable) - 1)]
reserve.employee = random_employee
# Save
reserve.user.notification_type = 'email'
reserve.save()
# saving coupon is_valid
coupons = Coupon.objects.filter(service=service.id)
coupon_is_used = False
for coup in coupons:
if data['number'] == coup.number:
coup.is_used = True
coup.save()
coupon_is_used = True
# Validation checking in form
user_page_link = '%s/u/%s' % (settings.BASE_URL, reserve.service_provider.userpage_link)
email_to1 = data.get('email')
email_to2 = service.service_provider.user.email
if service.service_provider.reservation_confirmation_needed:
subject = _('Confirmation of service reservation')
renderedToCustomer = render_to_string('emails/reservation_customer.html',
{'reservation': reserve, 'link': user_page_link})
renderedToProvider = render_to_string('emails/reservation_provider.html',
{'reservation': reserve, 'link': user_page_link})
message1 = (subject, renderedToCustomer, None, [email_to1])
message2 = (subject, renderedToProvider, None, [email_to2])
send_mass_mail((message1, message2), fail_silently=True)
else:
subject = _('Confirmation of service reservation')
renderedToCustomer = render_to_string('emails/reservation_customer.html',
{'reservation': reserve, 'link': user_page_link})
send_mail(subject, renderedToCustomer, email_to2, [email_to1],
fail_silently=False)
start = datetime.datetime.combine(reserve.date, reserve.time)
gcal_params = urllib.urlencode({
'action': 'TEMPLATE',
'text': reserve.service_name.encode('utf8'),
'dates': '%s/%s' % (datetime_to_url_format(start),
datetime_to_url_format(
start + datetime.timedelta(minutes=reserve.service_duration))),
'details': reserve.service.description.encode('utf8'),
'location': reserve.service_provider.full_address().encode('utf8'),
'trp': 'true',
'sprop': 'E-Narocanje',
'sprop': 'name:%s' % settings.BASE_URL,
})
url_service = settings.BASE_URL + reverse('service', args=(service.id,))
sync(service.service_provider)
return render_to_response('reservations/done.html', locals(), context_instance=RequestContext(request))
# Someone else has made a reservation in the meantime
return render_to_response('reservations/alreadyreserved.html', locals(),
context_instance=RequestContext(request))
raise Http404
