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 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 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 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 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 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_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 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 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 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 approve_batch_aspirants_upload(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:
return_data['ASPIRANTS_REG'] = []
excel_file = ExcelFile(request.session['ASPIRANTS_FILE_URL'])
records = excel_file.get_records(True)
for record in records:
record = list(record)
aspirant_reg = {'full_name': '{} {}'.format(record[0], record[1])}
try:
user_create = User.objects.create_user(
first_name=record[0],
last_name=record[1],
username=record[4],
email=record[4],
is_superuser=False,
is_staff=True,
date_joined=datetime.datetime.now())
aspirant_reg['registered_as_user'] = '******'
aspirant = Client()
aspirant.alias_name = record[2]
aspirant.phone_number = SMS.format_phone_number(record[3])
aspirant.user = User.objects.get(username=record[4])
aspirant.seat = Seat.objects.get(
Q(seat_name__icontains=record[5])
| Q(short_code__icontains=record[5]))
aspirant.region_name = record[6]
aspirant.country = Country.objects.get(country_name='Kenya')
aspirant.county = County.objects.get(county_name=record[7])
aspirant.constituency = Constituency.objects.get(
constituency_name=record[8])
aspirant.ward = Ward.objects.get(ward_name=record[9])
try:
aspirant.save()
aspirant_reg['registered_as_aspirant'] = '1'
except:
aspirant_reg['registered_as_aspirant'] = '0'
except:
aspirant_reg['registered_as_user'] = '******'
return_data['ASPIRANTS_REG'].append(aspirant_reg)
return HttpResponse(json.dumps(return_data))
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 test_client_full_name_2():
client = Client(first_name="A", last_name="C")
assert str(client) == "A C"
def post(self, request, format=None):
access_token = request['body'].get('access_token')
client = Client(request['body'])
client.save()
fanpages = insert_page_by_client(access_token)
client.pages.set(fanpages)
def test_client_full_name_1():
client = Client(first_name="A", middle_name="B", last_name="C")
assert str(client) == "A B C"
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_full_name_1():
client = Client(
first_name='A', middle_name='B', last_name='C')
assert str(client) == 'A B C'
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_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 handle(self, *args, **options):
# Create domain
domain = Domain(name='pass.com')
domain.save()
# Create owner
agent = Agent.objects.create_user(email='*****@*****.**',
password='******')
agent.is_owner = True
agent.domain = domain
agent.save()
# Create salesteam
for i in range(1, 5):
agent = Agent.objects.create_user(email='salesman' + str(i) +
'@pass.com',
password='******')
agent.domain = domain
agent.save()
# Create clients
for _ in range(1, random.randrange(1, 24)):
client = Client(name=fake.company())
client.save()
# Create managers
for _ in range(1, random.randrange(12)):
Manager(client=client,
first_name=fake.first_name(),
last_name=fake.last_name(),
title=fake.job(),
email=fake.free_email(),
phone=fake.phone_number()).save()
# Create competitors
for _ in range(1, random.randrange(24)):
competitor = Competitor(name=fake.company())
competitor.save()
# Create opportunities
for _ in range(1, random.randrange(100)):
cmp_count = random.randint(6, 12)
agent = random.choice(Agent.objects.all())
client = random.choice(Client.objects.all())
opportunity = Opportunity(
title = fake.sentence(nb_words=6), \
agent = agent, \
client = client, \
domain = domain, \
deadline = datetime.datetime.now() + datetime.timedelta(days=random.randrange(100,120)), \
budget = 60000 + (random.randrange(60)*1000), \
margin = random.randrange(40)/100, \
milestone = random.choice(Opportunity.MILESTONES)[0], \
# Relationship
rel_knowledge = random.choice([True,False]), \
# Competitors
cmp_knowledge = random.choice([True,False]), \
cmp_count = cmp_count, \
# Solution
sol_leader = random.choice([True,False]), \
sol_refs = random.choice([True,False]), \
sol_understanding = random.choice([True,False]), \
sol_quantify = random.choice([True,False]), \
sol_create_requirements = random.choice([True,False]), \
sol_negociation = random.choice([True,False]))
opportunity.save()
for _ in range(1, random.randrange(cmp_count)):
Activity()
# Create competitors
for _ in range(1, random.randrange(cmp_count)):
CompetitorOpportunity(
competitor = random.choice(Competitor.objects.all()), \
opportunity = opportunity, \
appreciation = random.choice(CompetitorOpportunity.APPRECIATION)[0], \
relationship = random.choice(CompetitorOpportunity.RELATIONSHIP)[0], \
fullfilment = random.choice(CompetitorOpportunity.FULLFILMENT)[0], \
pro = fake.sentence(nb_words=26), \
cons = fake.sentence(nb_words=26), \
notes = fake.sentence(nb_words=26)
).save()
# Create requirements
for _ in range(1, random.randrange(6)):
Requirement(
description = fake.sentence(nb_words=6), \
opportunity = opportunity, \
fulfillment = random.choice(Requirement.FULLFILMENT)[0], \
notes = fake.sentence(nb_words=16)
).save()
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))
def inscriptionClientMobil(request):
#token = request.POST["token"]
nom = request.POST["nom"]
prenom = request.POST["prenom"]
email = request.POST["email"]
numero = request.POST["numero"]
password = request.POST["password"]
try:
_user = User.objects.filter(username=numero, is_active=1)[0]
if _user:
error_numero = "un compte est déjà enregistré avec ce numero"
return HttpResponse(error_numero, status=402)
except:
check = 0
exist = 0
listeValidation = Validation.objects.filter(estValider=0)
while check == 0:
var_tmp = ""
while len(var_tmp) < 6:
d = randint(0, 9)
var_tmp = var_tmp + str(d)
for validation in listeValidation:
if validation.keyValidation == var_tmp:
exist = 1
if exist == 0:
check = 1
personne = Personne()
personne.nomPersonne = nom
personne.prenomPersonne = prenom
personne.numeroPersonne = numero
personne.emailPersonne = email
personne.save()
try:
old_user = User.objects.filter(username=numero, is_active=0)[0]
if old_user:
old_user.delete()
except:
v = 1
user = User(username=numero,
email=email,
first_name=nom,
last_name=prenom,
is_active=1)
user.set_password(password)
user.save()
client = Client()
client.user = user
client.personne = personne
# client.code=password
client.type = 2
client.save()
validation = Validation()
validation.client = client
validation.keyValidation = var_tmp
validation.save()
data_message = {"code": var_tmp, "numero": numero}
sendSms(numero, var_tmp)
#sendSms(data_message)
log = Log()
log.utilisateur = request.user.username
log.action = "Creation compte client " + nom + " " + prenom + " " + numero
log.save()
nom = user.client.personne.nomPersonne
prenom = user.client.personne.prenomPersonne
idClient = user.client.idclient
data = '{'
data += '"nom":"' + nom + '",'
data += '"prenom":"' + prenom + '",'
data += '"idClient":"' + str(idClient) + '"'
data += '}'
return HttpResponse(data)
