def create(self, request, *args, **kwargs):
owner = is_user_a_owner(request=self.request, raise_exception=True)
self.house = get_object_or_404(House,
pk=self.kwargs.get('pk'),
owner=owner)
return super(OwnerHousePictureListCreateView,
self).create(request, *args, **kwargs)
def get_queryset(self):
owner = is_user_a_owner(self.request, raise_exception=False)
if owner:
return TenantMeal.objects.filter(house__owner=owner)
tenant = is_user_a_tenant(self.request, raise_exception=False)
if tenant:
return TenantMeal.objects.filter(house=tenant.current_booking.space.house)
def get_object(self):
owner = is_user_a_owner(self.request, raise_exception=True)
tenant = get_object_or_404(Tenant, pk=self.kwargs.get('pk'))
try:
if tenant.current_booking.space.house.owner == owner:
return tenant
except:
raise Http404({'detail': "Tenant does not have any booking in your house"})
def create(self, request, *args, **kwargs):
owner = is_user_a_owner(request, raise_exception=True)
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer=serializer, owner=owner)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data,
status=status.HTTP_201_CREATED,
headers=headers)
def create(self, request, *args, **kwargs):
self.owner = is_user_a_owner(request, raise_exception=True)
if 'tenants' in request.data:
tenant_group, _ = create_tenant_group(request.data.copy(),
self.owner)
request.data['tenant_group'] = tenant_group.pk
return super(HouseBillListCreateView,
self).create(request, *args, **kwargs)
def create(self, request, *args, **kwargs):
# check for all required fields
required = ('name', )
if not all(request.data.get(field) for field in required):
return Response({"error": "Incomplete fields provided!"},
status=status.HTTP_400_BAD_REQUEST)
self.owner = is_user_a_owner(request, raise_exception=True)
return super(OwnerHouseListCreateView,
self).create(request, *args, **kwargs)
def has_permission(self, request, view):
if not request.user.is_authenticated:
return False
owner = is_user_a_owner(request, raise_exception=False)
# print("owner is ", owner)
if owner:
return True
else:
return False
def get_queryset(self):
# returns all the check-ins of every current booking of spaces where space house owner = logged in owner
owner = is_user_a_owner(self.request, raise_exception=False)
if owner:
return TenantLateCheckin.objects.filter(current_booking__space__house__owner=owner)
# returns all the check-ins of logged in tenant
tenant = is_user_a_tenant(self.request, raise_exception=True)
if tenant:
return TenantLateCheckin.objects.filter(current_booking=tenant.current_booking)
def create(self, request, *args, **kwargs):
required = ['house', 'type', 'subtype']
if not all([request.data.get(field) for field in required]):
return Response({"error": "Incomplete fields provided!"},
status=status.HTTP_400_BAD_REQUEST)
self.owner = is_user_a_owner(self.request, raise_exception=True)
house = get_object_or_404(House,
id=request.data['house'],
owner=self.owner)
return super(HouseSpaceListCreateView,
self).create(request, *args, **kwargs)
def get_object(self):
house = get_object_or_404(House, id=self.kwargs.get("pk"))
self.owner = is_user_a_owner(self.request, raise_exception=True)
if house.managed_by is None and house.visible and house.owner == self.owner: # if managed by Halanx
return house
elif house.managed_by == self.owner == house.owner: # if user owns and manages the house
return house
# tenant = is_user_a_tenant(self.request, raise_exception=False)
# if tenant: # if user is a tenant and has booking with the space in the current house
# obj = get_object_or_404(Booking, tenant=tenant, space__in=house.spaces.all())
# from utility.logging_utils import cwlogger
# cwlogger.info(dict(type=self.__class__.__name__, tenant=tenant.id, house=self.kwargs.get('pk')))
# return obj
raise Http404("Not found")
def get_queryset(self):
self.owner = is_user_a_owner(request=self.request,
raise_exception=True)
query_filter_params = {
'paid': 'paid',
'due_date__lte': 'due_date__lte',
'due_date__gte': 'due_date__gte',
'amount__lte': 'amount__lte',
'amount__gte': 'amount__gte'
}
extra_kwargs = get_filter_extra_kwargs(query_filter_params,
self.request)
house = get_object_or_404(House,
owner=self.owner,
pk=self.kwargs.get('pk'))
return Bill.objects.filter(owner=self.owner,
house=house,
**extra_kwargs)
def get_queryset(self):
owner = is_user_a_owner(self.request, raise_exception=True)
query_filter_params = {
'house_id': 'house',
'visited': 'visited',
'cancelled': 'cancelled'
}
extra_kwargs = get_filter_extra_kwargs(query_filter_params,
self.request)
# To get upcoming visits and past visits
if 'visit_type' in self.request.GET:
if self.request.GET['visit_type'] == 'upcoming':
extra_kwargs['scheduled_visit_time__gte'] = str(datetime.now())
elif self.request.GET['visit_type'] == 'past':
extra_kwargs['actual_visit_time__lte'] = str(datetime.now())
return HouseVisit.objects.filter(house__owner=owner, **extra_kwargs)
def create(self, request, *args, **kwargs):
owner = is_user_a_owner(request, raise_exception=True)
get_object_or_404(House, owner=owner, id=request.data['house'])
return super(TenantMealListCreateView, self).create(request, *args, **kwargs)
def get_queryset(self):
owner = is_user_a_owner(request=self.request, raise_exception=True)
house = get_object_or_404(House, pk=self.kwargs.get('pk'), owner=owner)
return HousePicture.objects.filter(house__owner=owner, house=house)
def get_serializer_context(self):
result = super(TeamMemberRetrieveUpdateDestroyView,
self).get_serializer_context()
result["owner"] = is_user_a_owner(self.request, raise_exception=True)
return result
def create_tenant_view(request):
"""
1. validation phone and space data
"""
owner = is_user_a_owner(request, raise_exception=True)
# Phone no, name, space, rent are mandatory
required = ('phone_no', 'space', 'rent', 'license_start_date')
if not all(request.data.get(field) for field in required):
return Response({'error': "Incomplete fields provided!"}, status=status.HTTP_400_BAD_REQUEST)
phone_no, space = validate_phone_no_space_and_free_beds(request=request, owner=owner) # validate phone_no and space
if request.data.get('name', None):
name = request.data['name']
else:
name = ''
# extract phone number
phone_no = re.sub(r'\+91|[-\s()]', '', request.data['phone_no'])
customer = is_customer_exist(phone_no)
if customer is None: # if No such customer exists create user
try:
user, created = User.objects.get_or_create(username="******".format(phone_no),
password="******".format(phone_no),
)
if created:
user.first_name = name
user.save()
except IntegrityError: # user already exists
user = User.objects.get(username="******".format(phone_no))
customer_create_data = dict(user=user, phone_no=phone_no, is_registered=False)
customer = Customer.objects.create(**customer_create_data)
tenant, created = Tenant.objects.get_or_create(customer=customer)
notification_message = ""
if created:
tenant_type_booking = NEW_TENANT_BOOKING
else:
tenant_type_booking = EXISTING_TENANT_BOOKING
if created and customer.is_registered: # New Tenant created and the customer is already registered on Halanx
notification_message = NEW_TENANT_REGISTERED_CUSTOMER
elif created and not customer.is_registered: # New Tenant created and the customer is not registered on Halanx
notification_message = NEW_TENANT_UNREGISTERED_CUSTOMER
elif not created:
if tenant.current_booking is not None:
raise ValidationError({'detail': "This tenant already has current booking"})
if tenant.customer.is_registered: # Tenant already exists
notification_message = EXISTING_TENANT_REGISTERED_CUSTOMER
if not tenant.customer.is_registered:
notification_message = EXISTING_TENANT_UNREGISTERED_CUSTOMER
send_notification_to_tenant(phone_no=phone_no, customer=customer, title=notification_message)
booking_creation_data = {
'space': space, 'tenant': tenant, 'type': tenant_type_booking, 'rent': request.data['rent'],
'license_start_date': request.data['license_start_date']
}
extra_fields = ('security_deposit', 'token_amount', 'onboarding_charges', 'paid_token_amount',
'paid_movein_charges', 'move_in_notes')
for field in extra_fields:
if request.data.get(field, None):
booking_creation_data[field] = request.data.get(field)
Booking.objects.create(**booking_creation_data)
tenant_data = TenantDetailSerializer(tenant, display_fields=['id', 'customer']).data
response_data = {
'status': 'success',
'data': tenant_data
}
return Response(response_data, status=status.HTTP_201_CREATED)
def get_queryset(self):
owner = is_user_a_owner(request=self.request, raise_exception=True)
return Tenant.objects.filter(bookings__space__house__owner=owner)
def get_object(self):
self.owner = is_user_a_owner(self.request, raise_exception=True)
space = get_object_or_404(Space,
pk=self.kwargs.get("pk"),
house__owner=self.owner)
return space
def create_bill_split(request, pk):
"""
{
'bill_split' :
{
'data_format' : {
'distribution_type': 'amount', # or 'ratio'
'tenants': [
{
'id': 1,
'value': 1000 # or 0.4
},
{
'id': 2,
'value': 1500 # or 0.6
}
]
}
}
"""
owner = is_user_a_owner(request, raise_exception=True)
bill = get_object_or_404(Bill, pk=pk, owner=owner)
data_format = request.data['bill_split']['data_format']
value_sum = 0
tenants = []
for tenant in data_format['tenants']:
try:
obj = get_object_or_404(Tenant, pk=tenant['id'])
tenants.append(obj)
# Check if tenant has any booked space in owners house
raise_exception = True
try:
if obj.current_booking.space.house.owner == owner:
raise_exception = False
except Exception as E:
print(E)
finally:
if raise_exception:
raise ValidationError({
'detail':
"This Tenant is not currently booked in any of your house space"
})
value_sum += validate_single_amount_or_ratio_value(
bill=bill,
distribution_type=data_format['distribution_type'],
value=tenant['value'])
if data_format['distribution_type'] == DISTRIBUTION_TYPE_AMOUNT:
tenant['bill_contribution'] = tenant['value']
elif data_format['distribution_type'] == DISTRIBUTION_TYPE_RATIO:
tenant['bill_contribution'] = tenant['value'] * bill.amount
except Http404:
raise ValidationError({'detail': 'Not found'})
if data_format['distribution_type'] == DISTRIBUTION_TYPE_AMOUNT:
if value_sum != bill.amount:
raise ValidationError(
{'detail': "Sum must be equal to {}".format(bill.amount)})
elif data_format['distribution_type'] == DISTRIBUTION_TYPE_RATIO:
if value_sum != 1:
raise ValidationError({'detail': "Ratio Sum must be equal to 1"})
bill_split_instance_list = []
if len(set(tenants)) < len(tenants):
raise ValidationError({'detail': "Duplicate Tenant Found"})
if set(bill.tenant_group.tenants.all()) != set(tenants):
raise ValidationError({'detail': 'Tenants Mismatched'})
for tenant in data_format['tenants']:
bill_split_instance = BillSplit.objects.create(
tenant=Tenant.objects.get(pk=tenant['id']),
bill=bill,
amount=tenant['bill_contribution'],
due_date=bill.due_date)
bill_split_instance_list.append(bill_split_instance)
bill_split_serializer = BillSplitSerializer(bill_split_instance_list,
many=True)
return Response(bill_split_serializer.data, status=status.HTTP_201_CREATED)
def get_object(self):
return get_object_or_404(TeamMember,
pk=self.kwargs.get("pk"),
owner=is_user_a_owner(self.request,
raise_exception=True))
def get_queryset(self):
return Vendor.objects.filter(
owner=is_user_a_owner(self.request, raise_exception=True))
def get(self, request, *args, **kwargs):
self.owner = is_user_a_owner(request=request, raise_exception=True)
if self.owner:
tenant = get_object_or_404(Tenant, pk=request.query_params['tenant'])
return Response(self.get_serializer(tenant).data, status=status.HTTP_200_OK)
def get_serializer_context(self):
result = super(VendorListCreateView, self).get_serializer_context()
result["owner"] = is_user_a_owner(self.request, raise_exception=True)
return result
def get_queryset(self):
owner = is_user_a_owner(request=self.request, raise_exception=True)
return Bill.objects.filter(owner=owner)
def create_tenant_group_view(request):
owner = is_user_a_owner(request, raise_exception=True)
instance, tenant_group_serializer = create_tenant_group(
request.data.copy(), owner)
return Response(tenant_group_serializer.data,
status=status.HTTP_201_CREATED)
def get_object(self):
self.owner = is_user_a_owner(self.request, raise_exception=True)
return get_object_or_404(Vendor,
pk=self.kwargs.get("pk"),
owner=self.owner)
def get_queryset(self):
owner = is_user_a_owner(self.request, raise_exception=True)
query_filter_params = {'type': 'type'}
extra_kwargs = get_filter_extra_kwargs(query_filter_params,
self.request)
return Space.objects.filter(house__owner=owner, **extra_kwargs)
def get_serializer_context(self):
result = super(TeamMemberListCreateView, self).get_serializer_context()
result['owner'] = is_user_a_owner(self.request, raise_exception=True)
return result
