def create_user_after_request(self, *args, **kwargs):
try:
new_user = User.objects.create(
first_name=self.name,
mobile_phone=clear_contact_phone(self.mobile_phone_number),
turnes_person_id=self.turnes_person_id)
except Exception:
return False
new_user_password = get_random_string(length=8)
new_user.set_password(new_user_password)
new_user.save()
print("new_user_password", new_user_password)
try:
m_sid = send_password(to=clear_contact_phone(
self.mobile_phone_number),
password=new_user_password)
except Exception:
new_user.delete()
return False
# m_sid = send_password(
# to="+380631280489",
# password=new_user_password
# )
if m_sid:
self.message_sid = m_sid
return True
def create_user_after_request(sender, instance, **kwargs):
if instance.turnes_person_id:
new_user = User.objects.create(
first_name=instance.name,
mobile_phone=clear_contact_phone(instance.mobile_phone_number),
turnes_person_id=instance.turnes_person_id
)
new_user_password = get_random_string(length=8)
new_user.set_password(new_user_password)
new_user.save()
# phonxis twilio account
# account_sid = "AC37cb13a1d11a145f195479dfc148253b"
# auth_token = "8893689c10c3f0204f39c18d6dac4be3"
# twilio_phone = "+19132760090"
# main twilio account
# account_sid = "AC37cb13a1d11a145f195479dfc148253b"
# auth_token = "8893689c10c3f0204f39c18d6dac4be3"
# twilio_phone = "+19132760090"
client = Client(
settings.TWILIO_ACCOUNT_SID,
settings.TWILIO_AUTH_TOKEN
)
message = client.messages.create(
body="Ваш пароль на сайте exf.in.ua: {0}".format(new_user_password),
from_=settings.TWILIO_PHONE_NUMBER,
# to="+380631280489"
to="+{0}".format(clear_contact_phone(instance.mobile_phone_number))
)
def mobile_phone_number(value):
clean_phone = clear_contact_phone(value)
if not len(clean_phone) == 12:
raise ValidationError(
_(u"Введите правильный номер телефона")
)
def clean(self):
cleaned_data = super(RegisterNumberForm, self).clean()
phone = cleaned_data.get('phone')
valid_phone = clear_contact_phone(phone)
cleaned_data["phone"] = valid_phone
return cleaned_data
def make_user_password(user_obj):
new_user_password = get_random_string(length=8)
user_obj.set_password(new_user_password)
user_obj.save()
client = Client(settings.TWILIO_ACCOUNT_SID, settings.TWILIO_AUTH_TOKEN)
message = client.messages.create(
body="Ваш пароль на сайте expressfinance.com.ua: {0}".format(
new_user_password),
from_=settings.TWILIO_PHONE_NUMBER,
# to="+{0}".format("380950968326")
to="+{0}".format(clear_contact_phone(user_obj.mobile_phone)))
return new_user_password
def user_login(request, status_message=None):
if request.method == 'POST':
data = {
'mobile_phone':
clear_contact_phone(request.POST.get('mobile_phone')),
'password': request.POST.get('password')
}
form = LoginForm(data)
if form.is_valid():
mobile_phone = form.cleaned_data.get('mobile_phone')
password = form.cleaned_data.get('password')
user = authenticate(mobile_phone=mobile_phone, password=password)
if user is not None:
login(request, user)
if request.POST.get('remember_me') is not None:
request.session.set_expiry(0)
# checking if user changed password which received from SMS
if user.changed_default_password:
return HttpResponseRedirect(reverse('profile'))
# elif not user.ready_for_turnes:
# return HttpResponseRedirect(reverse('questionnaire'))
else:
# if no, redirects to change password page
return HttpResponseRedirect(reverse('set_password'))
else:
status_message = _("Неправильный номер или пароль")
return render(request, 'enter.html', {
'form': LoginForm(),
'status_message': status_message
})
else:
status_message = _("Неправильный номер или пароль")
return render(request, 'enter.html', {
'form': LoginForm(),
'status_message': status_message
})
elif request.method == 'GET':
if request.user.is_authenticated:
return HttpResponseRedirect(reverse('profile'))
form = LoginForm()
return render(request, 'enter.html', {
'form': form,
'status_message': status_message
})
def save(self, *args, **kwargs):
# search previous Requests with current contract_num
if RequestPersonalArea.objects.filter(
contract_num=self.contract_num).exists():
qs = RequestPersonalArea.objects.filter(
contract_num=self.contract_num)
self.has_account = qs[0].has_account
qs.delete()
# get Turnes ID for current contract_num
self.turnes_person_id = get_person_id(contract_num=self.contract_num,
phone=clear_contact_phone(
self.mobile_phone_number))
print("turnes_person_id", self.turnes_person_id)
if self.turnes_person_id and not self.has_account:
self.has_account = self.create_user_after_request()
super(RequestPersonalArea, self).save(*args, **kwargs)
def bankid_getdata(request):
"""
Function gets encoded data from BankID,
decode it and save into models
"""
access_token = request.session.get('access_token', None) # pop
refresh_token = request.session.get('refresh_token', None) # pop
BankIDLog.objects.create(type='BankIDGetData',
subtype="access_token",
message=access_token)
BankIDLog.objects.create(type='BankIDGetData',
subtype="refresh_token",
message=refresh_token)
if settings.DEBUG:
url = "https://bankid.privatbank.ua/ResourceService/checked/data"
else:
url = "https://biprocessing.org.ua/ResourceService/checked/data"
headers = {
"Content-Type":
"application/json",
"Authorization":
"Bearer {access_token}, Id {client_id}".format(
access_token=access_token, client_id=settings.BANKID_CLIENT_ID),
"Accept":
"application/json"
}
# Describe which data will be requested
data = {
"type":
"physical",
"fields": [
"firstName", "middleName", "lastName", "phone", "inn", "clId",
"clIdText", "birthDay", "email", "sex", "resident",
"dateModification"
],
"scans": [{
"type":
"passport",
"fields": ["link", "dateCreate", "extension", "dateModification"]
}, {
"type":
"zpassport",
"fields": ["link", "dateCreate", "extension", "dateModification"]
}, {
"type":
"inn",
"fields": ["link", "dateCreate", "extension", "dateModification"]
}, {
"type":
"personalPhoto",
"fields": ["link", "dateCreate", "extension", "dateModification"]
}],
"addresses": [{
"type":
"factual",
"fields": [
"country", "state", "area", "city", "street", "houseNo",
"flatNo", "dateModification"
]
}, {
"type":
"birth",
"fields": [
"country", "state", "area", "city", "street", "houseNo",
"flatNo", "dateModification"
]
}],
"documents": [{
"type":
"passport",
"fields": [
"series", "number", "issue", "dateIssue", "dateExpiration",
"issueCountryIso2", "dateModification"
]
}, {
"type":
"zpassport",
"fields": [
"series", "number", "issue", "dateIssue", "dateExpiration",
"issueCountryIso2", "dateModification"
]
}]
}
BankIDLog.objects.create(type='BankIDGetData',
subtype="request headers",
message=headers)
BankIDLog.objects.create(type='BankIDGetData',
subtype="request data",
message=json.dumps(data))
BankIDLog.objects.create(type='BankIDGetData',
subtype="request URL",
message=url)
r = requests.post(url=url, headers=headers, data=json.dumps(data))
BankIDLog.objects.create(type='BankIDGetData',
subtype="response",
message=r.json())
response_json = r.json()
if 'customer' in response_json.keys():
decrypted = decrypt_data(response_json)
else:
BankIDLog.objects.create(type='BankIDGetData',
subtype="error",
message="response not contain 'customer' key")
return HttpResponseRedirect(reverse_lazy('main'))
BankIDLog.objects.create(type='BankIDGetData',
subtype="decrypted",
message=decrypted)
# Check if user with this mobile_phone exists
user_exists = User.objects.filter(
mobile_phone=clear_contact_phone(decrypted["customer"]["phone"]))
if user_exists:
return HttpResponseRedirect(reverse_lazy('login'))
user = User.objects.create(mobile_phone=clear_contact_phone(
decrypted["customer"]["phone"]),
ready_for_turnes=False)
# Set user password, send SMS with it
password = make_user_password(user)
# Authenticate user
auth_user = authenticate(mobile_phone=user.mobile_phone, password=password)
# Save decrypted data to models:
# Customer, Document, Address, ScanDocument
# and copy this data to Questionnaire model
local_save(decrypted, user, headers)
if auth_user is not None:
login(request, auth_user)
return HttpResponseRedirect(reverse_lazy('questionnaire'))
return HttpResponseRedirect(reverse_lazy('main'))
def post(self, *args, **kwargs):
anketa_exists = Questionnaire.objects.filter(
user=self.request.user).exists()
if not anketa_exists:
if self.request.user.is_authenticated:
form = RegisterPersonalForm(data=self.request.POST)
if form.is_valid():
anketa = form.save(commit=False)
anketa.user = self.request.user
anketa.save()
return JsonResponse({
'result': 'ok',
'errors': None
},
safe=False)
else:
return JsonResponse(
{
'result': 'error',
'errors': form.errors
},
safe=False,
status=400)
else:
return JsonResponse({
'result': 'error',
'errors': form.errors
},
safe=False,
status=400)
else:
data_dict = self.request.POST.dict()
if 'switchResidence' in data_dict:
data_dict.pop('switchResidence')
if 'the-same' in data_dict:
data_dict.pop('the-same')
if 'step' in data_dict:
data_dict.pop('step')
if 'registration_county_switch' in data_dict:
data_dict.pop('registration_county_switch')
if 'residence_county_switch' in data_dict:
data_dict.pop('residence_county_switch')
if 'switchRegistration' in data_dict:
data_dict.pop('switchRegistration')
if 'birthday_date' in data_dict:
if data_dict['birthday_date']:
try:
data_dict['birthday_date'] = parse(
data_dict.get('birthday_date', '9999-01-01'))
except Exception:
data_dict['birthday_date'] = parse('9999-01-01')
if 'passport_date' in data_dict:
if data_dict['passport_date']:
try:
data_dict['passport_date'] = parse(
data_dict.get('passport_date', '9999-01-01'))
except Exception:
data_dict['passport_date'] = parse('9999-01-01')
if 'passport_outdate' in data_dict:
if data_dict['passport_outdate']:
try:
data_dict['passport_outdate'] = parse(
data_dict.get('passport_outdate', '9999-01-01'))
except Exception:
data_dict['passport_outdate'] = parse('9999-01-01')
else:
data_dict['passport_outdate'] = '9999-01-01'
if 'has_criminal_record' in data_dict:
if data_dict['has_criminal_record'] == 'off':
data_dict['has_criminal_record'] = False
else:
data_dict['has_criminal_record'] = True
instance_qs = Questionnaire.objects.filter(user=self.request.user)
f = RegisterPersonalForm(data=data_dict, instance=instance_qs[0])
if f.is_valid():
instance_qs.update(**data_dict)
else:
return JsonResponse({
'result': 'error',
'errors': f.errors
},
safe=False,
status=400)
if int(self.request.POST.get("step", 0)) == 5:
resp = check_blacklist(
itn=self.request.user.anketa.itn,
mobile_phone=clear_contact_phone(
self.request.user.anketa.mobile_phone),
passseria=self.request.user.anketa.passport_code[:2]
if self.request.user.anketa.passport_code else 'АА',
passnumber=self.request.user.anketa.passport_code[2:]
if self.request.user.anketa.passport_code else 000000,
)
if 'in_blacklist' in resp:
if resp['in_blacklist']:
user = User.objects.filter(id=self.request.user.id)[0]
anketa_qs = Questionnaire.objects.filter(
user=user).update(blacklist=True)
#
user.active = False
user.ready_for_turnes = False
user.save()
callback_fail = CallbackFailForm.get_solo()
redirect_url = reverse('fail',
kwargs={
'id_mess':
callback_fail.success.id,
'redirect_url':
'main'
})
return JsonResponse(
{
'result': 'ok',
'errors': None,
'url': redirect_url
},
safe=False)
else:
user = User.objects.filter(id=self.request.user.id)[0]
# user.ready_for_turnes = True
user.save()
save_anketa_turnes(anketa=self.request.user.anketa)
return JsonResponse(
{
'result': 'ok',
'errors': None,
'url': reverse('profile')
},
safe=False)
return JsonResponse({'result': 'ok', 'errors': None}, safe=False)
def request_callback(request):
if request.method == 'POST':
bid_id = request.POST.get("bid_id", None)
contact_phone = request.POST.get("contact_phone")
clean_phone = clear_contact_phone(contact_phone)
# linkprofit parameters
wm_id = ''
if 'wm_id' in request.session:
wm_id = request.session['wm_id']
del request.session['wm_id']
any_param = ''
if 'any_param' in request.session:
any_param = request.session['any_param']
del request.session['any_param']
# salesdoubler parameters
aff_sub = ''
if 'aff_sub' in request.session:
aff_sub = request.session['aff_sub']
del request.session['aff_sub']
aff_id = ''
if 'aff_id' in request.session:
aff_id = request.session['aff_id']
del request.session['aff_id']
# doaffilate parameters (w/o utm_source, utm_medium and utm_campaign)
v = ''
if 'v' in request.session:
v = request.session['v']
del request.session['v']
if bid_id:
# if Bid has been created in save_credit_request function
if Bid.objects.filter(id=int(bid_id)).exists():
bid = Bid.objects.get(id=int(bid_id))
bid.contact_phone = clean_phone
bid.name = request.POST.get("client_name")
bid.save()
process_bid(bid)
request.session['bid_id'] = bid.id
else:
new_bid = Bid.objects.create(
city=request.POST.get('city'),
name=request.POST.get("client_name"),
contact_phone=clean_phone,
wm_id=wm_id,
any_param=any_param,
aff_sub=aff_sub,
aff_id=aff_id,
v=v)
new_bid.save()
process_bid(new_bid)
request.session['bid_id'] = new_bid.id
else:
new_bid = Bid.objects.create(city=request.POST.get('city'),
name=request.POST.get("client_name"),
contact_phone=clean_phone,
wm_id=wm_id,
any_param=any_param,
aff_sub=aff_sub,
aff_id=aff_id,
v=v)
new_bid.save()
process_bid(new_bid)
request.session['bid_id'] = new_bid.id
# for NEXT COMMITS
# return sms(request, "+380950968326", reverse('callback_verify'))
callback_success = CallbackSuccessForm.get_solo()
url = reverse('success',
kwargs={
'id_mess': callback_success.success.id,
'redirect_url': 'main'
})
return HttpResponseRedirect(url)
return HttpResponseNotAllowed(['POST'])
