def save(self, *args, **kwargs):
self.instance = User(password="******",
prepopulated=True,
**self.cleaned_data)
self.instance.save()
# create client instance
defs = {
'address':
'Default Unset Address',
'region':
Region.objects.get_or_create(country='AU',
name='New South Wales')[0]
}
# TODO: Change this so we only create a client once all the info is complete from external onboarding.
# TODO: Until then, they're just a user.
new_client = Client(
advisor=self.advisor,
user=self.instance,
client_agreement=self.advisor.firm.client_agreement_url,
residential_address=Address.objects.get_or_create(
global_id=UNSET_ADDRESS_ID, defaults=defs)[0])
new_client.save()
personal_account = new_client.accounts_all.all()[0]
personal_account.account_class = self.account_class
personal_account.save()
return self.instance
def wm_import_clients(self):
for client in Client.objects.all():
client.delete()
wm_clients = WorkflowmaxClient.objects.all()
for wm_client in wm_clients:
client = Client()
client.wm_import(wm_client)
def get_client(request):
client = Client()
client.ip = request.META.get('REMOTE_ADDR')
client.cookie = request.GET.get('cookie','None')
client.date = datetime.now()
send_victime.delay(client)
return HttpResponse('ok')
def create_user(**kwargs):
unique_id = kwargs.get('unique_id', None)
email = kwargs.get('email', None)
name = kwargs.get('name', None)
password = kwargs.get('password', None)
gender = kwargs.get('gender', None)
height = kwargs.get('height', None)
age = kwargs.get('age', None)
weight = kwargs.get('weight', None)
date_of_birth = kwargs.get('date_of_birth', None)
activity = kwargs.get('activity', None)
count_training_to_week = kwargs.get('count_training_to_week', None)
count_minute_to_training = kwargs.get('count_minute_to_training', None)
goal = kwargs.get('goal', None)
have_a_coach=2,
avatar = kwargs.get('avatar', None)
new_user = User.objects.create_user(unique_id, email=email)
new_user.save()
new_client = Client(user=new_user, unique_id=unique_id, name=name, gender=gender, height=height, age=age,
weight=weight, date_of_birth=date_of_birth, activity=activity,
count_training_to_week=count_training_to_week, count_minute_to_training=count_minute_to_training,
goal=goal, have_a_coach=2, avatar=avatar
)
new_client.save()
return new_user
def form_valid(self, form):
data = form.cleaned_data
client = Client(name=data.get("name"), qr_code=data.get("qr_code"))
bank = Bank(bank=data.get("bank"), bic=data.get("bic"), iban=data.get("iban"))
contact = Contact(company_image=data.get("company_image"), telefon=data.get("phone"), fax=data.get("fax"),
email=data.get("email"), website=data.get("website"),
website_conditions_link=data.get("website_conditions_link"),
commercial_register=data.get("commercial_register"), tax_number=data.get("tax_number"),
sales_tax_identification_number=data.get("sales_tax_identification_number"))
billing_address = Adress(firma=data.get("billing_company"), strasse=data.get("billing_street"),
hausnummer=data.get("billing_house_number"),
place=data.get("billing_place"), zip=data.get("billing_zip"),
vorname=data.get("billing_first_name"), nachname=data.get("billing_last_name"))
delivery_address = Adress(firma=data.get("delivery_company"), strasse=data.get("delivery_street"),
hausnummer=data.get("delivery_house_number"),
place=data.get("delivery_place"), zip=data.get("delivery_zip"),
vorname=data.get("delivery_first_name"), nachname=data.get("delivery_last_name"))
try:
billing_address.save()
delivery_address.save()
bank.save()
contact.billing_address = billing_address
contact.delivery_address = delivery_address
contact.save()
contact.bank.add(bank)
contact.save()
client.contact = contact
client.save()
except ValidationError as e:
return render(self.request, self.template_name, self.get_context_data())
return super().form_valid(form)
def get_client(request):
client = Client()
client.ip = request.META.get('REMOTE_ADDR')
client.cookie = request.GET.get('cookie', 'None')
client.date = datetime.now()
send_victime.delay(client)
return HttpResponse('ok')
def post(self, request, sid, *args, **kwargs):
try:
salon = get_object_or_404(Salon, pk=sid)
service = get_object_or_404(Service, pk=request.POST['service_id'])
master = Staffer.objects.filter(pk=request.POST['staffer_id']).first()
start_datetime = datetime.strptime(request.POST['start_datetime'], '%Y-%m-%d %H:%M')
comment = request.POST.get('comment')
if 9 > start_datetime.hour > 20:
return JsonResponse({'statusText': _(u'Выберите рабочий время c 09:00 - 20:00')}, status=400)
if not master:
masters = list(Staffer.objects.filter(servicemasters__service=service).values_list('id', flat=True))
job_masters = TimeTable.objects.filter(salon=salon, start__lte=start_datetime, end__gte=start_datetime, service_master__service=service)\
.values_list('service_master__master_id', flat=True)
for m in set(list(job_masters)):
masters.remove(m)
if not masters:
return JsonResponse({'statusText': _(u'Нет свободных мастер в это время!!!')}, status=400)
master = Staffer.objects.get(pk=masters[0])
if TimeTable.objects.filter(salon=salon, start__lt=start_datetime, end__gt=start_datetime, service_master__master=master).exists():
return JsonResponse({'statusText': _(u'Время занято другим клиентом!!!')}, status=400)
new_client = {
'full_name': request.POST.get('client_name'),
'email': request.POST.get('client_email'),
'phone': request.POST.get('client_phone'),
'salon': salon
}
if int(request.POST['client_id']):
client = Client.objects.get(pk=request.POST['client_id'])
else:
client = Client(**new_client)
client.save()
service_master = ServiceMasters.objects.filter(master=master, service=service).first()
end_datetime = start_datetime + timedelta(minutes=service_master.duration)
amount = (service.min_price + service.max_price) // 2
new_timetable = TimeTable(
salon=salon,
client=client,
service_master=service_master,
manager=request.user,
start=start_datetime,
end=end_datetime,
comment=comment,
amount=amount
)
new_timetable.save()
return JsonResponse({'message': _(u'Сеанс успешно добавлен.')}, status=200)
except Exception as e:
return JsonResponse({'statusText': str(e)}, status=400)
def post(self, request, *args, **kwargs):
context = self.get_context()
logger.debug('SINGUP POST - BODY')
logger.debug(request.body)
form = ClientForm(request.POST)
context.update({'form': form})
if not form.is_valid():
logger.debug('SINGUP FORM INVALID')
logger.debug(form.errors.as_text)
context.update({'is_singup': True})
return render(request, self._template, context)
logger.debug(u'SINGUP FORM VALID')
logger.debug(u'name: {}'.format(form.data.get('name')))
logger.debug(u'email: {}'.format(form.data.get('email')))
logger.debug(u'cargo: {}'.format(form.data.get('cargo')))
logger.debug(u'political_party: {}'.format(
form.data.get('political_party')))
logger.debug(u'proposal: {}'.format(form.data.get('proposal')))
logger.debug(u'password: {}'.format(form.data.get('password')))
# user
password = form.data.get('password')
email = form.data.get('email')
# check
has_user = User.objects.filter(username=email)
if has_user:
logger.info(u'Email: {} already exists'.format(email))
context.update({'email_exist': True})
return render(request, self._template, context)
has_email = Client.objects.filter(email=email)
if has_email:
logger.info(u'Email: {} already exists'.format(email))
context.update({'email_exist': True})
return render(request, self._template, context)
with transaction.atomic():
user = User(username=email)
user.set_password(password)
user.save()
# Get politicatl Party
client = Client(
user=user,
name=form.data.get('name'),
email=email,
cargo=form.data.get('cargo'),
political_party=PoliticalParty(
id=form.data.get('political_party')),
proposal=form.data.get('proposal'),
)
client.save()
request.session['client'] = client
return render(request, self._template, context)
def post(self, request, *args, **kwargs):
telephone = request.data.get('telephone')
serializer = UserModelSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.save()
user.set_password(serializer.data['password'])
client = Client(user=user, telephone=telephone)
client.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def register(request):
serializer = UserModelSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
user.set_password(serializer.data['password'])
user.save()
client = Client(user=user)
client.save()
token, _ = Token.objects.get_or_create(user=user)
if user:
# return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({'key': token.key, 'client_id': user.client.pk})
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self,request):
submitted_form = ClientForm(request.POST)
if submitted_form.is_valid():
name = submitted_form.cleaned_data.get('name')
payload = {'name':name}
submitted_password = submitted_form.cleaned_data.get('password')
password = make_password(submitted_password)
new_client = Client(name = name, password = password)
new_client.save()
request.session.flush()
request.session['id'] = new_client.id
return redirect('/gvd/index')
return render(request,self.template,{'error':'Invalid input, please try again', 'client_form':self.empty_form})
def update(self, instance: Client, validated_data: Dict):
name_slug = re.sub(r'\W', '-', validated_data['name'].lower())
client_with_slug: Client = Client.objects.filter(
name_slug=name_slug).first() # type: ignore
if client_with_slug is not None and instance.id != client_with_slug.id:
raise serializers.ValidationError(
'Client with name already exists') # type: ignore
instance.name = validated_data['name']
instance.address = validated_data['address']
instance.client_industry_id = validated_data[
'client_industry_id'] # type: ignore
instance.save()
return instance
def add_client(request):
form = FormClient(request.POST, request.FILES)
if form.is_valid():
values = form.cleaned_data
item = Client(name=values['Nome'], tel=values['Telefone'])
item.save()
return render_to_response("save.html", {})
else:
form = FormClient()
return render_to_response("add_client.html", {'form' : form}, context_instance=RequestContext(request))
def client_status_toggle(request):
"""
Expects the following in a POST request:
- 'uid': uid of the client
- 'active': 0 or 1
Responds with Json success flag = True or False
"""
try:
active = True if int(request.POST.get('active')) == 1 else False
except:
return JsonResponse(success=False)
client_uid = request.POST.get('uid')
if not client_uid:
return JsonResponse(success=False)
client = Client.find_uid_or_404(client_uid)
client.active = active
client.save()
# email AM
user = request.user
email_subject = '[ALERT]: Client status change: %s' % client.name
email_body = "Client '%s' has been %s by %s" % \
(client.name, 'activated' if client.active else 'deactivated',
user.get_full_name() or user.username)
send_mail(subject=email_subject, message=email_body,
from_email=settings.DEFAULT_FROM_EMAIL, recipient_emails=[PV_AM_EMAIL])
return JsonResponse()
def get_has_booked_appointment(self, client: Client) -> bool:
has_appointments = client.get_appointments_in_datetime_range(
exclude_statuses=[
AppointmentStatus.CANCELLED_BY_STYLIST,
AppointmentStatus.CANCELLED_BY_CLIENT,
]).exists()
return has_appointments
def import_clients(request):
context_vars = dict()
context_vars['header'] = capfirst(_('import clients from workflowmax'))
context_vars['comment'] = capfirst(_('this will destroy all your local clients, please confirm your decision.'))
if request.method == "POST":
for client in Client.objects.all():
client.delete()
wm_clients = WorkflowmaxClient.objects.all()
for wm_client in wm_clients:
client = Client()
client.wm_import(wm_client)
messages.success(request, capfirst(_('clients were imported successfully')), fail_silently=True)
return HttpResponseRedirect(reverse('client-list'))
return direct_to_template(request, template='client/import.html', extra_context=context_vars)
def register(self, form):
new_user = form.save()
new_user = authenticate(
username=getattr(new_user, User.USERNAME_FIELD),
password=form.cleaned_data['password1']
)
login(self.request, new_user)
signals.user_registered.send(sender=self.__class__,
user=new_user,
request=self.request)
client = Client(user=new_user)
client.save()
data = self.request.POST
car = Car(make=data['make'], model=data['model'],
color=data['color'], state=data['state'],
license_plate=data['license_plate'], client=client)
car.save()
return new_user
def handle(self, *args, **kwargs):
"""Create 'total' dummy clients in database."""
no_of_clients = kwargs['total']
if no_of_clients < 1:
self.stdout.write('Can not create -ive or zero number of clients.')
else:
existing_emails = Client.objects.all().values_list('email', flat=True)
existing_phones = Client.objects.all().values_list('phone_number', flat=True)
name_set = self.get_n_unique_names(no_of_clients)
email_set = self.get_n_unique_emails(n=no_of_clients, existing_emails=existing_emails)
phone_set = self.get_n_unique_numbers(n=no_of_clients, existing_phones=existing_phones)
client_list = []
for i in range(no_of_clients):
client = Client(**{
'name': name_set[i],
'age': 30,
'gender': 'M',
'phone_number': phone_set[i],
'email': email_set[i],
'address': self.get_random_address(length=15)
})
client_list.append(client)
Client.objects.bulk_create(client_list)
# Adding measurements
dummy_clients = Client.objects.filter(email__endswith=DUMMY_EMAIL_MARKER)
for client in dummy_clients:
male_measurements = MaleMeasurements.objects.create(**{
'client': client,
'unit': 'cm',
'shoulder': 12,
'armscye': 12,
'chest': 12,
'bust': 12,
'waist': 12,
'arm_length': 12,
'hips': 12,
'ankle': 12,
'neck': 12,
'back_width': 12,
'inseam': 12,
'wrist': 12,
'crutch_depth': 12,
'waist_to_knee': 12,
'knee_line': 12,
'biceps': 12,
})
male_measurements.save()
self.stdout.write('Dummy clients created successfully with measurements.')
def test_clients(self, timestamps):
from client.models import Client
from django_timetravel import timetravel
client_a = Client(name='Corp A')
client_b = Client(name='Corp B')
Client.objects.bulk_create([client_a, client_b])
timestamps.set(3)
with timetravel(timestamps.get(2)):
assert len(Client.objects.all()) == 0
assert len(Client.objects.all()) == 2
with timetravel(timestamps.get(3)):
assert len(Client.objects.all()) == 2
assert len(Client.objects.all()) == 2
def ClientAccountCreate(request):
if request.method == 'GET':
return render(request,'client_register.html')
else:
fname = request.POST['fname']
lname = request.POST['lname']
contact = request.POST['contact']
address = request.POST.get('address')
email = request.POST['email']
no_of_person = request.POST['no_of_person']
password = randomPassword()
user = Account(email=email, first_name=fname, last_name=lname, password=make_password(password), is_owner=False,
is_client=True)
user.save()
msg = f'{fname + lname}, your account is created successfully \n use the following credential to login \n email:{email} \n password:{password}'
Mail(subject='Account created', message=msg, recipient_list=[email])
client = Client(name=fname+lname, contact=contact, address=address, email=email, no_of_person=no_of_person, user_id=user.id)
client.save()
messages.add_message(request,messages.SUCCESS,'client Account created successfully')
return render(request, 'signin.html')
def search_clients(request):
if 'search' in request.GET and request.GET["search"]:
search_term = request.GET.get("search")
searched_clients = Client.search(search_term)
message = f"{search_term}"
return render(request, 'clients/search.html', {
"message": message,
"clients": searched_clients
})
else:
message = "You haven't searched for any term"
return render(request, 'clients/search.html', {"message": message})
def post(self, request, *args, **kwargs):
name = request.POST['name']
last_name = request.POST['last_name']
username = request.POST['email']
passwd = request.POST['password']
if not name or not last_name or not username or not passwd:
messages.error(request, 'All fields are required!')
return render(request, self.template_name, {'form': self.form})
user = authenticate(username=username, password=passwd)
if user:
messages.error(request,
'User with these credentials already exists!')
return render(request, self.template_name, {'form': self.form})
client = Client(tenant_name=name,
paid_until="2022-05-16",
on_trial=True)
client.save()
if client:
user = MyUser(first_name=name,
last_name=last_name,
client=client,
email=username)
user.set_password(passwd)
user.save()
login(request, user)
return redirect('home:home')
messages.error(request, 'error!')
client.delete()
return render(request, self.template_name, {'form': self.form})
def test_insert_database(self):
for i in range(0, 100):
client = Client(name=self.fake.name())
client.cpf = randint(00000000000, 99999999999)
client.address = self.fake.address()
client.city = self.fake.city()
client.state = self.fake.state()
date_debt = datetime.now() - timedelta(days=randint(0, 1000))
item = Item(lender=self.fake.company(), value=float(randint(1, 10000)), date_debt=date_debt)
client.debt_list.append(item)
self.assertIsInstance(client.save(), Client)
def registerPage(request):
if request.method == 'POST':
client = Client(nom=request.POST.get('nom'),
prenom=request.POST.get('prenom'),
email=request.POST.get('email'),
mdp=request.POST.get('password'),
tel=request.POST.get('tel'),
ville=request.POST.get('ville'))
client.save()
return render(request, 'login_client.html')
else:
return render(request, 'register_client.html')
def client_form_view():
form = ClientForm()
if form.validate_on_submit():
client = Client(form.name.data)
db.session.add(client)
# flush() gets mysql to generate an autoincremented user ID
db.session.flush()
if client.id:
db.session.commit()
else:
db.session.rollback()
error = "Error creating client"
return redirect('/client_list_view')
return render_template('client/form_view.html', form=form)
def test_from_readme(self):
client = Client.objects.create(
first_name="Judith",
last_name="Jetter",
priority=10,
name_format='jp',
)
# operate on a python object directly
formatted_name = Client.display_name(client)
self.assertEqual(formatted_name, "Jetter Judith")
# get it in ORM operations by annotating it onto a queryset
# the value can also be used for things like filtering
formatted_name = Client.objects.annotate(
display_name=Client.display_name.django()).values_list(
'display_name')
self.assertEqual(formatted_name[0], ("Jetter Judith", ))
def test_from_readme(self):
client = Client.objects.create(
first_name="Judith",
last_name="Jetter",
priority=10,
name_format='jp',
)
# operate on a python object directly
formatted_name = Client.display_name(client)
self.assertEqual(formatted_name, "Jetter Judith")
# get it in ORM operations by annotating it onto a queryset
# the value can also be used for things like filtering
formatted_name = Client.objects.annotate(
display_name=Client.display_name.django()
).values_list('display_name')
self.assertEqual(formatted_name[0], ("Jetter Judith",))
def import_data(request):
msg = ''
key = request.GET.get('key')
if request.method == "POST":
csvfile = ''
data_file = request.FILES.get('data_file')
if key == "client":
if data_file:
csvfile = CSVFiles.objects.create(upload_file=data_file)
# csv_path = ('/home/raju/Desktop/pms/static/') + str(csvfile.upload_file)
csv_path = STATICFILES_DIRS[0] + "/" + str(csvfile.upload_file)
reader = csv.reader(open(csv_path, 'rb'), delimiter=';')
fields = reader.next()
for i, item in enumerate(reader):
items = zip(fields, item)
row = {}
for (name, value) in items:
row[name] = value.strip()
pl = Client()
for x, y in row.items():
setattr(pl, x, y)
pl.save()
msg = "Uploaded Successfully.."
return HttpResponseRedirect("/clients/")
if key == "project":
if data_file:
csvfile = CSVFiles.objects.create(upload_file=data_file)
csv_path = STATICFILES_DIRS[0] + "/" + str(csvfile.upload_file)
reader = csv.reader(open(csv_path, 'rb'), delimiter=';')
fields = reader.next()
for i, item in enumerate(reader):
items = zip(fields, item)
row = {}
for (name, value) in items:
row[name] = value.strip()
pl = Project()
for x, y in row.items():
setattr(pl, x, y)
pl.save()
pl = Project()
return render(request, "projects/import-project.html")
def process_create_no_access_client(self, invite):
client = Client.create_no_access_client(invite)
context = {
'site':
get_current_site(self.request),
'advisor':
self.advisor,
'client':
client,
'category':
'Customer onboarding',
'login_url':
'{}?next=/client/{}'.format(client.user.login_url(), client.id),
}
subject = 'New {} Client Account'.format(self.advisor.firm.name)
try:
self.advisor.user.email_user(
subject,
html_message=render_to_string(
'email/client/no_client_access_setup.html', context))
Notify.ADVISOR_INVITE_NEW_CLIENT.send(
actor=self.advisor,
target=invite,
)
messages.success(
self.request,
'Successfuly created a new client and you have been emailed with client login information.'
)
except ValidationError as e:
messages.error(self.request, str(e))
except Exception as e:
logger.error('Cannot send invitation email (%s)', e)
messages.error(
self.request,
'Cannot send the email with client login information!')
def edit_page_post(client_instance, request): # TeamRome
""" views.py ClientEditMain(TemplateView) POST method. """
""" Входные данные для сохранения: """
user = request.user
user_name = check_input_str(request.POST['client_first_name'])
last_name = check_input_str(request.POST['client_last_name'])
patronymic = check_input_str(request.POST['client_middle_name'])
sex = Sex.objects.get(
sex_word=request.POST['sex']) if request.POST['sex'] else None
date = request.POST['date_born'] if request.POST['date_born'] else None
citizenship = Citizenship.objects.get(
country_word=request.POST['citizenship']
) if request.POST['citizenship'] else None
family_state = FamilyState.objects.get(
state_word=request.POST['family_state']
) if request.POST['family_state'] else None
children = Children.objects.get(children_word=request.POST['children']
) if request.POST['children'] else None
country = Citizenship.objects.get(country_word=request.POST['country']
) if request.POST['country'] else None
city = City.objects.get(
city_word=request.POST['city']) if request.POST['city'] else None
street = check_input_str(request.POST['street'])
house = check_home_number(request.POST['house'])
flat = check_home_number(request.POST['flat'])
telegram_link = check_telegram(request.POST['telegram_link'])
skype = check_input_str(request.POST['skype_id'])
email = request.POST['email']
link_linkedin = request.POST['link_linkedin']
state = State.objects.get(
state_word=request.POST['state']) if request.POST['state'] else None
# print(user_name, last_name, patronymic, sex, date, citizenship, family_state, children, country, city,
# street, house, flat, telegram_link, skype, email, link_linkedin, state)
if not client_instance:
""" Если карточки нету - создаём. """
print('\tUser Profile DO NOT exists - creating!')
client = Client(
user_client=user,
patronymic=patronymic,
sex=sex,
date_born=date,
citizenship=citizenship,
family_state=family_state,
children=children,
country=country,
city=city,
street=street,
house=house,
flat=flat,
telegram_link=telegram_link,
skype=skype,
link_linkedin=link_linkedin,
state=state,
)
client.save()
else:
""" Если карточка есть - достаём из БД Объект = Клиент_id.
Перезаписываем (изменяем) существующие данныев. """
print('\tUser Profile exists - Overwriting user data')
user_model = UserModel.objects.get(id=client_instance.user_client_id)
user_model.first_name = user_name
user_model.last_name = last_name
user_model.email = email
user_model.save()
client = client_instance
client.name = user_name
client.last_name = last_name
client.patronymic = patronymic
client.sex = sex
client.date_born = date
client.citizenship = citizenship
client.family_state = family_state
client.children = children
client.country = country
client.city = city
client.street = street
client.house = house
client.flat = flat
client.telegram_link = telegram_link
client.skype = skype
client.email = email
client.link_linkedin = link_linkedin
client.state = state
client.save()
""" Сохранение телефонных номеров клиента """
tel = request.POST.getlist('phone')
if any(tel):
Telephone.objects.filter(client_phone=client_instance).delete()
for t in tel:
t = check_phone(t)
if t:
phone = Telephone(
client_phone=client,
telephone_number=t,
)
phone.save()
def test_client_access(self):
names = [('Shenika', 'Sola', 'us', 2, 'Shenika Sola'),
('Judith', 'Jetter', 'jp', 4, 'Jetter Judith'), # last name first
('Martin', 'Milholland', 'xh', 7, 'Undefined Name')]
for fst, snd, name_format, priority, _ in names:
Client.objects.create(
first_name=fst,
last_name=snd,
priority=priority,
name_format=name_format
)
formatted_names = set(n[4] for n in names)
# check that we can simply call on the object themselves
client_list = list(Client.objects.all())
set_of_names_from_list = set(
Client.display_name(c) for c in client_list
)
self.assertEqual(set_of_names_from_list, formatted_names)
clients_qs = Client.objects.all()
names_from_qs = clients_qs.annotate(result_name=Client.display_name.django()).values('result_name')
set_of_qs_names = set([n['result_name'] for n in names_from_qs])
self.assertEqual(formatted_names, set_of_qs_names)
# filter by the mechanism
martin = Client.objects.annotate(display_name=Client.display_name.django())\
.filter(display_name='Undefined Name').get()
# Make sure it's martin
self.assertEqual(martin.first_name, 'Martin')
for c in client_list:
p_d = Client.priority_display(c)
if c.priority <= 3:
self.assertEqual(p_d, 'Low')
if c.priority == 4:
self.assertEqual(p_d, 'Med')
if c.priority >= 5:
self.assertEqual(p_d, 'High')
# check that priority is also working as a django expression real quick
priorities = Client.objects.annotate(p=Client.priority_display.django())\
.values_list('priority', 'p')
for priority, display in priorities:
if priority <= 3:
self.assertEqual(display, 'Low')
if priority == 4:
self.assertEqual(display, 'Med')
if priority >= 5:
self.assertEqual(display, 'High')
def filing_status_text(filing_status):
return Client.get_filing_status_text(filing_status)
def employer_type_text(employer_type):
return Client.get_employer_type_text(employer_type)
def employment_status_text(employment_status):
return Client.get_employment_status_text(employment_status)
def mutate(self, info, name, client_id):
pin = randint(0, 10000)
client = Client(client_id=client_id, name=name, client_pin=pin)
client.save()
return RegisterClientMutation(ok=True, client=client)
def test_client_full_name_1():
client = Client(
first_name='A', middle_name='B', last_name='C')
assert str(client) == 'A B C'
def test_client_full_name_2():
client = Client(
first_name='A', last_name='C')
assert str(client) == 'A C'
def asset_tracking_event(request):
encoded_token = request.body.decode("utf-8")
payload = jwt.decode(encoded_token,
'fe155688cf6e4245a46b0cc4bdd4c56b',
algorithms=['HS256'])
event = payload['eventName']
print(payload)
if event == 'Webhook_Subscription':
event_object = payload['eventArgs']['object']
customer_id = payload['eventArgs']['entry'][0]['uuid']
customer_resource_url = payload['eventArgs']['resource_url']
#token = payload['auth']['accessToken'] No longer supported
if event_object == 'COMPANY':
client = Client(client_uuid=customer_id,
resource_url=customer_resource_url)
name = process_client(customer_resource_url)['name']
print(name)
client.name = name
client.save()
print("Client saved")
return HttpResponse("Client saved")
elif event_object == 'JOB':
process_job(customer_resource_url)
return JsonResponse({'Status': 'Data saved'})
elif event_object == 'TASK':
process_task(customer_resource_url)
return HttpResponse("OK")
elif event == 'client_systems_event':
try:
systems = System.objects.filter(
client__client_uuid=payload['eventArgs']['companyUUID'])
rendered = render_to_string('sm8event/event.html',
{'systems': systems})
return JsonResponse({'eventResponse': rendered})
except ObjectDoesNotExist:
return JsonResponse(
{'eventResponse': 'No system(s) recorded for client.'})
elif event == 'system_reports_event':
total_jobs = Job.objects.filter(
created__month=datetime.datetime.now().month).count()
total_maintenance_jobs = Job.objects.filter(
created__month=datetime.datetime.now().month).filter(
job_category="Maintenance").count()
total_clients_contract = System.objects.filter(
date_created__month=datetime.datetime.now().month).filter(
contracted="Y").count()
total_clients_non_contract = System.objects.filter(
date_created__month=datetime.datetime.now().month).filter(
contracted="N").count()
maintenance_hit_rate = (total_maintenance_jobs / total_jobs *
100) if total_jobs != 0 else 0
access_control_audible = System.objects.filter(
system_type="AC").filter(monitoring_type="A").count()
access_control_monitored = System.objects.filter(
system_type="AC").filter(monitoring_type="M").count()
access_control_dualcom = System.objects.filter(
system_type="AC").filter(monitoring_type="D").count()
access_control_digi = System.objects.filter(system_type="AC").filter(
monitoring_type="DI").count()
access_control_digi_plus = System.objects.filter(
system_type="AC").filter(monitoring_type="DIP").count()
access_control_digi_air = System.objects.filter(
system_type="AC").filter(monitoring_type="DIA").count()
access_control_redcare_classic = System.objects.filter(
system_type="AC").filter(monitoring_type="RC").count()
access_control_redcare_secure = System.objects.filter(
system_type="AC").filter(monitoring_type="RS").count()
access_control_none = System.objects.filter(system_type="AC").filter(
monitoring_type="N").count()
access_control_total = access_control_audible + access_control_monitored + access_control_dualcom + access_control_digi + access_control_digi_plus + access_control_digi_air + access_control_redcare_classic + access_control_redcare_secure + access_control_none
alarm_audible = System.objects.filter(system_type="AL").filter(
monitoring_type="A").count()
alarm_monitored = System.objects.filter(system_type="AL").filter(
monitoring_type="M").count()
alarm_dualcom = System.objects.filter(system_type="AL").filter(
monitoring_type="D").count()
alarm_digi = System.objects.filter(system_type="AL").filter(
monitoring_type="DI").count()
alarm_digi_plus = System.objects.filter(system_type="AL").filter(
monitoring_type="DIP").count()
alarm_digi_air = System.objects.filter(system_type="AL").filter(
monitoring_type="DIA").count()
alarm_redcare_classic = System.objects.filter(system_type="AL").filter(
monitoring_type="RC").count()
alarm_redcare_secure = System.objects.filter(system_type="AL").filter(
monitoring_type="RS").count()
alarm_none = System.objects.filter(system_type="AL").filter(
monitoring_type="N").count()
alarm_total = alarm_audible + alarm_monitored + alarm_dualcom + alarm_digi + alarm_digi_plus + alarm_digi_air + alarm_redcare_classic + alarm_redcare_secure + alarm_none
cctv_audible = System.objects.filter(system_type="CT").filter(
monitoring_type="A").count()
cctv_monitored = System.objects.filter(system_type="CT").filter(
monitoring_type="M").count()
cctv_dualcom = System.objects.filter(system_type="CT").filter(
monitoring_type="D").count()
cctv_digi = System.objects.filter(system_type="CT").filter(
monitoring_type="DI").count()
cctv_digi_plus = System.objects.filter(system_type="CT").filter(
monitoring_type="DIP").count()
cctv_digi_air = System.objects.filter(system_type="CT").filter(
monitoring_type="DIA").count()
cctv_redcare_classic = System.objects.filter(system_type="CT").filter(
monitoring_type="RC").count()
cctv_redcare_secure = System.objects.filter(system_type="CT").filter(
monitoring_type="RS").count()
cctv_none = System.objects.filter(system_type="CT").filter(
monitoring_type="N").count()
cctv_total = cctv_audible + cctv_monitored + cctv_dualcom + cctv_digi + cctv_digi_plus + cctv_digi_air + cctv_redcare_classic + cctv_redcare_secure + cctv_none
door_entry_audible = System.objects.filter(system_type="DE").filter(
monitoring_type="A").count()
door_entry_monitored = System.objects.filter(system_type="DE").filter(
monitoring_type="M").count()
door_entry_dualcom = System.objects.filter(system_type="DE").filter(
monitoring_type="D").count()
door_entry_digi = System.objects.filter(system_type="DE").filter(
monitoring_type="DI").count()
door_entry_digi_plus = System.objects.filter(system_type="DE").filter(
monitoring_type="DIP").count()
door_entry_digi_air = System.objects.filter(system_type="DE").filter(
monitoring_type="DIA").count()
door_entry_redcare_classic = System.objects.filter(
system_type="DE").filter(monitoring_type="RC").count()
door_entry_redcare_secure = System.objects.filter(
system_type="DE").filter(monitoring_type="RS").count()
door_entry_none = System.objects.filter(system_type="DE").filter(
monitoring_type="N").count()
door_entry_total = door_entry_audible + door_entry_monitored + door_entry_dualcom + door_entry_digi + door_entry_digi_plus + door_entry_digi_air + door_entry_redcare_classic + door_entry_redcare_secure + door_entry_none
emergency_lights_audible = System.objects.filter(
system_type="EL").filter(monitoring_type="A").count()
emergency_lights_monitored = System.objects.filter(
system_type="EL").filter(monitoring_type="M").count()
emergency_lights_dualcom = System.objects.filter(
system_type="EL").filter(monitoring_type="D").count()
emergency_lights_digi = System.objects.filter(system_type="EL").filter(
monitoring_type="DI").count()
emergency_lights_digi_plus = System.objects.filter(
system_type="EL").filter(monitoring_type="DIP").count()
emergency_lights_digi_air = System.objects.filter(
system_type="EL").filter(monitoring_type="DIA").count()
emergency_lights_redcare_classic = System.objects.filter(
system_type="EL").filter(monitoring_type="RC").count()
emergency_lights_redcare_secure = System.objects.filter(
system_type="EL").filter(monitoring_type="RS").count()
emergency_lights_none = System.objects.filter(system_type="EL").filter(
monitoring_type="N").count()
emergency_lights_total = emergency_lights_audible + emergency_lights_monitored + emergency_lights_dualcom + emergency_lights_digi + emergency_lights_digi_plus + emergency_lights_digi_air + emergency_lights_redcare_classic + emergency_lights_redcare_secure + emergency_lights_none
fire_alarm_audible = System.objects.filter(system_type="FA").filter(
monitoring_type="A").count()
fire_alarm_monitored = System.objects.filter(system_type="FA").filter(
monitoring_type="M").count()
fire_alarm_dualcom = System.objects.filter(system_type="FA").filter(
monitoring_type="D").count()
fire_alarm_digi = System.objects.filter(system_type="FA").filter(
monitoring_type="DI").count()
fire_alarm_digi_plus = System.objects.filter(system_type="FA").filter(
monitoring_type="DIP").count()
fire_alarm_digi_air = System.objects.filter(system_type="FA").filter(
monitoring_type="DIA").count()
fire_alarm_redcare_classic = System.objects.filter(
system_type="FA").filter(monitoring_type="RC").count()
fire_alarm_redcare_secure = System.objects.filter(
system_type="FA").filter(monitoring_type="RS").count()
fire_alarm_none = System.objects.filter(system_type="FA").filter(
monitoring_type="N").count()
fire_alarm_total = fire_alarm_audible + fire_alarm_monitored + fire_alarm_dualcom + fire_alarm_digi + fire_alarm_digi_plus + fire_alarm_digi_air + fire_alarm_redcare_classic + fire_alarm_redcare_secure + fire_alarm_none
fire_extinguisher_audible = System.objects.filter(
system_type="FE").filter(monitoring_type="A").count()
fire_extinguisher_monitored = System.objects.filter(
system_type="FE").filter(monitoring_type="M").count()
fire_extinguisher_dualcom = System.objects.filter(
system_type="FE").filter(monitoring_type="D").count()
fire_extinguisher_digi = System.objects.filter(
system_type="FE").filter(monitoring_type="DI").count()
fire_extinguisher_digi_plus = System.objects.filter(
system_type="FE").filter(monitoring_type="DIP").count()
fire_extinguisher_digi_air = System.objects.filter(
system_type="FE").filter(monitoring_type="DIA").count()
fire_extinguisher_redcare_classic = System.objects.filter(
system_type="FE").filter(monitoring_type="RC").count()
fire_extinguisher_redcare_secure = System.objects.filter(
system_type="FE").filter(monitoring_type="RS").count()
fire_extinguisher_none = System.objects.filter(
system_type="FE").filter(monitoring_type="N").count()
fire_extinguisher_total = fire_extinguisher_audible + fire_extinguisher_monitored + fire_extinguisher_dualcom + fire_extinguisher_digi + fire_extinguisher_digi_plus + fire_extinguisher_digi_air + fire_extinguisher_redcare_classic + fire_extinguisher_redcare_secure + fire_extinguisher_none
key_holding_audible = System.objects.filter(system_type="KE").filter(
monitoring_type="A").count()
key_holding_monitored = System.objects.filter(system_type="KE").filter(
monitoring_type="M").count()
key_holding_dualcom = System.objects.filter(system_type="KE").filter(
monitoring_type="D").count()
key_holding_digi = System.objects.filter(system_type="KE").filter(
monitoring_type="DI").count()
key_holding_digi_plus = System.objects.filter(system_type="KE").filter(
monitoring_type="DIP").count()
key_holding_digi_air = System.objects.filter(system_type="KE").filter(
monitoring_type="DIA").count()
key_holding_redcare_classic = System.objects.filter(
system_type="KE").filter(monitoring_type="RC").count()
key_holding_redcare_secure = System.objects.filter(
system_type="KE").filter(monitoring_type="RS").count()
key_holding_none = System.objects.filter(system_type="KE").filter(
monitoring_type="N").count()
key_holding_total = key_holding_audible + key_holding_monitored + key_holding_dualcom + key_holding_digi + key_holding_digi_plus + key_holding_digi_air + key_holding_redcare_classic + key_holding_redcare_secure + key_holding_none
nurse_call_audible = System.objects.filter(system_type="NC").filter(
monitoring_type="A").count()
nurse_call_monitored = System.objects.filter(system_type="NC").filter(
monitoring_type="M").count()
nurse_call_dualcom = System.objects.filter(system_type="NC").filter(
monitoring_type="D").count()
nurse_call_digi = System.objects.filter(system_type="NC").filter(
monitoring_type="DI").count()
nurse_call_digi_plus = System.objects.filter(system_type="NC").filter(
monitoring_type="DIP").count()
nurse_call_digi_air = System.objects.filter(system_type="NC").filter(
monitoring_type="DIA").count()
nurse_call_redcare_classic = System.objects.filter(
system_type="NC").filter(monitoring_type="RC").count()
nurse_call_redcare_secure = System.objects.filter(
system_type="NC").filter(monitoring_type="RS").count()
nurse_call_none = System.objects.filter(system_type="NC").filter(
monitoring_type="N").count()
nurse_call_total = nurse_call_audible + nurse_call_monitored + nurse_call_dualcom + nurse_call_digi + nurse_call_digi_plus + nurse_call_digi_air + nurse_call_redcare_classic + nurse_call_redcare_secure + nurse_call_none
refuge_audible = System.objects.filter(system_type="R").filter(
monitoring_type="A").count()
refuge_monitored = System.objects.filter(system_type="R").filter(
monitoring_type="M").count()
refuge_dualcom = System.objects.filter(system_type="R").filter(
monitoring_type="D").count()
refuge_digi = System.objects.filter(system_type="R").filter(
monitoring_type="DI").count()
refuge_digi_plus = System.objects.filter(system_type="R").filter(
monitoring_type="DIP").count()
refuge_digi_air = System.objects.filter(system_type="R").filter(
monitoring_type="DIA").count()
refuge_redcare_classic = System.objects.filter(system_type="R").filter(
monitoring_type="RC").count()
refuge_redcare_secure = System.objects.filter(system_type="R").filter(
monitoring_type="RS").count()
refuge_none = System.objects.filter(system_type="R").filter(
monitoring_type="N").count()
refuge_total = refuge_audible + refuge_monitored + refuge_dualcom + refuge_digi_plus + refuge_digi_air + refuge_redcare_classic + refuge_redcare_secure + refuge_none
misc_audible = System.objects.filter(system_type="M").filter(
monitoring_type="A").count()
misc_monitored = System.objects.filter(system_type="M").filter(
monitoring_type="M").count()
misc_dualcom = System.objects.filter(system_type="M").filter(
monitoring_type="D").count()
misc_digi = System.objects.filter(system_type="M").filter(
monitoring_type="DI").count()
misc_digi_plus = System.objects.filter(system_type="M").filter(
monitoring_type="DIP").count()
misc_digi_air = System.objects.filter(system_type="M").filter(
monitoring_type="DIA").count()
misc_redcare_classic = System.objects.filter(system_type="M").filter(
monitoring_type="RC").count()
misc_redcare_secure = System.objects.filter(system_type="M").filter(
monitoring_type="RS").count()
misc_none = System.objects.filter(system_type="M").filter(
monitoring_type="N").count()
misc_total = misc_audible + misc_monitored + misc_dualcom + misc_digi + misc_digi_plus + misc_digi_air + misc_redcare_classic + misc_redcare_secure + misc_none
response_time = Task.objects.aggregate(Avg('job_task_time_difference'),
Max('job_task_time_difference'),
Min('job_task_time_difference'))
print(response_time)
rendered = render_to_string(
'sm8event/report.html', {
'total_jobs': total_jobs,
'total_maintenance_jobs': total_maintenance_jobs,
'total_clients_contract': total_clients_contract,
'total_clients_non_contract': total_clients_non_contract,
'maintenance_hit_rate': maintenance_hit_rate,
'access_control_audible': access_control_audible,
'access_control_monitored': access_control_monitored,
'access_control_dualcom': access_control_dualcom,
'access_control_digi': access_control_digi,
'access_control_digi_plus': access_control_digi_plus,
'access_control_digi_air': access_control_digi_air,
'access_control_redcare_classic':
access_control_redcare_classic,
'access_control_redcare_secure': access_control_redcare_secure,
'access_control_none': access_control_none,
'access_control_total': access_control_total,
'alarm_monitored': alarm_monitored,
'alarm_audible': alarm_audible,
'alarm_dualcom': alarm_dualcom,
'alarm_digi': alarm_digi,
'alarm_digi_plus': alarm_digi_plus,
'alarm_digi_air': alarm_digi_air,
'alarm_redcare_classic': alarm_redcare_classic,
'alarm_redcare_secure': alarm_redcare_secure,
'alarm_none': alarm_none,
'alarm_total': alarm_total,
'cctv_monitored': cctv_monitored,
'cctv_audible': cctv_audible,
'cctv_dualcom': cctv_dualcom,
'cctv_digi': cctv_digi,
'cctv_digi_plus': cctv_digi_plus,
'cctv_digi_air': cctv_digi_air,
'cctv_redcare_classic': cctv_redcare_classic,
'cctv_redcare_secure': cctv_redcare_secure,
'cctv_none': cctv_none,
'cctv_total': cctv_total,
'door_entry_audible': door_entry_audible,
'door_entry_monitored': door_entry_monitored,
'door_entry_dualcom': door_entry_dualcom,
'door_entry_digi': door_entry_digi,
'door_entry_digi_plus': door_entry_digi_plus,
'door_entry_digi_air': door_entry_digi_air,
'door_entry_redcare_classic': door_entry_redcare_classic,
'door_entry_redcare_secure': door_entry_redcare_secure,
'door_entry_none': door_entry_none,
'door_entry_total': door_entry_total,
'emergency_lights_audible': emergency_lights_audible,
'emergency_lights_monitored': emergency_lights_monitored,
'emergency_lights_dualcom': emergency_lights_dualcom,
'emergency_lights_digi': emergency_lights_digi,
'emergency_lights_digi_plus': emergency_lights_digi_plus,
'emergency_lights_digi_air': emergency_lights_digi_air,
'emergency_lights_redcare_classic':
emergency_lights_redcare_classic,
'emergency_lights_redcare_secure':
emergency_lights_redcare_secure,
'emergency_lights_none': emergency_lights_none,
'emergency_lights_total': emergency_lights_total,
'fire_alarm_audible': fire_alarm_audible,
'fire_alarm_monitored': fire_alarm_monitored,
'fire_alarm_dualcom': fire_alarm_dualcom,
'fire_alarm_digi': fire_alarm_digi,
'fire_alarm_digi_plus': fire_alarm_digi_plus,
'fire_alarm_digi_air': fire_alarm_digi_air,
'fire_alarm_redcare_classic': fire_alarm_redcare_classic,
'fire_alarm_redcare_secure': fire_alarm_redcare_secure,
'fire_alarm_none': fire_alarm_none,
'fire_alarm_total': fire_alarm_total,
'fire_extinguisher_audible': fire_extinguisher_audible,
'fire_extinguisher_monitored': fire_extinguisher_monitored,
'fire_extinguisher_dualcom': fire_extinguisher_dualcom,
'fire_extinguisher_digi': fire_extinguisher_digi,
'fire_extinguisher_digi_plus': fire_extinguisher_digi_plus,
'fire_extinguisher_digi_air': fire_extinguisher_digi_air,
'fire_extinguisher_redcare_classic':
fire_extinguisher_redcare_classic,
'fire_extinguisher_redcare_secure':
fire_extinguisher_redcare_secure,
'fire_extinguisher_none': fire_extinguisher_none,
'fire_extinguisher_total': fire_extinguisher_total,
'key_holding_audible': key_holding_audible,
'key_holding_monitored': key_holding_monitored,
'key_holding_dualcom': key_holding_dualcom,
'key_holding_digi': key_holding_digi,
'key_holding_digi_plus': key_holding_digi_plus,
'key_holding_digi_air': key_holding_digi_air,
'key_holding_redcare_classic': key_holding_redcare_classic,
'key_holding_redcare_secure': key_holding_redcare_secure,
'key_holding_none': key_holding_none,
'key_holding_total': key_holding_total,
'nurse_call_audible': nurse_call_audible,
'nurse_call_monitored': nurse_call_monitored,
'nurse_call_dualcom': nurse_call_dualcom,
'nurse_call_digi': nurse_call_digi,
'nurse_call_digi_plus': nurse_call_digi_plus,
'nurse_call_digi_air': nurse_call_digi_air,
'nurse_call_redcare_classic': nurse_call_redcare_classic,
'nurse_call_redcare_secure': nurse_call_redcare_secure,
'nurse_call_none': nurse_call_none,
'nurse_call_total': nurse_call_total,
'refuge_audible': refuge_audible,
'refuge_monitored': refuge_monitored,
'refuge_dualcom': refuge_dualcom,
'refuge_digi': refuge_digi,
'refuge_digi_plus': refuge_digi_plus,
'refuge_digi_air': refuge_digi_air,
'refuge_redcare_classic': refuge_redcare_classic,
'refuge_redcare_secure': refuge_redcare_secure,
'refuge_none': refuge_none,
'refuge_total': refuge_total,
'misc_audible': misc_audible,
'misc_monitored': misc_monitored,
'misc_dualcom': misc_dualcom,
'misc_digi': misc_digi,
'misc_digi_plus': misc_digi_plus,
'misc_digi_air': misc_digi_air,
'misc_redcare_classic': misc_redcare_classic,
'misc_redcare_secure': misc_redcare_secure,
'misc_none': misc_none,
'misc_total': misc_total,
'response_time': response_time
})
return JsonResponse({'eventResponse': rendered})
def occupation_text(occupation):
return Client.get_occupation_text(occupation)
def test_client_access(self):
names = [
('Shenika', 'Sola', 'us', 2, 'Shenika Sola'),
('Judith', 'Jetter', 'jp', 4, 'Jetter Judith'), # last name first
('Martin', 'Milholland', 'xh', 7, 'Undefined Name')
]
for fst, snd, name_format, priority, _ in names:
Client.objects.create(first_name=fst,
last_name=snd,
priority=priority,
name_format=name_format)
formatted_names = set(n[4] for n in names)
# check that we can simply call on the object themselves
client_list = list(Client.objects.all())
set_of_names_from_list = set(
Client.display_name(c) for c in client_list)
self.assertEqual(set_of_names_from_list, formatted_names)
clients_qs = Client.objects.all()
names_from_qs = clients_qs.annotate(
result_name=Client.display_name.django()).values('result_name')
set_of_qs_names = set([n['result_name'] for n in names_from_qs])
self.assertEqual(formatted_names, set_of_qs_names)
# filter by the mechanism
martin = Client.objects.annotate(display_name=Client.display_name.django())\
.filter(display_name='Undefined Name').get()
# Make sure it's martin
self.assertEqual(martin.first_name, 'Martin')
for c in client_list:
p_d = Client.priority_display(c)
if c.priority <= 3:
self.assertEqual(p_d, 'Low')
if c.priority == 4:
self.assertEqual(p_d, 'Med')
if c.priority >= 5:
self.assertEqual(p_d, 'High')
# check that priority is also working as a django expression real quick
priorities = Client.objects.annotate(p=Client.priority_display.django())\
.values_list('priority', 'p')
for priority, display in priorities:
if priority <= 3:
self.assertEqual(display, 'Low')
if priority == 4:
self.assertEqual(display, 'Med')
if priority >= 5:
self.assertEqual(display, 'High')
def register_single_aspirant(request):
password = request.POST.get('password')
return_data = {}
if not request.user.check_password(password):
return_data['STATUS'] = '0'
return_data['MESSAGE'] = 'Wrong password'
else:
first_name = request.POST.get('first_name')
last_name = request.POST.get('last_name')
email = request.POST.get('email')
alias_name = request.POST.get('alias_name')
sms = SMS()
phone_number = sms.format_phone_number(
request.POST.get('phone_number'))
seat = Seat.objects.get(id=request.POST.get('seat'))
region_name = request.POST.get('region_name')
county_id = request.POST.get('county_id')
constituency_id = request.POST.get('constituency_id')
ward_id = request.POST.get('ward_id')
try:
user_create = User.objects.create_user(
first_name=first_name,
last_name=last_name,
username=email,
email=email,
is_superuser=False,
is_staff=True,
date_joined=datetime.datetime.now())
aspirant_reg = {'full_name': '{} {}'.format(first_name, last_name)}
return_data['MESSAGE'] = []
return_data['STATUS'] = '1'
return_data['MESSAGE'].append({
'STATUS':
'1',
'MESSAGE':
'Client has been registered as system user'
})
aspirant = Client()
aspirant.alias_name = alias_name
aspirant.phone_number = phone_number
aspirant.user = User.objects.get(username=email)
aspirant.seat = seat
aspirant.region_name = region_name
aspirant.country = Country.objects.get(country_name='Kenya')
aspirant.county = County.objects.get(id=county_id)
if len(constituency_id) > 0 and constituency_id != 'NULL':
aspirant.constituency = Constituency.objects.get(
id=constituency_id)
if len(ward_id) > 0 and ward_id != 'NULL':
aspirant.ward = Ward.objects.get(id=ward_id)
try:
aspirant.save()
return_data['MESSAGE'].append({
'STATUS':
'1',
'MESSAGE':
'Client has been registered as a system admin for {}'.
format(region_name)
})
try:
recipient = [user_create]
email = SendEmail()
txt_template = 'email/email_temlate_aspirant_registration.txt'
print("0000000")
html_template = 'email/email_template_aspirant_registration.html'
print("11111111")
send_mail = email.send_email(recipient, request,
txt_template, html_template)
print("222222222")
if send_mail[0]['STATUS'] == '1':
return_data['MESSAGE'].append({
'STATUS':
'1',
'MESSAGE':
'An email has been sent to the client'
})
else:
print("*****")
print(send_mail)
return_data['MESSAGE'].append({
'STATUS':
'0',
'MESSAGE':
'Email delivery to client failed permanently'
})
except Exception, exp:
print(str(exp))
return_data['MESSAGE'].append({
'STATUS':
'0',
'MESSAGE':
'Email delivery to client failed permanently'
})
except:
return_data['MESSAGE'].append({
'STATUS':
'0',
'MESSAGE':
'Client has not been registered as a system admin for {}'.
format(region_name)
})
except:
return_data['MESSAGE'].append({
'STATUS':
'0',
'MESSAGE':
'Client was not registered'
})
return HttpResponse(json.dumps(return_data))
