def create(self, validated_data):
customers = [
customer['id'] for customer in self.initial_data.pop('customers')
]
groups = [
group['id'] for group in self.initial_data.pop('vehicle_groups')
]
modules = [mod['id'] for mod in self.initial_data.pop('modules', [])]
permission_name = self.initial_data.pop('permission')
self.initial_data['permission'] = UserPermission.get_by_name(
permission_name
) if permission_name else UserPermission.get_limited_user()
user = DataliveUser.objects.create(**self.initial_data)
customers_list = Customer.objects.filter(id__in=customers)
user.customers.add(*customers_list)
groups_list = VehicleGroup.objects.filter(id__in=groups)
user.vehicle_groups.add(*groups_list)
module_list = ModulePermission.objects.filter(id__in=modules)
user.modules.add(*module_list)
token = Helpers.unique_reset_token_key(user)
UserResetPasswordToken.create_token(user, token)
EmailService().send_welcome_password_email(user=user, token=token)
return user
def bill_upload(self, request):
serializer = userSerializer.MarketingCampaignSerializer(
data=request.data)
if serializer.is_valid():
data = serializer.validated_data
from core.models.master import Notifications
import base64
notices = Notifications.objects.filter(
name='OPS_MARKETING_BILL_UPLOAD')
for notice in notices:
if notice.type == Notifications.NOTIFICATION_TYPE_EMAIL:
context = {
'name': data.get('name'),
'email': data.get('email'),
'mobile': data.get('phone'),
'message': 'PFA Bill Uploaded By User.',
'utm_source': data.get('utm_source'),
'utm_medium': data.get('utm_medium'),
'utm_campaign': data.get('utm_campaign')
}
body = notice.template % context
subject = notice.subject % context
logger.debug('Send Email for Bill upload id=%s' % context)
attachment = {
'content': base64.b64encode(data.get('media').read()),
'name': 'uploaded_bill',
'type': 'image/jpeg'
}
from services.email_service import EmailService
EmailService.send_mail_using_mandrill_without_template(
subject,
notice.get_to_list(),
body,
cc_email_list=notice.get_cc_list(),
attachments=[attachment])
return Response({'status': 'success'}, status=status.HTTP_200_OK)
else:
return Response({"errors": serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serializer = DefectSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
print('**************')
print(serializer)
serializer.save()
# email = DefectSettings.confirmation_email
user = request.user
EmailService().send_defect_notification_email(user, serializer.data)
return Response(serializer.data, status=status.HTTP_201_CREATED)
def notify_email(self):
if self.type == self.NOTIFICATION_TYPE_PANIC:
subject = 'NOTIFICATION - Panic Button Alert from ' + str(
self.notified_by)
body = 'Panic message recieved: | Text message:' + str(
self.text) + '. | VehicleID: ' + str(
self.vehicle) + '. | Date: ' + str(self.date) + ', ' + str(
self.time) + 'From: ' + str(self.notified_by)
emails = [
'*****@*****.**', '*****@*****.**',
'*****@*****.**', '*****@*****.**',
'*****@*****.**'
]
# Send notifications to the above array
for s in emails:
print s
EmailService().send_generic_email(s, subject, body)
pass
def daily_vehicle_check_damage_email(date=timezone.now().date()):
damages_qs = Damage.objects.filter(date=date)
regions_ids = {
# key: region_id
# value: list of damage_id
}
vehicle_groups_ids = {
# key: vehicle_group_id
# value: list of damage_id
}
sent_emails = []
# get lists of related regions and vehicle groups
for obj in damages_qs.values('vehicle__vehiclegroup__region', 'vehicle__vehiclegroup', 'pk'):
if obj['vehicle__vehiclegroup__region']:
if obj['vehicle__vehiclegroup__region'] in regions_ids:
regions_ids[obj['vehicle__vehiclegroup__region']].append(obj['pk'])
else:
regions_ids[obj['vehicle__vehiclegroup__region']] = [obj['pk']]
if obj['vehicle__vehiclegroup']:
if obj['vehicle__vehiclegroup'] in vehicle_groups_ids:
vehicle_groups_ids[obj['vehicle__vehiclegroup']].append(obj['pk'])
else:
vehicle_groups_ids[obj['vehicle__vehiclegroup']] = [obj['pk']]
# send email for each region
for region in Region.objects.filter(pk__in=regions_ids.keys()).prefetch_related('notifications_emails'):
# get damages and vehicles related with this region
damages = damages_qs.filter(pk__in=regions_ids.get(region.pk, []))
region_vehicles_ids = set(region.VehicleGroups.values_list('vehicles__id', flat=True))
num_checked_vehicles = Report.objects.filter(vehicle__in=region_vehicles_ids, date=date).distinct().count()
# render text and html body for email
context = {
'region_name': region.name,
'report_date': date.strftime('%d/%m/%Y'),
'num_checked': num_checked_vehicles,
'num_unchecked': len(region_vehicles_ids) - num_checked_vehicles,
'new_damages': damages.filter(status='NEW').count(),
'unfixed_damages': Damage.objects.exclude(status='FIX').filter(vehicle__in=region_vehicles_ids).count(),
'dashboard_url': '',
}
text_content = get_template('notifications/emails/daily_vehicle_check_damage_email_region.txt').render(context)
html_content = get_template('notifications/emails/daily_vehicle_check_damage_email_region.html').render(context)
# send emails to Notifiacation Emails of this region
for email in region.notifications_emails.filter(email__isnull=False).values_list('email', flat=True).distinct():
sent_emails.append(email)
EmailService().send_generic_email(email, 'Vehicle Check Daily Depot summary', text_content, html_content)
Notification.objects.create(
notified_by='Automatically Cron msg',
source='CRON',
type=Notification.NOTIFICATION_TYPE_DAILY_VEHICLE_CHECK_EMAIL,
text=text_content,
)
# send email to each Vehicle Group
for vehicle_group in VehicleGroup.objects.filter(pk__in=vehicle_groups_ids.keys()).prefetch_related('notifications_emails'):
# get damages and vehicles related with this vehicle group
damages = damages_qs.filter(pk__in=vehicle_groups_ids.get(vehicle_group.pk, []))
depot_vehicles_ids = set(vehicle_group.vehicles.values_list('id', flat=True))
num_checked_vehicles = Report.objects.filter(vehicle__in=depot_vehicles_ids, date=date).distinct().count()
# render text and html body for email
context = {
'depot_name': vehicle_group.name,
'report_date': date.strftime('%d/%m/%Y'),
'num_checked': num_checked_vehicles,
'num_unchecked': len(depot_vehicles_ids) - num_checked_vehicles,
'new_damages': damages.filter(status='NEW').count(),
'unfixed_damages': Damage.objects.exclude(status='FIX').filter(vehicle__in=depot_vehicles_ids).count(),
'dashboard_url': '',
}
text_content = get_template('notifications/emails/daily_vehicle_check_damage_email_depot.txt').render(context)
html_content = get_template('notifications/emails/daily_vehicle_check_damage_email_depot.html').render(context)
# send emails to Notifiacation Emails of this vehicle group
for email in vehicle_group.notifications_emails.filter(email__isnull=False).values_list('email', flat=True).distinct():
# prevent duplicate of email if Region report already was sent to this email
if email not in sent_emails:
EmailService().send_generic_email(email, 'Vehicle Check Daily Region summary', text_content, html_content)
Notification.objects.create(
notified_by='Automatically Cron msg',
source='CRON',
type=Notification.NOTIFICATION_TYPE_DAILY_VEHICLE_CHECK_EMAIL,
text=text_content,
)
def mot_expiry_email_notifications():
# mot expired after 7 days
vehicles_qs = Vehicle.objects.filter(
mot_date__lte=timezone.now().date()+timedelta(days=settings.SEND_NOTIFICATION_IF_MOT_EXPIRY_DATE_LESS_THAN_DAYS))
regions_ids = {
# key: region_id
# value: list of vehicle_id
}
vehicle_groups_ids = {
# key: vehicle_group_id
# value: list of vehicle_id
}
sent_emails = []
# get lists of related regions and vehicle groups
for obj in vehicles_qs.values('vehiclegroup__region', 'vehiclegroup', 'pk'):
if obj['vehiclegroup__region']:
if obj['vehiclegroup__region'] in regions_ids:
regions_ids[obj['vehiclegroup__region']].append(obj['pk'])
else:
regions_ids[obj['vehiclegroup__region']] = [obj['pk']]
if obj['vehiclegroup']:
if obj['vehiclegroup'] in vehicle_groups_ids:
vehicle_groups_ids[obj['vehiclegroup']].append(obj['pk'])
else:
vehicle_groups_ids[obj['vehiclegroup']] = [obj['pk']]
# send email for each region
for region in Region.objects.filter(pk__in=regions_ids.keys()).prefetch_related('notifications_emails'):
# get vehicles related with this region
vehicles = vehicles_qs.filter(pk__in=regions_ids.get(region.pk, []))
# render text and html body for email
context = {
'region_name': region.name,
'report_date': timezone.now().date().strftime('%d/%m/%Y'),
'vehicles': vehicles,
}
text_content = get_template('notifications/emails/mot_expiry_email_notification_region.txt').render(context)
html_content = get_template('notifications/emails/mot_expiry_email_notification_region.html').render(context)
# send emails to Notifiacation Emails of this region
for email in region.notifications_emails.filter(email__isnull=False).values_list('email', flat=True).distinct():
sent_emails.append(email)
EmailService().send_generic_email(email, 'MOT Expiry notification', text_content, html_content)
Notification.objects.create(
notified_by='Automatically Cron msg',
source='CRON',
type=Notification.NOTIFICATION_TYPE_MOT_EXPIRY_EMAIL,
text=text_content,
)
# send email to each Vehicle Group
for vehicle_group in VehicleGroup.objects.filter(pk__in=vehicle_groups_ids.keys()).prefetch_related('notifications_emails'):
# get vehicles related with this vehicle group
vehicles = vehicles_qs.filter(pk__in=vehicle_groups_ids.get(vehicle_group.pk, []))
# render text and html body for email
context = {
'depot_name': vehicle_group.name,
'report_date': timezone.now().date().strftime('%d/%m/%Y'),
'vehicles': vehicles,
}
text_content = get_template('notifications/emails/mot_expiry_email_notification_depot.txt').render(context)
html_content = get_template('notifications/emails/mot_expiry_email_notification_depot.html').render(context)
# send emails to Notifiacation Emails of this vehicle group
for email in vehicle_group.notifications_emails.filter(email__isnull=False).values_list('email', flat=True).distinct():
# prevent duplicate of email if Region report already was sent to this email
if email not in sent_emails:
EmailService().send_generic_email(email, 'MOT Expiry notification', text_content, html_content)
Notification.objects.create(
notified_by='Automatically Cron msg',
source='CRON',
type=Notification.NOTIFICATION_TYPE_MOT_EXPIRY_EMAIL,
text=text_content,
)
"""Game services. A service is just a class devoted to perform certain actions, like sending emails (the email service). Services can be reached and imported here. """ from services.email_service import EmailService email = EmailService()
def __init__(self, otp_digits=4):
self.email = EmailService()
self.otp_digits = otp_digits
self.user_model = UserModel()
class LoginService:
"""
Provide methods for login management
"""
def __init__(self, otp_digits=4):
self.email = EmailService()
self.otp_digits = otp_digits
self.user_model = UserModel()
@staticmethod
def make_response(is_valid: bool, info, error_code: int):
"""
Make response for client
:param is_valid: The success of the operation
:param info: Some information
:param error_code: HTMl error code
:return: dict()
"""
return {'valid': is_valid, 'info': info, 'code': error_code}
@staticmethod
def is_valid_email(email):
return validate_email(email=email)
@staticmethod
def api_key_generator(email, password):
"""
Create a SHA256 code with tuple(email, password)
:param email: Email of the user
:param password: Password of the user
:return: SHA256 code
"""
hash_string = email + password + email.split('@')[0]
sha_signature = hashlib.sha256(hash_string.encode()).hexdigest()
return sha_signature
def user_exists(self, email, api_key):
"""
Check if a user exists into the DB
:param email:
:param api_key:
:return: True | False
"""
if self.is_valid_email(email):
return self.user_model.check_user(email, api_key)
else:
logger.error("login_service -> user_exists")
return False
def create_user(self, name, surname, username, email, password):
"""
Create a user by
:param name:
:param surname:
:param username:
:param email:
:param password:
:return: api_key | False
"""
if name and surname and username and email and password:
if self.is_valid_email(
email) and not self.user_model.check_username(username):
api_key = self.api_key_generator(email, password)
if not self.user_exists(email, api_key):
return self.make_response(
True, {
'api_key':
self.user_model.create(name, surname, username,
email, api_key)
}, 200)
return self.make_response(False, "Not valid input", 400)
def user_logged(self, email, api_key, otp_code):
"""
Get a specific user by
:param email:
:param api_key:
:param otp_code:
:return: True | False
"""
if self.is_valid_email(email):
if self.user_model.get_user_with_otp(email, api_key,
otp_code) and self.clear_otp(
api_key, otp_code):
self.user_model.reset_otp_requests(api_key)
return True
return False
else:
logger.error("login_service -> user_logged")
return False
# TODO: To improve
def send_reset_password(self, email, password):
"""
Send email for reset password
:param email:
:param password:
:return: True | False
"""
if self.is_valid_email(email):
if self.user_model.check_user(
email, self.api_key_generator(
email,
password)): # TODO: This condition is not perfect
return self.email.send_reset_password(email)
else:
logger.error("login_service -> send_reset_password")
return False
@staticmethod
def generate_otp():
"""
Create a random OTP of 6 digits
:return: OTP code
"""
return randint(100000, 999999)
def send_otp_code(self, email, api_key):
"""
Send OTP code via email
:param email:
:param api_key:
:return: True | False
"""
if self.is_valid_email(email) and self.user_exists(email, api_key):
otp_code = self.generate_otp()
self.user_model.create_otp(api_key, otp_code)
if self.check_otp_requests(email, api_key, otp_code):
timestamp = self.user_model.get_otp_timestamp(api_key)
otp_requests = self.user_model.get_otp_requests(api_key) + 1
self.user_model.update_otp(otp_requests, timestamp, api_key)
if self.email.send_otp(email, otp_code):
return True
else:
logger.error("login_service -> send_otp_code")
return False
def clear_otp(self, api_key, otp_code):
"""
Delete OTP code after login
:param api_key: api_key of user that logged in
:param otp_code: OTP code of user that logged in
:return: True | False
"""
return self.user_model.delete_otp(api_key, otp_code)
def check_otp_requests(self, email, api_key, otp_code):
"""
Check if the requested limit of otp has been reached
:param email:
:param api_key:
:param otp_code:
:return: True | False
"""
if self.user_model.check_user_otp_timestamp(api_key):
self.user_model.reset_otp_requests(api_key)
if 0 <= self.user_model.get_otp_requests(
api_key) <= 3 and self.user_model.get_user_with_otp(
email, api_key, otp_code):
return True
return False
def check_api_key(self, api_key):
"""
Find user by:
:param api_key:
:return True | False
"""
return self.user_model.check_api_key(api_key)
def put(self, request, format=None):
file = request.FILES['file']
customer_id = request.data.get("customer_id", None)
user_email = request.data.get('email', None)
try:
customer = Customer.objects.get(id=customer_id)
except Exception as e:
return Response({
"error":
"Customer ID %s was not found in our database. Please confirm that you have selected a customer"
% customer_id
})
wb = load_workbook(file)
validate = self.validate_excel(wb)
if validate != True:
return Response({"error": validate})
verify_upload = request.data.get("verifyUpload", None)
if verify_upload == "true":
vehicles_array, vehicle_manufacturer_array, vehicle_group_array = self.classify_rows(
wb)
return Response({
"vehiclesArray": vehicles_array,
"vehicleManufacturerArray": vehicle_manufacturer_array,
"depotArray": vehicle_group_array
})
rows_inserted = 0
rows_failed = 0
rows_updated = 0
error_list = []
# Address Sheet Inserts
address_sheet = wb["address"]
address_header = [
cell.value for cell in address_sheet.rows[0]
if cell.value is not None
]
address_array = self.excel_dict_reader(address_header, address_sheet)
for num, obj in enumerate(address_array):
try:
if len(Address.objects.filter(
display_name=obj["display_name"])) == 0:
address = Address.objects.create(**obj)
address.save()
rows_inserted += 1
else:
Address.objects.filter(
display_name=obj["display_name"]).update(**obj)
address = Address.objects.filter(**obj)[0]
rows_updated += 1
except Exception as e:
rows_failed += 1
error_list.append('%s in row %s in the Address sheet' %
(type(e).__name__, num + 2))
continue
# Contact Sheet Inserts
contact_sheet = wb["contact"]
contact_header = [
cell.value for cell in contact_sheet.rows[0]
if cell.value is not None
]
contact_array = self.excel_dict_reader(contact_header, contact_sheet)
for num, obj in enumerate(contact_array):
try:
obj["address"] = Address.objects.filter(
display_name=obj["address"])[0] if len(
Address.objects.filter(
display_name=obj["address"])) > 0 else None
if len(Contact.objects.filter(
display_name=obj["display_name"])) == 0:
contact = Contact.objects.create(**obj)
contact.save()
rows_inserted += 1
else:
Contact.objects.filter(
display_name=obj["display_name"]).update(**obj)
contact = Contact.objects.filter(**obj)[0]
rows_updated += 1
except Exception as e:
rows_failed += 1
error_list.append('%s in row %s in the Contact sheet' %
(type(e).__name__, num + 2))
continue
# Customer Sheet Inserts
customers_sheet = wb["customer"]
customers_header = [
cell.value for cell in customers_sheet.rows[0]
if cell.value is not None
]
customers_array = self.excel_dict_reader(customers_header,
customers_sheet)
for num, obj in enumerate(customers_array):
try:
obj["contact"] = Contact.objects.filter(
display_name=obj["contact"])[0] if len(
Contact.objects.filter(
display_name=obj["contact"])) > 0 else None
obj["maintenance_control"] = Contact.objects.filter(
display_name=obj["maintenance_control"]
)[0] if len(
Contact.objects.filter(
display_name=obj["maintenance_control"])) > 0 else None
if len(Customer.objects.filter(name=obj["name"])) == 0:
customer = Customer.objects.create(**obj)
customer.save()
rows_inserted += 1
else:
Customer.objects.filter(name=obj["name"]).update(**obj)
customer = Customer.objects.filter(**obj)[0]
rows_updated += 1
except Exception as e:
rows_failed += 1
error_list.append('%s in row %s in the Customer sheet' %
(type(e).__name__, num + 2))
continue
# Lease Company Sheet Inserts
lease_company_sheet = wb["lease company"]
lease_company_header = [
cell.value for cell in lease_company_sheet.rows[0]
if cell.value is not None
]
lease_company_array = self.excel_dict_reader(lease_company_header,
lease_company_sheet)
for num, obj in enumerate(lease_company_array):
try:
obj["customer"] = customer
obj["address"] = Address.objects.filter(
display_name=obj["address"])[0] if len(
Address.objects.filter(
display_name=obj["address"])) > 0 else None
if len(LeaseCompany.objects.filter(name=obj["name"])) == 0:
lease_company = LeaseCompany.objects.create(**obj)
lease_company.save()
rows_inserted += 1
else:
LeaseCompany.objects.filter(name=obj["name"]).update(**obj)
lease_company = LeaseCompany.objects.filter(**obj)[0]
rows_updated += 1
except Exception as e:
rows_failed += 1
error_list.append('%s in row %s in the Lease Company sheet' %
(type(e).__name__, num + 2))
continue
# Vehicle Group Contacts Inserts OR Depot Contacts
vehicle_group_contact_sheet = wb["depot contacts"]
vehicle_group_contact_header = [
cell.value for cell in vehicle_group_contact_sheet.rows[0]
if cell.value is not None
]
vehicle_group_contact_array = self.excel_dict_reader(
vehicle_group_contact_header, vehicle_group_contact_sheet)
for num, obj in enumerate(vehicle_group_contact_array):
try:
obj["customer"] = customer
obj["address"] = Address.objects.filter(
display_name=obj["address"])[0] if len(
Address.objects.filter(
display_name=obj["address"])) > 0 else None
if len(VehicleGroupContact.objects.filter(
name=obj["name"])) == 0:
vehicle_group_contact = VehicleGroupContact.objects.create(
**obj)
vehicle_group_contact.save()
rows_inserted += 1
else:
VehicleGroupContact.objects.filter(
name=obj["name"]).update(**obj)
vehicle_group_contact = VehicleGroupContact.objects.filter(
**obj)[0]
rows_updated += 1
except Exception as e:
rows_failed += 1
error_list.append('%s in row %s in the Depot Contacts sheet' %
(type(e).__name__, num + 2))
continue
# Vehicle Manufacturer Model inserts
vehicle_manufacturer_sheet = wb["vehicle manufacturer model"]
vehicle_manufacturer_header = [
cell.value for cell in vehicle_manufacturer_sheet.rows[0]
if cell.value is not None
]
vehicle_manufacturer_array = self.excel_dict_reader(
vehicle_manufacturer_header, vehicle_manufacturer_sheet)
for num, obj in enumerate(vehicle_manufacturer_array):
try:
# Creating VehicleManufacturer object if it doesn't exist
if len(
VehicleManufacturer.objects.filter(
name=obj["manufacturer"])) > 0:
obj["manufacturer"] = VehicleManufacturer.objects.filter(
name=obj["manufacturer"])[0]
else:
manufacturer = VehicleManufacturer.objects.create(
name=obj["manufacturer"])
manufacturer.save()
obj["manufacturer"] = manufacturer
# Creating VehicleManufacturer model from here on
obj["vehicle_type"] = self.choices_map(
obj["vehicle_type"],
VehicleManufacturerModel().VEHICLE_TYPES)
obj["fuel_type"] = self.choices_map(
obj["fuel_type"],
VehicleManufacturerModel().FUEL_TYPE)
vehicle_model_contacts = obj.pop("vehicle_model_contacts",
None)
if len(
VehicleManufacturerModel.objects.filter(
model=obj["model"])) == 0:
manufacturer_model = VehicleManufacturerModel.objects.create(
**obj)
rows_inserted += 1
else:
VehicleManufacturerModel.objects.filter(
model=obj["model"]).update(**obj)
manufacturer_model = VehicleManufacturerModel.objects.filter(
**obj)[0]
rows_updated += 1
manufacturer_model.save()
if vehicle_model_contacts is not None:
for vehicle_model_contact in vehicle_model_contacts.split(
','):
vehicle_model_contact = VehicleGroupContact.objects.filter(
name=vehicle_model_contact)[0]
manufacturer_model.vehicle_model_contacts.add(
vehicle_model_contact)
manufacturer_model = manufacturer_model.save()
except IndexError:
rows_failed += 1
pass
except Exception as e:
rows_failed += 1
error_list.append(
'%s in row %s in the Vehicle Manufacturer Model sheet' %
(type(e).__name__, num + 2))
# Driver category inserts
driver_category_sheet = wb["driver category"]
driver_category_header = [
cell.value for cell in driver_category_sheet.rows[0]
if cell.value is not None
]
driver_category_array = self.excel_dict_reader(driver_category_header,
driver_category_sheet)
for num, obj in enumerate(driver_category_array):
try:
obj["customer"] = customer
if len(
DriverCategory.objects.filter(
display_name=obj["display_name"])) == 0:
driver_category = DriverCategory.objects.create(**obj)
driver_category.save()
rows_inserted += 1
else:
DriverCategory.objects.filter(
display_name=obj["display_name"]).update(**obj)
rows_updated += 1
except Exception as e:
rows_failed += 1
error_list.append('%s in row %s in the Driver Category sheet' %
(type(e).__name__, num + 2))
continue
# Livery category inserts
livery_category_sheet = wb["livery category"]
livery_category_header = [
cell.value for cell in livery_category_sheet.rows[0]
if cell.value is not None
]
livery_category_array = self.excel_dict_reader(livery_category_header,
livery_category_sheet)
for num, obj in enumerate(livery_category_array):
try:
obj["customer"] = customer
if len(
LiveryCategory.objects.filter(
category_name=obj["category_name"])) == 0:
category = LiveryCategory.objects.create(**obj)
category.save()
rows_inserted += 1
else:
LiveryCategory.objects.filter(
category_name=obj["category_name"]).update(**obj)
rows_updated += 1
except Exception as e:
rows_failed += 1
error_list.append('%s in row %s in the Livery Category sheet' %
(type(e).__name__, num + 2))
continue
# Vehicles Sheet Inserts
vehicles_sheet = wb["vehicle"]
vehicles_header = [
cell.value for cell in vehicles_sheet.rows[0]
if cell.value is not None
]
vehicles_array = self.excel_dict_reader(vehicles_header,
vehicles_sheet)
vehicle_group_cross = {}
for num, obj in enumerate(vehicles_array):
try:
# Setting our ForeignKeys to actual values
make = obj.pop("make", None)
model = obj.pop("model", None)
obj["manufacturer_model"] = VehicleManufacturerModel.objects.filter(
model=model)[0] if len(
VehicleManufacturerModel.objects.filter(
model=model)) > 0 else None
obj["driver_category"] = DriverCategory.objects.filter(
display_name=obj["driver_category"])[0] if len(
DriverCategory.objects.filter(
display_name=obj["driver_category"])) > 0 else None
obj["customer"] = customer
obj["lease_company"] = LeaseCompany.objects.filter(
name=obj["lease_company"],
customer=obj["customer"])[0] if len(
LeaseCompany.objects.filter(
name=obj["lease_company"],
customer=obj["customer"])) > 0 else None
obj["livery_category"] = LiveryCategory.objects.filter(
category_name=obj["livery_category"]
)[0] if len(
LiveryCategory.objects.filter(
category_name=obj["livery_category"])) > 0 else None
obj["latest_odometer_source"] = self.choices_map(
obj["latest_odometer_source"],
Vehicle().VEHICLE_ODO_SOURCES)
group = obj.pop('vehicle_group', None)
if group is not None:
vehicle_group_cross[group] = obj["registration"]
if len(Vehicle.objects.filter(
registration=obj["registration"])) == 0:
vehicle = Vehicle.objects.create(**obj)
vehicle.save()
rows_inserted += 1
else:
Vehicle.objects.filter(
registration=obj["registration"]).update(**obj)
vehicle = Vehicle.objects.filter(**obj)[0]
rows_updated += 1
except Exception as e:
rows_failed += 1
error_list.append('%s in row %s in the Vehicle sheet' %
(type(e).__name__, num + 2))
continue
# Vehicle Group Inserts or Depot
vehicle_group_sheet = wb["depot"]
vehicle_group_header = [
cell.value for cell in vehicle_group_sheet.rows[0]
if cell.value is not None
]
vehicle_group_array = self.excel_dict_reader(vehicle_group_header,
vehicle_group_sheet)
for num, obj in enumerate(vehicle_group_array):
try:
obj["customer"] = customer
vehicles = obj.pop('vehicles', None)
notifications_emails = obj.pop('notifications_emails', None)
vehicle_group_contacts = obj.pop('vehicle_group_contacts',
None)
if len(VehicleGroup.objects.filter(name=obj["name"])) == 0:
vehicle_group = VehicleGroup.objects.create(**obj)
vehicle_group.save()
rows_inserted += 1
else:
VehicleGroup.objects.filter(name=obj["name"]).update(**obj)
vehicle_group = VehicleGroup.objects.filter(**obj)[0]
rows_updated += 1
for vehicle_group_key in vehicle_group_cross.keys():
if vehicle_group_key == vehicle_group.name:
vehicle = Vehicle.objects.filter(
registration=vehicle_group_cross[vehicle_group_key]
)[0]
vehicle_group.vehicles.add(vehicle)
vehicle_group = vehicle_group.save()
else:
vehicle_group_new = VehicleGroup.objects.filter(
name=vehicle_group_key)[0] if len(
VehicleGroup.objects.filter(
name=vehicle_group_key)) > 0 else None
if vehicle_group_new is not None:
vehicle = Vehicle.objects.filter(
registration=vehicle_group_cross[
vehicle_group_key])[0]
vehicle_group_new.vehicles.add(vehicle)
vehicle_group = vehicle_group_new.save()
if vehicles is not None:
for vehicle in vehicles:
vehicle = Vehicle.objects.filter(
registration=vehicle)[0]
vehicle_group.vehicles.add(vehicle)
vehicle_group = vehicle_group.save()
if notifications_emails is not None:
for notification in notifications_emails:
notification = NotificationEmail.objects.filter(
name=notification)[0]
vehicle_group.notifications_emails.add(notification)
vehicle_group = vehicle_group.save()
if vehicle_group_contacts is not None:
for contact in vehicle_group_contacts:
contact = VehicleGroupContact.objects.filter(
name=contact)[0]
vehicle_group.vehicle_group_contacts.add(contact)
vehicle_group = vehicle_group.save()
except IndexError:
continue
except Exception as e:
rows_failed += 1
error_list.append('%s in row %s in the Depot sheet' %
(type(e).__name__, num + 2))
continue
# Insurance Policy Number Inserts
insurance_policy_number_sheet = wb["insurance policy number"]
insurance_policy_number_header = [
cell.value for cell in insurance_policy_number_sheet.rows[0]
if cell.value is not None
]
insurance_policy_number_array = self.excel_dict_reader(
insurance_policy_number_header, insurance_policy_number_sheet)
for num, obj in enumerate(insurance_policy_number_array):
try:
obj["driver_category"] = DriverCategory.objects.filter(
display_name=obj["driver_category"])[0] if len(
DriverCategory.objects.filter(
display_name=obj["driver_category"])) > 0 else None
if len(
InsurancePolicyNumber.objects.filter(
policy_number=obj["policy_number"])) == 0:
policy_number = InsurancePolicyNumber.objects.create(**obj)
policy_number.save()
rows_inserted += 1
else:
InsurancePolicyNumber.objects.filter(
policy_number=obj["policy_number"]).update(**obj)
policy_number = InsurancePolicyNumber.objects.filter(
**obj)[0]
rows_updated += 1
except Exception as e:
rows_failed += 1
error_list.append(
'%s in row %s in the Insurance Policy Number sheet' %
(type(e).__name__, num + 2))
continue
# Insurance Inserts
insurance_sheet = wb["insurance"]
insurance_header = [
cell.value for cell in insurance_sheet.rows[0]
if cell.value is not None
]
insurance_array = self.excel_dict_reader(insurance_header,
insurance_sheet)
for num, obj in enumerate(insurance_array):
try:
obj["customer"] = customer
obj["address"] = Address.objects.filter(
display_name=obj["address"])[0] if len(
Address.objects.filter(
display_name=obj["address"])) > 0 else None
policy_numbers = obj.pop("insurance_policy_numbers", None)
if len(Insurance.objects.filter(name=obj["name"])) == 0:
insurance = Insurance.objects.create(**obj)
insurance.save()
rows_inserted += 1
else:
Insurance.objects.filter(name=obj["name"]).update(**obj)
insurance = Insurance.objects.filter(**obj)[0]
rows_updated += 1
if policy_numbers is not None:
for policy_number in policy_numbers:
policy_number = InsurancePolicyNumber.objects.get(
policy_number=policy_number)
insurance.insurance_policy_numbers.add(policy_number)
insurance = insurance.save()
except Exception as e:
rows_failed += 1
error_list.append('%s in row %s in the Insurance sheet' %
(type(e).__name__, num + 2))
continue
email_body = "%s Rows were inserted, %s Rows were updated and %s Rows failed.\nErrors:\n-" % (
rows_inserted, rows_failed, rows_updated)
email_body += "\n-".join(error_list)
EmailService().send_generic_email(user_email,
'Datalive Import Results',
email_body)
error_dict = []
for error in error_list:
error_dict.append({
"row":
error.split("in the")[0].split("row")[-1].strip(),
"error_name":
error.split('in row')[0].strip(),
"sheet":
error.split("in the")[1].replace("sheet", '').strip()
})
return Response({
"rows_inserted": rows_inserted,
"rows_failed": rows_failed,
"rows_updated": rows_updated,
"error_dict": error_dict
})