def get_initial(self):
data = super(CreateEnd, self).get_initial()
pk_contract = self.kwargs['pk_contract']
pk_delivery = self.kwargs['pk_delivery']
item_delivery = ItemDelivery.objects.get(pk=pk_delivery)
contract = Contract.objects.get(pk=pk_contract)
data['item_delivery'] = item_delivery
data['contract'] = contract
data['distance_delivery'] = round(item_delivery.distance, 2)
data['distance_collect'] = round(
get_distance(get_addressable(contract.driver),
get_addressable(item_delivery)), 2)
data['distance_total'] = round(
data['distance_delivery'] + data['distance_collect'], 2)
data['collect_time'] = utc_to_local(
datetime.datetime.now()) + datetime.timedelta(
seconds=get_route_time(get_addressable(contract.driver),
get_addressable(item_delivery),
contract.transport))
data['delivery_time'] = data['collect_time'] + datetime.timedelta(
seconds=get_route_time(get_addressable(item_delivery),
get_addressable(item_delivery.target),
contract.transport))
data['cost_travel'] = Money(
round(
get_cost_travel(contract.transport.km_l,
data['distance_total'], contract.driver.type),
2), 'BRL')
data['start_travel_time'] = utc_to_local(datetime.datetime.now())
return data
def check_delivered(self, **kwargs):
travels = Travel.objects.filter(
contract__player=self.request.user.player, is_delivered=False)
for travel in travels:
self.update_driver_position(travel, **kwargs)
if utc_to_local(datetime.datetime.now()) >= travel.delivery_time:
travel.is_collected = True
travel.is_delivered = True
driver = travel.contract.driver
driver.status_driver = STATUS_DRIVERS[1][0]
driver.lat = travel.item_delivery.target.lat
driver.lng = travel.item_delivery.target.lng
driver.address = travel.item_delivery.target.address
driver.save()
travel.save()
player = self.request.user.player
player.credits = player.credits + travel.item_delivery.amount_receivable
player.credits = player.credits - travel.cost_travel
player.save()
notification = EmailNotification()
notification.player = player
notification.message = "Delivery #{} foi entregue por {} em {}".format(
str(travel.pk), str(travel.contract.driver.name),
str(travel.item_delivery.target.address))
notification.save()
def check_recurrency_loan(request, loan):
now = utc_to_local(datetime.datetime.now())
if now >= loan.recurrency.next:
change_next_recurrency(loan.recurrency, **{'months': 1})
pay(request, loan.value_installment)
notification = EmailNotification()
notification.player = loan.player
notification.message = "The monthly fee for the loan of {} was paid in the amount of R$ {}".format(
str(loan.loan_value), str(loan.value_installment))
notification.save()
def check_recurrency_driver(request, driver):
now = utc_to_local(datetime.datetime.now())
if now >= driver.recurrency.next:
change_next_recurrency(driver.recurrency, **{'weeks': 1})
pay(request, driver.salary)
notification = EmailNotification()
notification.player = driver.contract.player
notification.message = "{} salary was paid in the amount of R$ {}".format(
str(driver.name), str(driver.salary))
notification.save()
def check_recurrency_contract(request, contract):
now = utc_to_local(datetime.datetime.now())
if now >= contract.recurrency.next:
change_next_recurrency(contract.recurrency, **{'years': 1})
pay(request, contract.bonus)
notification = EmailNotification()
notification.player = contract.player
notification.message = "A bonus was paid to {} in the amount of R$ {}".format(
str(contract.driver.name), str(contract.bonus))
notification.save()
def check_system_generate_new_objects(self):
sys = System.objects.first()
now = utc_to_local(datetime.datetime.now())
dic_sys = {}
dic_sys[sys.type] = sys.timer
if now >= sys.next:
sys.last = now
sys.next = now + relativedelta(**dic_sys)
sys.save()
self.generate_new_objects()
def check_recurrency_transport(request, transport):
now = utc_to_local(datetime.datetime.now())
if now >= transport.recurrency.next:
change_next_recurrency(transport.recurrency,
**get_dict_recurr_by_type(transport.type))
pay(request, transport.maintenance_value)
notification = EmailNotification()
notification.player = transport.owner
notification.message = "Maintenance for transportation #{} was paid in the amount of R$ {}".format(
str(transport.id), str(transport.maintenance_value))
notification.save()
def get_position_driver_current(self, travel):
diff_total = (travel.delivery_time -
travel.start_travel_time).total_seconds()
current_diff = (utc_to_local(datetime.datetime.now()) -
travel.start_travel_time).total_seconds()
prop_way = current_diff / diff_total
if travel.map_coordinates:
array_map = json.loads(travel.map_coordinates)
if current_diff > diff_total:
return array_map[-1]['lat'], array_map[-1]['lng']
index = int((len(array_map) - 1) * prop_way)
return array_map[index]['lat'], array_map[index]['lng']
return travel.contract.driver.lat, travel.contract.driver.lng
def generate_recurrency(is_limited=False, end=None, **kwargs):
now = utc_to_local(datetime.datetime.now())
if end is None:
end = {}
keys = list(kwargs.keys())
end[keys[0]] = kwargs[keys[0]] + 1
recurrency = Recurrency()
recurrency.is_limited = is_limited
recurrency.start = now
recurrency.end = now + relativedelta(**end)
recurrency.next = now + relativedelta(**kwargs)
recurrency.save()
return recurrency
def change_lat_lng_driver(contract_model, start_travel, target_addressable):
now = datetime.datetime.now()
diff = (utc_to_local(now) - start_travel).total_seconds()
point_a = {'lat': contract_model.driver.lat, 'lng': contract_model.driver.lng}
point_b = {'lat': target_addressable.lat, 'lng': target_addressable.lng}
maneuvers = get_maneuvers(point_a, point_b)
address_actually = check_maneuvers(maneuvers, diff)
if address_actually:
geoloc = geolocation(address_actually, point_a, point_b)
if geoloc:
actual_lat = str(geoloc['lat'])
actual_lng = str(geoloc['lon'])
actual_address = address_actually
return actual_lat, actual_lng, actual_address
return contract_model.driver.lat, contract_model.driver.lng, contract_model.driver.address
def form_valid(self, form):
map_coordinates = self.request.POST['map_coordinates']
self.object = form.save()
data = form.cleaned_data.copy()
self.object.start_travel_time = utc_to_local(datetime.datetime.now())
self.object.collect_time = self.object.start_travel_time + datetime.timedelta(
seconds=get_route_time(
get_addressable(self.object.contract.driver),
get_addressable(self.object.item_delivery),
self.object.contract.transport))
self.object.save()
self.object.delivery_time = get_sum_delivery_time(self.object)
self.object.save()
driver = self.object.contract.driver
driver.status_driver = STATUS_DRIVERS[0][0]
driver.save()
messages.success(self.request, 'Travel created with success')
return super(CreateEnd, self).form_valid(form)
def check_collected(self, **kwargs):
travels = Travel.objects.filter(
contract__player=self.request.user.player, is_collected=False)
for travel in travels:
self.update_driver_position(travel, **kwargs)
if utc_to_local(datetime.datetime.now()) >= travel.collect_time:
travel.is_collected = True
travel.save()
driver = travel.contract.driver
driver.lat = travel.item_delivery.lat
driver.lng = travel.item_delivery.lng
driver.address = travel.item_delivery.address
driver.save()
notification = EmailNotification()
notification.player = driver.contract.player
notification.message = "Delivery foi coletado por {} em {}".format(
str(travel.contract.driver.name),
str(travel.item_delivery.target.address))
notification.save()
def handle(self, *args, **kwargs):
Loan.objects.all().delete()
Recurrency.objects.all().delete()
Transport.objects.all().delete()
Driver.objects.all().delete()
ItemDelivery.objects.all().delete()
Address.objects.all().delete()
System.objects.all().delete()
sys = System()
now_time = utc_to_local(datetime.datetime.now())
sys.last = now_time
sys.save()
dic_sys = {}
dic_sys[sys.type] = sys.timer
sys.next = now_time + relativedelta(**dic_sys)
sys.save()
for i in range(50):
transp = Transport()
transp.save(first_save=True)
driver = Driver()
driver.save(first_save=True)
idelivr = generate_object_item_delivery()
print(idelivr.lat, idelivr.lng)
def get_seconds(value, travel=None):
if travel:
return (travel.delivery_time -
utc_to_local(datetime.datetime.now())).total_seconds() * 1000
return (value -
utc_to_local(datetime.datetime.now())).total_seconds() * 1000
def get_value_pay(loan):
now = utc_to_local(datetime.datetime.now())
months = calc_diff_months(loan.created_at, now)
if months < 1:
return loan.total_value_pay
return ((10 - months) * loan.value_installment)
def check_stop_recurrency(object):
now = utc_to_local(datetime.datetime.now())
if now >= object.recurrency.end:
rec = object.recurrency
rec.delete()
object.delete()
def timeformat(date):
date = utc_to_local(date)
return date.strftime("%Y-%m-%dT%H:%M:%S")
