def perform_create(self, serializer):
user = serializer.save()
signals.user_registered.send(sender=self.__class__, user=user, request=self.request)
if settings.get('SEND_ACTIVATION_EMAIL'):
self.send_activation_email(user)
elif settings.get('SEND_CONFIRMATION_EMAIL'):
self.send_confirmation_email(user)
def get_email_context(self, user):
token = self.token_generator.make_token(user)
uid = encode_uid(user.pk)
return {
'user': user,
'domain': settings.get('DOMAIN'),
'site_name': settings.get('SITE_NAME'),
'uid': uid,
'token': token,
'protocol': 'https' if self.request.is_secure() else 'http',
}
def create(self, request, *args, **kwargs):
nickname = request.data['nickname'] if False else ' '
sex= request.data['sex'] if False else 1
phone = request.data['phone'] if False else ' '
data = {
'email':request.data['email'],
'username':request.data['username'],
'password':request.data['password'],
'nickname':nickname,
'sex':sex,
'phone':phone,
}
# 这里还要添加验证模型的东西
user = User(email = data['email'],username = data['username'],password = data['password'],is_active = 0)
try:
user.save()
profile = Profile(nickname=data['nickname'], sex=data['sex'], phone=data['phone'], user=user,user_id=user.id)
profile.save()
signals.user_registered.send(sender=self.__class__, user=user, request=self.request)
if 1:
self.send_activation_email(user)
elif settings.get('SEND_CONFIRMATION_EMAIL'):
self.send_confirmation_email(user)
return Response({'status': 'User created success'},
status=status.HTTP_201_CREATED)
except:
return Response({'status': 'error'},
status=status.HTTP_400_BAD_REQUEST)
def get_email_context(self, user):
"""Get context for activation email (from Djoser app)
"""
context = super().get_email_context(user)
context['url'] = djoser_settings.get('ACTIVATION_URL').format(
**context)
return context
def perform_create(self, serializer):
user = serializer.validated_data
# if no email is entered, an email is generated from the username for the purposes of creating a Dwolla account
if (user['email'] == ""):
email = str(user['username']) + '@gmail.com'
else:
email = str(user['email'])
instance = serializer.save()
user = serializer.data
user = User.objects.get(id=user['id'])
owner = user.owner
checkNum = str(owner.checkNum)
saveNum = str(owner.saveNum)
routeNum = str(owner.routeNum)
signals.user_registered.send(sender=self.__class__, user=instance, request=self.request)
# gets a token
token = genauthtoken.genToken()
# makes a customer on Dwolla
customer = customergen.makeCust(token, "test", "test2", email, str(owner.address), str(owner.city), str(owner.state), str(owner.postalcode), str(owner.dob), str(owner.ssn), str(owner.phone))
# send bank account info to Dwolla
checkbank = addbank.makeBank(token, customer, routeNum, checkNum, str(user.username))
savebank = addbank.makeBank(token, customer, routeNum, saveNum, str(user.username))
verifybank.verify(token, checkbank)
verifybank.verify(token, savebank)
owner.custDwolla = customer
owner.checkSource = checkbank
owner.saveSource = savebank
owner.save()
if settings.get('SEND_ACTIVATION_EMAIL'):
self.send_email(**self.get_send_email_kwargs(instance))
def save(self):
if self.pk is not None:
current = Reimbursement.objects.get(pk=self.pk)
if current.status != self.status and current.status != "A" and current.status != "R":
if self.status == "A":
msg_text = render_to_string('reimbursement_approval.txt', {
'first_name': self.member.first_name,
'last_name': self.member.last_name,
'street_address': self.member.street_address,
'city': self.member.city,
'zip': self.member.zip,
'site_name': djoser_settings.get('SITE_NAME')
})
from_email = Email(settings.DEFAULT_FROM_EMAIL, 'Guaranteed Ride Home')
to_email = Email(self.member.email)
subject = 'Guaranteed Ride Home Accepted Reimbursement - Please review mailing address'
content = Content("text/plain", msg_text)
mail = Mail(from_email, subject, to_email, content)
response = sg.client.mail.send.post(request_body=mail.get())
print(response.status_code)
from_email = Email(settings.DEFAULT_FROM_EMAIL, 'Guaranteed Ride Home')
to_email = Email(settings.ADMIN_EMAIL)
to_email2 = Email(settings.ADMIN_EMAIL2)
subject = '[GRH] Accepted Reimbursement - Please review mailing address'
content = Content("text/plain", msg_text)
mail = Mail(from_email, subject, to_email, content)
response = sg.client.mail.send.post(request_body=mail.get())
print(response.status_code)
mail = Mail(from_email, subject, to_email2, content)
response = sg.client.mail.send.post(request_body=mail.get())
print(response.status_code)
elif self.status == "R":
msg_text = render_to_string('reimbursement_rejection.txt', {'first_name': self.member.first_name, 'site_name': djoser_settings.get('SITE_NAME')})
from_email = Email(settings.DEFAULT_FROM_EMAIL, 'Guaranteed Ride Home')
to_email = Email(self.member.email)
subject = 'Guaranteed Ride Home Declined Reimbursement'
content = Content("text/plain", msg_text)
mail = Mail(from_email, subject, to_email, content)
response = sg.client.mail.send.post(request_body=mail.get())
print(response.status_code)
from_email = Email(settings.DEFAULT_FROM_EMAIL, 'Guaranteed Ride Home')
to_email = Email(settings.ADMIN_EMAIL)
to_email2 = Email(settings.ADMIN_EMAIL2)
subject = '[GRH] Declined Reimbursement'
content = Content("text/plain", msg_text)
mail = Mail(from_email, subject, to_email, content)
response = sg.client.mail.send.post(request_body=mail.get())
print(response.status_code)
mail = Mail(from_email, subject, to_email2, content)
response = sg.client.mail.send.post(request_body=mail.get())
print(response.status_code)
super(Reimbursement, self).save()
def get_serializer_class(self):
"""Return the serializer class."""
from djoser import settings
if settings.get('LOGIN_AFTER_REGISTRATION'):
return RegistrationSerializer
else:
raise NotImplementedError("Missing serializer.")
def perform_create(self, serializer):
instance = serializer.save()
djoser_signals.user_registered.send(sender=self.__class__,
user=instance.user,
request=self.request)
if djoser_settings.get('SEND_ACTIVATION_EMAIL') \
and not instance.user.email_verified:
self.send_email(**self.get_send_email_kwargs(instance.user))
def create(self, validated_data):
if settings.get('SEND_ACTIVATION_EMAIL'):
with transaction.atomic():
user = User.objects.create_user(**validated_data)
user.is_active = False
user.save(update_fields=['is_active'])
else:
user = User.objects.create_user(**validated_data)
return user
def resend_verification(self, request, email):
try:
user = ApellaUser.objects.get(email=email, email_verified=False)
except ApellaUser.DoesNotExist:
raise PermissionDenied("user.invalid.or.activated")
if djoser_settings.get('SEND_ACTIVATION_EMAIL'):
self.send_email(**self.get_send_email_kwargs(user))
return HttpResponse(status=202)
def get_email_context(self, user):
"""Replace the SendEmailViewMixin's e-mail sending method.
When we send new tenant members, or new tenant_admins, e-mail about
their being added to a new tenant, this provides additional
context for the templates.
:param user: A user, with the additional attribute
perform_create_tenant_name
:type user: User
"""
from djoser import settings
return {'domain': settings.get('DOMAIN'),
'site_name': settings.get('SITE_NAME'),
'protocol': 'https' if self.request.is_secure() else 'http',
"tenant_name": user.perform_create_tenant_name,
"username": user.username
}
def get_email_context(self, user):
"""Replace the SendEmailViewMixin's e-mail sending method.
When we send new tenant members, or new tenant_admins, e-mail about
their being added to a new tenant, this provides additional
context for the templates.
:param user: A user, with the additional attribute
perform_create_tenant_name
:type user: User
"""
from djoser import settings
return {
'domain': settings.get('DOMAIN'),
'site_name': settings.get('SITE_NAME'),
'protocol': 'https' if self.request.is_secure() else 'http',
"tenant_name": user.perform_create_tenant_name,
"username": user.username
}
def action(self, serializer):
if serializer.user.is_active:
raise ParseError('This token has already been used')
serializer.user.is_active = True
if serializer.validated_data.get('password', None):
serializer.user.set_password(serializer.validated_data['password'])
serializer.user.save()
signals.user_activated.send(
sender=self.__class__, user=serializer.user, request=self.request)
if djoser_settings.get('LOGIN_AFTER_ACTIVATION'):
token, _ = Token.objects.get_or_create(user=serializer.user)
data = serializers.TokenSerializer(token).data
else:
data = {}
return Response(data=data, status=status.HTTP_200_OK)
def mutate_and_get_payload(cls, input, context, info):
email = input.get('email')
password = input.get('password')
password_repeat = input.get('password_repeat')
if password == password_repeat:
try:
user = UserModel.objects.create(email=email, is_active=False)
user.set_password(password)
user.save()
if djoser_settings.get('SEND_ACTIVATION_EMAIL'):
send_activation_email(user, context)
return Register(success=bool(user.id))
except:
errors = ["email", "Email already registered."]
return Register(success=False, errors=errors)
errors = ["password", "Passwords don't match."]
return Register(success=False, errors=errors)
class UserRegistrationSerializer(serializers.ModelSerializer):
email = serializers.EmailField(required=True)
password = serializers.CharField(
style={'input_type': 'password'},
write_only=True,
validators=settings.get('PASSWORD_VALIDATORS'))
class Meta:
model = User
fields = tuple(User.REQUIRED_FIELDS) + (
User.USERNAME_FIELD, User._meta.pk.name, 'password', 'email')
def create(self, validated_data):
if settings.get('SEND_ACTIVATION_EMAIL'):
with transaction.atomic():
user = User.objects.create_user(**validated_data)
user.is_active = False
user.save(update_fields=['is_active'])
else:
user = User.objects.create_user(**validated_data)
return user
def perform_create(self, serializer):
user = serializer.validated_data
# if no email is entered, an email is generated from the username for the purposes of creating a Dwolla account
if (user['email'] == ""):
email = str(user['username']) + '@gmail.com'
else:
email = str(user['email'])
instance = serializer.save()
user = serializer.data
user = User.objects.get(id=user['id'])
owner = user.owner
checkNum = str(owner.checkNum)
saveNum = str(owner.saveNum)
routeNum = str(owner.routeNum)
signals.user_registered.send(sender=self.__class__,
user=instance,
request=self.request)
# gets a token
token = genauthtoken.genToken()
# makes a customer on Dwolla
customer = customergen.makeCust(token, "test", "test2", email,
str(owner.address), str(owner.city),
str(owner.state),
str(owner.postalcode), str(owner.dob),
str(owner.ssn), str(owner.phone))
# send bank account info to Dwolla
checkbank = addbank.makeBank(token, customer, routeNum, checkNum,
str(user.username))
savebank = addbank.makeBank(token, customer, routeNum, saveNum,
str(user.username))
verifybank.verify(token, checkbank)
verifybank.verify(token, savebank)
owner.custDwolla = customer
owner.checkSource = checkbank
owner.saveSource = savebank
owner.save()
if settings.get('SEND_ACTIVATION_EMAIL'):
self.send_email(**self.get_send_email_kwargs(instance))
class UserRegistrationSerializer(djoser_serializers.UserRegistrationSerializer):
#password = serializers.CharField(style={'input_type': 'password'},
# write_only=True,
# validators=djoser_settings.get('PASSWORD_VALIDATORS'))
password2 = serializers.CharField(style={'input_type': 'password'},
write_only=True,
validators=djoser_settings.get('PASSWORD_VALIDATORS'))
email = serializers.EmailField(required=True)
def validate_email(self, value):
value = value.strip()
exists = User.objects.filter(email=value).exists()
if exists:
raise serializers.ValidationError(_("This email already in use."))
return value
class Meta:
model = User
fields = ['username', 'email', 'password', 'password2']
def validate(self, data):
password2 = data.pop('password2')
if data['password'] != password2:
raise serializers.ValidationError(_("Passwords not equal."))
return data
def create(self, validated_data):
user = User.objects.create_user(**validated_data)
#if djoser_settings.get('SEND_ACTIVATION_EMAIL'):
# user.is_active = False
# user.save(update_fields=['is_active'])
return user
def mutate_and_get_payload(cls, input, context, info):
email = input.get('email')
password = input.get('password')
password_repeat = input.get('password_repeat')
if password == password_repeat:
try:
user = UserModel.objects.create(
email=email,
username=email,
is_active=True
)
user.set_password(password)
user.save()
if djoser_settings.get('SEND_ACTIVATION_EMAIL'):
send_activation_email(user, context)
return Register(success=bool(user.id),uid=encode_uid(user.pk))
except IntegrityError:
errors = ["email", "Email already registered."]
return Register(success=False, errors=errors, uid='')
except Exception as e:
errors = [str(e)]
return Register(success=False, errors=errors, uid='')
errors = ["password", "Passwords don't match."]
return Register(success=False, errors=errors, uid='')
def get_serializer_class(self):
from djoser import serializers
print serializers.SetPasswordSerializer
if settings.get('SET_PASSWORD_RETYPE'):
return serializers.SetPasswordRetypeSerializer
return serializers.SetPasswordSerializer
def get_email_context(self, user):
context = super(Passwordresert, self).get_email_context(user)
context['url'] = settings.get('PASSWORD_RESET_CONFIRM_URL').format(**context)
return context
def get_email_context(self, user):
context = super().get_email_context(user)
context['url'] = djoser_settings.get('PASSWORD_RESET_CONFIRM_URL').format(**context)
return context
def post_save(self, obj, created=False):
if djoser_settings.get('LOGIN_AFTER_REGISTRATION'):
Token.objects.get_or_create(user=obj)
if djoser_settings.get('SEND_ACTIVATION_EMAIL'):
context = self.get_send_email_kwargs(obj).get('context', {})
context['first_name'] = obj.first_name
def get_email_context(self, user):
context = super(AccountLogin, self).get_email_context(user)
context["url"] = settings.get("ACTIVATION_URL").format(**context)
return context
def get_email_context(self, user):
context = super(AccountLogin, self).get_email_context(user)
context['url'] = settings.get('ACTIVATION_URL').format(**context)
return context
def perform_create(self, serializer):
instance = serializer.save()
instance.save()
signals.user_registered.send(sender=self.__class__, user=instance, request=self.request)
if settings.get("SEND_ACTIVATION_EMAIL"):
self.send_email(**self.get_send_email_kwargs(instance))
def create(self, request):
serializer = self.get_serializer(data=request.DATA, partial=True)
# We add the current user to the object/instance after serializing the request data.
if serializer.is_valid():
serializer.object.member = request.user
serializer.object.full_clean()
serializer.save()
msg_text = render_to_string('reimbursement_submittal.txt', {'first_name': request.user.first_name, 'site_name': djoser_settings.get('SITE_NAME')})
from_email = Email(settings.DEFAULT_FROM_EMAIL, 'Guaranteed Ride Home')
to_email = Email(request.user.email)
subject = 'Guaranteed Ride Home Submittal Confirmation'
content = Content("text/plain", msg_text)
mail = Mail(from_email, subject, to_email, content)
sgResponse = sg.client.mail.send.post(request_body=mail.get())
print(sgResponse.status_code)
msg_text = render_to_string('reimbursement_submittal.txt', {'first_name': request.user.first_name, 'site_name': djoser_settings.get('SITE_NAME')})
from_email = Email(settings.DEFAULT_FROM_EMAIL, 'Guaranteed Ride Home')
to_email = Email(settings.ADMIN_EMAIL)
to_email2 = Email(settings.ADMIN_EMAIL2)
subject = '[GRH] Submittal Confirmation'
content = Content("text/plain", msg_text)
mail = Mail(from_email, subject, to_email, content)
sgResponse = sg.client.mail.send.post(request_body=mail.get())
print(sgResponse.status_code)
mail = Mail(from_email, subject, to_email2, content)
sgResponse = sg.client.mail.send.post(request_body=mail.get())
print(sgResponse.status_code)
headers = self.get_success_headers(serializer.data)
return response.Response(request.DATA,
status=status.HTTP_201_CREATED,
headers=headers)
else:
return response.Response(serializer.errors, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
