def signUpView(request):
# Checking If the User is already Logged In
if (request.user.is_authenticated):
checkAndRedirect(request.user)
if (request.method == 'POST'):
form = forms.SignUpForm(request.POST)
if (form.is_valid()):
# print()
instance = form.save(commit=False)
# Only after instance is saved We can access id
instance.save()
# Creating Profile Instance for the new user
profileInstance = models.Profile(user=instance)
profileInstance.save()
# Creating Customer Instance for the new user
customerInstance = Customer(user=instance)
customerInstance.save()
user = authenticate(request,
username=form.cleaned_data['username'],
password=form.cleaned_data['password1'])
if (user):
login(request, user)
return HttpResponseRedirect(reverse('customer:landing'))
else:
form = forms.SignUpForm()
context = {
'form': form,
'cartc': 0,
}
return render(request, 'accounts/signup.html', context)
def save_profile(backend, user, response, *args, **kwargs):
if backend.name == 'facebook':
try:
customer = user.get_customer()
except:
customer = None
if customer is None:
user.is_customer = True
user.save()
customer = Customer(user_id=user.id)
try:
customer.birthday = datetime.datetime.strptime(
response['birthday'], '%m/%d/%Y').strftime('%Y-%m-%d')
except:
pass
try:
url = "http://graph.facebook.com/%s/picture?type=large" \
% response["id"]
if url:
from urllib.request import urlopen, HTTPError
from django.template.defaultfilters import slugify
from django.core.files.base import ContentFile
avatar = urlopen(url)
customer.profile_picture.save(
slugify(user.username + " social") + '.jpg',
ContentFile(avatar.read()))
except HTTPError:
pass
customer.save()
Activity.push(user, 201,
user.username + ' is register with facebook')
Activity.push(user, 101,
user.username + ' log in as customer with facebook.')
def handle(self, *args, **options):
email = input('Set email: ')
password = input('Set password: '******'Company name: ')
if not email or not password or not company_name:
raise ValueError('Please, set correct input values.')
try:
validators.validate_email(email)
except exceptions.ValidationError:
print("Enter valid email address.")
try:
with transaction.atomic():
# create user from input info
email = email.lower()
customer = Customer(email=email)
customer.set_password(password)
customer.save()
# create User's profile and set all needed info regarding redshift output storage
profile, created = Profile.objects.get_or_create(
user=customer, defaults={"company_name": company_name})
profile.rs_username = profile.username_generator()
profile.rs_password = profile.password_generator()
profile.save()
# prepare DB in redshift output storage for newly created user
self.prepare_rs_db(user_info=profile)
except IntegrityError:
print("User or profile entry already exists.")
def index(request):
if (request.method == "GET"):
all_objects = [*User.objects.all(), *Customer.objects.all()]
customerJson = serializers.serialize('json', all_objects)
# print(customerJson)
customerJson = json.loads(customerJson)
for customer in customerJson:
print(customer)
return HttpResponse(status=200)
elif (request.method == "POST"):
body = json.loads(request.body.decode('utf-8'))
name = body['username']
country = body['country']
phone = body['phone']
#test fields
if not name or not country or not phone:
return HttpResponse("Some Are Fields not satisfied\n", status=400)
#assume that a user is a customer
user = User(username=name)
user.save()
#test country check
if not checkCountry(body['country']):
return HttpResponse("Country not found\n", status=400)
cus = Customer(user=user, country=country, phone=phone)
cus.save()
return HttpResponse("Saved \n")
def welcome(request):
if request.method == "POST":
user = User.objects.get(username=request.user.username)
license_number = request.POST.get("license_number")
fname = request.POST.get("fname")
lname = request.POST.get("lname")
number = request.POST.get("number")
city = request.POST.get("city")
nickname = request.POST.get("nickname")
about = request.POST.get("about")
address = request.POST.get("address")
user.first_name = fname
user.last_name = lname
user.number = number
user.save()
customer = Customer(user=user,
phone=number,
city=city,
address=address,
nickname=nickname,
license_number=license_number,
about=about,
terms_condition=True)
customer.save()
message_to_company(email=user.email,
message="someone signed up yay!! :)",
name=fname,
phone=number,
subject="Leads Team Rock and Roll")
Pay.objects.filter(user=user).update(firstname=fname, phone=number)
return redirect("customer:user_page")
return render(request, "register/welcome.html")
def newSelling(request):
if request.method == 'POST':
form = SellingForm(request.POST, request.FILES)
if form.is_valid():
package = Package.objects.get(package_id=form.cleaned_data.get('package_id'))
total_price= package.price + (package.price*7/100)
# -----------------cusForm-------------------
cus = Customer(
cus_id="",
fname=form.cleaned_data.get('cus_fname'),
lname=form.cleaned_data.get('cus_lname'),
address=form.cleaned_data.get('cus_address'),
province=form.cleaned_data.get('cus_province'),
zipcode=form.cleaned_data.get('cus_zipcode'),
id_card=form.cleaned_data.get('cus_id_card'),
phone=form.cleaned_data.get('cus_phone'),
email=form.cleaned_data.get('cus_email')
)
cus.save()
this_cus = Customer.objects.latest('id')
print(this_cus)
# -------emp---------------
employee = Employee.objects.get(user=request.user.id)
# ------------car-----------------
car = Car(
car_id="",
car_number=form.cleaned_data.get('car_number'),
province=form.cleaned_data.get('car_province'),
brand=form.cleaned_data.get('car_brand'),
chassis_number=form.cleaned_data.get('car_chassis_number'),
model=form.cleaned_data.get('car_model'),
car_cc=form.cleaned_data.get('car_cc'),
car_type=form.cleaned_data.get('car_type'),
sit=form.cleaned_data.get('car_sit'))
car.save()
this_car = Car.objects.latest('id')
print(this_car)
# ---------------Tranfer-----------------------
tran = Tranfer(
emp_id=employee,
Package_id=package,
balance=total_price,
pic_balance=form.cleaned_data['pic_balance'])
tran.save()
doc_nbr = uuid.uuid4().hex[:12].upper()
ins = Insure(doc_nbr=doc_nbr, agent_code=employee,
package_id=package,
car_id=this_car, car_number=this_car.car_number,
cus_id=this_cus,
company_order=package.company_name,
price=package.price, total_price=total_price,
post_date=date.today())
ins.save()
your_ins = Insure.objectslatest('id')
# messages.success(request, f'ได้รับข้อมูลกรมธรรม์แล้ว อยู่ระหว่างการรออนุมัติกรมธรรม์')
messages.success(request, f'ออกกรมธรรม์สำเร็จแล้ว <a href="/"></a>')
return HttpResponseRedirect('/')
else:
form = SellingForm()
return render(request, 'insurance/newSelling.html', {'form': form})
def signup(request):
if request.method == 'POST':
form = SignUpForm(request.POST)
if not form.is_valid():
return render(request, 'signup.html', {'form': form})
else:
# fetch data from inputs of form
email = form.cleaned_data.get('email')
password = form.cleaned_data.get('password')
first_name = form.cleaned_data.get('first_name')
last_name = form.cleaned_data.get('last_name')
telephone = form.cleaned_data.get('telephone')
address = form.cleaned_data.get('address')
User.objects.create_user(username=email,
password=password,
email=email,
first_name=first_name,
last_name=last_name)
user = authenticate(email=email, password=password)
login(request, user)
customer = Customer(user=user, tel=telephone, address=address)
customer.save()
return redirect('/')
else:
return render(request, 'signup.html', {'form': SignUpForm()})
def update_or_create_customer_from_order(self, order, mission_instance):
buyer_name = order.get("BuyerName")
buyer_mail = order.get("BuyerEmail")
if buyer_mail is None or buyer_mail == "":
return
customer_instance = Customer.objects.filter(
contact__first_name_last_name=buyer_name,
contact__email=buyer_mail).first()
if customer_instance is None:
contact = Contact(email=buyer_mail,
first_name_last_name=buyer_name)
contact.save()
customer_instance = Customer(contact=contact)
customer_instance.save()
else:
customer_instance.email = buyer_mail
customer_instance.first_name_last_name = buyer_name
customer_instance.save()
if mission_instance.customer is None:
mission_instance.customer = customer_instance
return customer_instance
def create_customer(
user_id: int,
shop_id: int,
consume_amount: float = 0,
consume_count: int = 0,
point: float = 0,
remark: str = "",
):
"""
创建客户
:param user_id:
:param shop_id:
:param consume_amount:
:param consume_count:
:param point:
:param remark:
:return:
"""
customer = Customer(
shop_id=shop_id,
user_id=user_id,
consume_amount=consume_amount,
consume_count=consume_count,
point=point,
remark=remark,
)
customer.save()
return customer
def create(self, validated_data):
customer = Customer(
email=validated_data['email'],
nickname=validated_data['nickname'],
shipping_address=validated_data['shipping_address'],
)
customer.set_password(validated_data['password'])
customer.save()
return customer
def webhook(request):
'''
Webhook view for outlook, this is called when new notification is recieved from outlook
'''
content = ''
if "validationToken" in request.GET:
content = request.GET.get("validationToken")
else:
jsondata = request.body.decode("utf-8")
notificaiton = json.loads(jsondata)
if "value" in notificaiton and len(notificaiton["value"]) > 0:
if "resourceData" in notificaiton["value"][0]:
message_id = notificaiton["value"][0]["resourceData"]["id"]
# Getting the cache
if "subscriptionId" in notificaiton["value"][0]:
subscription_id = notificaiton["value"][0][
"subscriptionId"]
#result = _get_token_from_cache_with_subscription_id(request)
cache, outlook_cache = _get_outlook_cache_for_subscription_id(
subscription_id)
if cache and outlook_cache:
result = _get_token_from_cache(cache,
outlook_cache.user_id)
if "error" in result:
print("ERROR in Webhook")
current_token = result["access_token"]
mail = outlook_requests.fetch_message_by_message_id(
message_id, current_token)
if not "error" in mail:
customer_details = scrapper.scrap_customer_info_from_form(
mail)
# try:
creator_id = outlook_cache.user_id
creator = User.objects.filter(id=creator_id)
if (len(customer_details.keys())):
if (len(creator)):
customer_details["creator"] = creator[0]
new_customer = Customer(**customer_details)
new_customer.save()
requirement = Requirement(
customer=new_customer, status="CREATED")
requirement.save()
credit_card = CreditCard(customer=new_customer)
credit_card.save()
outlook_cache.new_message = True
outlook_cache.save()
# except:
# pass
else:
print(mail["error"])
return HttpResponse(content=content, content_type="text/plain", status=200)
def post(self, request, format=None):
if not request.data or 'token' not in request.data or 'email' not in request.data:
return Response('Credentials not provided', status=status.HTTP_400_BAD_REQUEST)
raw_token = request.data['token']
email = request.data['email']
"""
Steps:
1. Verify the token and user
2. Create new token manually and pass back
"""
token_parts = raw_token.split('.')
if len(token_parts) != 3:
return Response('Invalid token', status=status.HTTP_400_BAD_REQUEST)
encoded_header = token_parts[0]
encoded_payload = token_parts[1]
signature = token_parts[2]
decoded_header = json.loads(base64_decode(encoded_header))
decoded_payload = json.loads(base64_decode(encoded_payload))
validate_outlook_token_header(decoded_header)
validate_outlook_token_lifetime(decoded_payload)
validate_outlook_token_audience(decoded_payload)
validate_outlook_token_version(decoded_payload)
unique_identifier = vaildate_outlook_token_signature_and_get_unique_identifier(raw_token, decoded_payload)
"""
Once the unique is obtained. Create User and Outlook User instances
"""
try:
user = User.objects.get(email=email)
outlook_user = OutlookUser.objects.get(unique_identifier=unique_identifier)
customer = user.customer_profile
except User.DoesNotExist:
user = User.objects.create_user(email)
# Save user's name
first_name = request.data.get('first_name', '')
last_name = request.data.get('last_name', '')
user.first_name = first_name
user.last_name = last_name
user.save()
outlook_user = OutlookUser(unique_identifier=unique_identifier, user=user)
outlook_user.save()
customer = Customer(user=user)
customer.save()
except OutlookUser.DoesNotExist:
return Response('Invalid Outlook credentials', status=status.HTTP_403_FORBIDDEN)
except Exception as e:
return Response(e, status=status.HTTP_403_FORBIDDEN)
jwt_token = get_user_jwt_token(user)
return Response({'token': jwt_token, 'id': customer.id}, status.HTTP_200_OK)
def save_new_customer(self, billing_form, delivery_form):
contact = Contact()
billing_address = billing_form.save()
delivery_address = delivery_form.save()
contact.billing_address = billing_address
contact.delivery_address = delivery_address
contact.save()
customer = Customer()
customer.contact = contact
customer.save()
def customer_create(request):
params = json.loads(request.body.decode("utf-8"))
data = {}
blacklist = Blacklist.objects.all()
for man in blacklist:
nameRatio = fuzz.partial_ratio(man.name, params['name'])
nationRatio = fuzz.partial_ratio(man.nationality, params['nation'])
addrRatio = fuzz.partial_ratio(man.address, params['address'])
print(nameRatio, addrRatio, nationRatio)
if (nameRatio > 70 or addrRatio > 80
or (nameRatio + nationRatio) > 170):
log = AlertLog()
log.name = params['name']
log.operate = '開戶'
log.reason = '疑似為高風險或黑名單人物'
log.save()
return common_response(data, message='黑名單人物')
try:
with transaction.atomic():
distrcit = District.objects.get(id=params['district']['id'])
customer = Customer()
customer.name = params['name']
customer.roc_id = params['roc_id']
customer.gender = params['gender']
customer.birthday = params['birthday']
customer.cell_phone = params['cell_phone']
customer.address = params['address']
customer.district = distrcit
customer.password = get_sha256_value(params['cell_phone'])
customer.email = params['email']
customer.save()
data['id'] = customer.id
# 產生帳戶號碼
code = generate_16_digits_code()
exist_codes = [account.code for account in Account.objects.all()]
while code in exist_codes:
code = generate_16_digits_code()
# 新增帳戶
account = Account()
account.code = code
account.customer = Customer.objects.get(id=customer.id)
# 預設第1筆(新台幣)
currency_list = Currency.objects.filter(id=1)
if len(currency_list) != 0:
account.currency = currency_list[0]
account.save()
return common_response(data)
except Exception as e:
return common_response(data, message=str(e))
def post(self, request, format = None):
serializer = CustomerSerializer(data = request.data)
if serializer.is_valid():
user = User(first_name = serializer.data['first_name'], \
last_name = serializer.data['last_name'], \
username = serializer.data['username'], \
email = serializer.data['email'])
user.save()
customer = Customer(user = user, city = serializer.data['city'])
customer.save()
return Response(serializer.data, status = status.HTTP_201_CREATED)
return Response(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
def create(self, validated_data):
customer = Customer(
name=validated_data['name'],
mobile_number=validated_data['mobile_number'],
email=validated_data['email'],
car_company=validated_data['car_company'],
car_fuel=validated_data['car_fuel'],
car_year=validated_data['car_year']
)
customer.save()
return customer
def register(request):
name = request.POST.get('name').strip()
pwd = request.POST.get('pwd').strip()
pwd2 = request.POST.get('pwd2').strip()
type = request.POST.get('type').strip()
code = request.POST.get('code').strip()
print(name, pwd, pwd2, type, code)
code_real = request.session['code']
if code_real.lower() != code:
return JsonResponse({'code_error': 1})
pwd_new = pwd_by_hmac(pwd)
if type == '管理员':
try:
Admin.objects.get(admin_Name=name)
# 用户名已存在
return JsonResponse({'name': 1})
except Exception as e:
try:
user = Admin(admin_Name=name, admin_pwd=pwd_new)
user.save()
result = {'Success': True}
return JsonResponse(result)
except Exception as e:
print(e)
return JsonResponse({'Failed': True})
elif type == '摄影师':
try:
Cameraman.object.get(ca_name=name)
return JsonResponse({'name': 1})
except Exception as e:
try:
user = Cameraman(ca_name=name, ca_pwd=pwd_new)
user.save()
result = {'Success': True}
return JsonResponse(result)
except Exception as e:
print(e)
return JsonResponse({'Failed': True})
else:
try:
Customer.objects.get(cs_name=name)
return JsonResponse({'name': 1})
except Exception as e:
print(e)
try:
user = Customer(cs_name=name, cs_pwd=pwd_new)
user.save()
result = {'Success': True}
return JsonResponse(result)
except Exception as e:
print(e)
return JsonResponse({'Failed': True})
def create_customer(conn, crm_customer_id):
conn.request('GET',
'/dev/api/contacts/%s' % crm_customer_id,
headers=REQUEST_HEADER)
resp = conn.getresponse()
assert resp.status == 200
bbody = resp.read()
doc = json.loads(bbody.decode())
customer = Customer(profile={'agilecrm': crm_customer_id})
update_customer(customer, doc)
return customer
def add_customer_details(request):
if request.method == 'POST':
customer = Customer()
name = request.POST.get('name')
mail = request.POST.get('email')
phone_number = request.POST.get('contact')
address = request.POST.get('comment')
customer.name = name
customer.mail = mail
customer.phone_number = phone_number
customer.address = address
customer.save()
return render(request, 'add_customer_details.html', {})
def create(self, validated_data):
username = validated_data['username']
email = validated_data['email']
password = validated_data['password']
user_obj = User(
username=username,
email=email,
)
customer_obj = Customer(username=username)
customer_obj.save()
service_obj = Service(username=username)
service_obj.save()
user_obj.set_password(password)
user_obj.save()
return validated_data
def loginView(request):
if request.method == 'POST': # If the form has been submitted...
obj = Customer()
email = request.POST.get('email')
password = request.POST.get('password')
if len(email)== 0 or len(password)== 0:
row = ""
else:
obj.set_email(email)
obj.set_password(password)
row = obj.getUserAccount()
print (row)
if len(row) >0:
user = obj.authenticateCustomer()
request.session["user"] = email
request.session["password"] = password
request.session["auth"] = True
request.session["account"] = int(user[0])
request.session["customer"] = int(user[1])
cus_ID = int(user[1])
act_ID = int(user[0])
obj.set_accountID(act_ID)
obj.set_customerID(cus_ID)
allergies = loadAllergies(request)
preferences = loadPreferences(request)
user_info = obj.getUserAccount()
address_info = obj.getUserAddress()
state =[ sub['state'] for sub in address_info ]
name = user[2]
request.session["name"] = name
print(request.session["name"])
context = get_userinfo(request)
lstOrder = lastOrder(request)
hist = []
if len(lstOrder) != 0:
hist = loadOrderHistory(request)
context.update({'lastOrder':lstOrder,'history':hist,'check_list': allergies,'p_check_list': preferences ,'users': user_info,'addresses': address_info ,'state':state})
return render(request,'profile.html',context)
else:
response = "Invalid Credentials, please try again!"
obj.set_userAuthenticated(False)
context = {'response': response, 'alert_flag': True}
return render(request,'login.html',context)
context = {'response': ""}
return render(request,'login.html',context)
def mutate(self, info, user_data):
user = get_user_model()(username=user_data.username,
email=user_data.email,
first_name=user_data.first_name,
last_name=user_data.last_name)
user.set_password(user_data.password)
user.save()
customer = Customer(user=user, phone=user_data.phone)
customer.save()
address = Address(customer=customer,
street=user_data.street,
city=user_data.city,
country=user_data.country,
zip_code=user_data.zip_code)
address.save()
return CreateUser(user=customer)
def add_customer_info():
'''添加客户基本信息'''
user_id = g.user_id
# 获取请求的json数据,返回字典
req_dict = request.get_json()
name = req_dict.get("name")
contacts = req_dict.get("contacts")
phone = req_dict.get("phone")
# 效验参数
if not all([name, contacts, phone]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
try:
customer = Customer.query.filter(Customer.name == name,
Customer.isdelete == True).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据库异常")
if customer:
customer.contacts = contacts
customer.tel = phone
customer.isdelete = False
else:
customer = Customer(name=name,
contacts=contacts,
tel=phone,
user=user_id)
try:
db.session.add(customer)
db.session.commit()
except IntegrityError as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DATAEXIST, errmsg="该客户已存在")
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询数据库异常")
data = customer.to_base_dict()
return jsonify(errno=RET.OK, errsmg="添加成功", data=data)
def createCustomer(request):
fName = request.POST.get('customerFirstName')
lastName = request.POST.get('customerLastName')
Email = request.POST.get('customerEmail')
Password = request.POST.get('customerPassword')
query_set = list(Customer.objects.all().filter(email=Email))
# if returned query set empty -> user not in DB so create the user and add to DB
if not query_set:
customer_obj = Customer(firstName=fName,
lastName=lastName,
email=Email,
password=Password)
customer_obj.save()
# return control to login-page for new user to login using his/her info
return render(request, 'customer/login.html')
else:
return render(request, 'customer/sign_up.html')
def st_wh_customer_creation(request):
endpoint_secret = settings.STRIPE_WHS_PAYMENT_SUCCESS
payload = request.body
sig_header = request.META['HTTP_STRIPE_SIGNATURE']
event = None
try:
event = stripe.Webhook.construct_event(payload, sig_header,
endpoint_secret)
except ValueError as e:
# Invalid payload
return HttpResponse(status=400)
except stripe.error.SignatureVerificationError as e:
# Invalid signature
return HttpResponse(status=400)
# Handle the checkout.session.completed event
if event['type'] == 'customer.created':
st_customer = event['data']['object']
# Retrieve Orders
orders = CustomerOrder.objects.filter(
st_customer_id=st_customer.get("id"))
# Retrieve the customer
customer = Customer.objects.filter(
email=st_customer.get("email"),
stripe_customer_id=st_customer.get("id")).first()
if not customer:
for order in orders:
tg_customer = Customer(
email=st_customer.get("email"),
stripe_customer_id=st_customer.get("id"),
)
tg_customer.save()
order.customer = tg_customer
order.save()
return HttpResponse(status=200)
else:
return HttpResponse(status=400)
def createCustomer(request):
try:
form = ApiHelper.getData(request)
# username = form['username'] if 'username' in form else ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(5))
password = form['password'] if 'password' in form else '123'
first_name = form['first_name']
last_name = form['last_name']
female = False if form['female'] == 'false' else True
phone_number = form['phone_number']
username = phone_number #form['username']
date_of_birth = dt_class.strptime(
form['date_of_birth'],
'%Y-%m-%d') if 'date_of_birth' in form else None
address = form['address'] if 'address' in form else None
account = createAccount(username, None, password)
if not account:
return JsonResponse({
'code': 100,
'data': 'Tên tài khoản đã tồn tại!'
})
user_created = User.objects.filter(username="******").first()
customer = Customer(
first_name=first_name,
last_name=last_name,
female=female,
phone_number=phone_number,
date_of_birth=date_of_birth,
address=address,
account=account,
created_date=timezone.now(),
created_by=user_created,
)
customer.save()
return ApiHelper.Response_ok("Success")
except Exception as e:
print(e)
# print(traceback.format_exc())
return ApiHelper.Response_error()
def addCustomer(request):
customer_id = request.POST.get('customer_id')
customer_name = request.POST.get('customer_name')
customer_mobile = request.POST.get('customer_mobile')
customer_email = request.POST.get('customer_email')
customer_username = request.POST.get('customer_username')
customer_password = request.POST.get('customer_password')
customer_address = request.POST.get('customer_address')
customer_pwd_hash = make_password(customer_password)
add_customer = Customer(customer_id=customer_id,
customer_name=customer_name,
customer_mobile=customer_mobile,
customer_email=customer_email,
customer_username=customer_username,
customer_password=customer_pwd_hash,
customer_address=customer_address)
add_customer.save()
return showCustomer(request)
def post(self, request, format=None):
serializer = CustomerSerializer(data=request.data)
if serializer.is_valid():
logger.info('Creating user %s started' %
serializer.data['username'])
user = User(first_name = serializer.data['first_name'], \
last_name = serializer.data['last_name'], \
username = serializer.data['username'], \
email = serializer.data['email'])
user.set_password(serializer.data['password'])
user.save()
customer = Customer(user=user,
city=serializer.data['city'],
phone=serializer.data['phone'])
customer.save()
create_confirmations(customer)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def customer_create(request):
if request.method == 'POST':
data = JSONParser().parse(request)
email = data['email']
firstname = data['firstname']
lastname = data['lastname']
password = data['password']
customer = Customer(email=email,
first_name=firstname,
last_name=lastname,
password=hashlib.sha256(password).hexdigest(),
username=email)
customer.save()
serializerCustomer = CustomerSerializer(customer)
return JsonResponse(serializerCustomer.data, status=201)
def post(self, request, **kwargs):
order = Order()
order.product_name = request.session['productTitle']
order.product_url = request.session['url']
order.fee = float(request.session['productCost'])*0.15
order.status = "Finding a traveller"
order.creation_time = timezone.now()
order.save()
user = User.objects.get(pk=request.user.pk)
customer = Customer()
customer.order = order
customer.user = user
customer.city = request.session['city']
customer.save()
messages.info(request, "Payment successful! We'll notify you when we find a traveller for you!")
return redirect('HomePage')
