def get_revenue_by_resourcetype(self):
by_resource = self.get_revenue_by_resource()
result = dict((r.type, 0) for r in Resource.selectBy(place=self.location))
for name, revenue in by_resource:
r_type = Resource.selectBy(name=name)[0].type
result[r_type] += revenue
return result.items()
def validate_python(self, field_dict, state):
resource = Resource.get(field_dict['resource_id'])
if not resource.time_based:
return
if 'start' in field_dict and field_dict['start']:
start = field_dict['start']
start_time = time(int(start['hour']), int(start['minute']))
date = dateconverter.to_python(field_dict['date'])
start = datetime.combine(date, start_time)
elif 'start_datetime' in field_dict and field_dict['start_datetime']:
start = datetimeconverter.to_python(field_dict['start_datetime'])
else:
start = now(resource.place)
if 'end' in field_dict and field_dict['end']:
end = field_dict['end']
end_time = time(int(end['hour']), int(end['minute']))
date = dateconverter.to_python(field_dict['date'])
end = datetime.combine(date, end_time)
elif 'end_datetime' in field_dict and field_dict['end_datetime']:
end = datetimeconverter.to_python(field_dict['end_datetime'])
else:
end = start
errors = {}
if end <= start:
errors['end'] = _("The booking must end later than it starts!")
errors['start'] = _("The booking must start before ending!")
raise Invalid(
'That booking ends before starting', field_dict, state, error_dict=errors)
def get_usage_by_tariff(self):
"""
-> { rtype1:
{ tariff1:
{ resource1: usage, resource2: usage, ..},
tariff2: ..
}
}
usage: hours/quantity
"""
tariff_ids = tuple(resource.id for resource in self.location.resources if resource.type == 'tariff')
relevant_usages = tuple(ru for ru in self.usages if ru.resourceID not in tariff_ids)
relevant_resources = set(ru.resourceID for ru in relevant_usages)
r_type_map = dict((res.name, res.type) for res in self.location.resources if res.id in relevant_resources)
r_types = set(r_type_map.values())
type_resources_map = dict((r_type, tuple(x[0] for x in resources)) for r_type, resources in sortAndGrpby(r_type_map.items(), lambda item: item[1]))
resname = lambda r_id: Resource.get(r_id).name
#result = dict((r_type, dict((resname(t_id), dict((res, 0) for res in type_resources_map[r_type])) for t_id in tariff_ids)) for r_type in r_types)
result = dict((r_type, dict((res, defaultdict(lambda: 0)) for res in type_resources_map[r_type])) for r_type in r_types)
for ru in relevant_usages:
quantity = isinstance(ru.duration_or_quantity, datetime.timedelta) and \
(((ru.duration_or_quantity.days * 24 * 60 * 60) + ru.duration_or_quantity.seconds) / 60 *60) or ru.duration_or_quantity
try:
result[ru.resource.type][ru.resource.name][ru.tariffID] += quantity
except KeyError:
applogger.warn("get_usage_by_tariff: %s not found in %s" % (ru.resource.name, str(result[ru.resource.type].keys())))
return result
def get_tariff(loc, userid, usage_start_time, default=True):
result = Resource.select(AND(RUsage.q.resourceID == Resource.q.id,
Resource.q.type=='tariff',
RUsage.q.cancelled==0,
RUsage.q.userID==userid,
Resource.q.placeID==loc,
RUsage.q.start <= usage_start_time,
RUsage.q.end_time >= usage_start_time))
try:
return result[0]
except:
if default:
return Location.get(loc).defaulttariff
return None
def validate_python(self, field_dict, state):
from hubspace.controllers import unavailable_for_booking
resource = Resource.get(field_dict['resource_id'])
resourceid = resource.id
if not resource.time_based:
return
if 'start' in field_dict:
start = field_dict['start']
start_time = time(int(start['hour']), int(start['minute']))
date = dateconverter.to_python(field_dict['date'])
start = datetime.combine(date, start_time)
elif 'start_datetime' in field_dict:
start = datetimeconverter.to_python(field_dict['start_datetime'])
else:
start = now(resource.place)
if 'end' in field_dict:
end = field_dict['end']
end_time = time(int(end['hour']), int(end['minute']))
date = dateconverter.to_python(field_dict['date'])
end = datetime.combine(date, end_time)
elif 'end_datetime' in field_dict:
end = datetimeconverter.to_python(field_dict['end_datetime'])
else:
end = start + timedelta(minutes=15)
errors = {}
rusage = None
if 'id' in field_dict:
rusage = field_dict['id']
booking_conflicts = unavailable_for_booking(resourceid, start, end, rusage)
dfp = datetimeconverter.from_python
if booking_conflicts.count():
conflict = booking_conflicts[0]
if resource == conflict.resource:
errors['start'] = escape(resource.name) + " cannot be booked from " + dfp(start) + " to "+ dfp(end) + " since it is booked from " + dfp(conflict.start) + " to " + dfp(conflict.end_time)
else:
errors['start'] = escape(resource.name) + " cannot be booked from " + dfp(start) + " to "+ dfp(end) + " since it requires " + escape(conflict.resource.name)+ " which is booked from " + dfp(conflict.start) + " to " + dfp(conflict.end_time)
raise Invalid('Booking Conflicts', field_dict, state, error_dict=errors)
def validate_python(self, field_dict, state):
resource = Resource.get(field_dict['resource_id'])
if not resource.time_based:
return
if 'start' in field_dict and field_dict['start']:
start = field_dict['start']
start_time = time(int(start['hour']), int(start['minute']))
date = dateconverter.to_python(field_dict['date'])
start = datetime.combine(date, start_time)
elif 'start_datetime' in field_dict and field_dict['start_datetime']:
start = datetimeconverter.to_python(field_dict['start_datetime'])
else:
start = now(resource.place)
if field_dict.get("tentative"):
if (start - now()) < timedelta(2):
errors = {}
err = _("A tentative booking should be made at least %s hours in advance!") % bookinglib.t_booking_life_hrs
errors['tentative'] = err
errors['date'] = err
raise Invalid(err, field_dict, state, error_dict=errors)
def get_revenue_by_resource(self):
grouped = sortAndGrpby(self.usages, lambda x: (x.resourceID))
return tuple((Resource.get(r_id).name, float(sum(ru.effectivecost for ru in usages))) for (r_id, usages) in grouped)
def get_revenue_by_tariff(self):
grouped = sortAndGrpby(self.usages, lambda x: x.tariffID)
return ((Resource.get(t_id).name, float(sum(ru.effectivecost for ru in usages))) for t_id, usages in grouped)
def _get_tariff(self):
return Resource.get(self.tariffID)
def _get_resource(self):
return Resource.get(self.resourceID)
