In this assignment, you will design various classes and write a program for calculating how much a

property agent might earn in a year through selling properties.

a. Create a Property class with an address, 6 digit postal code number, tenure, completion year,
property type, area, commission rate and valuation. Add appropriate constructors and member
functions to initialize, access, and manipulate the data members. Commission rate is default to 1%.

class Property:
def __init__(self, address, postal_code, tenure, completion_year,
property_type, area, valuation, commission_rate=1.0):

"""Initializes a Property object with the given parameters."""

self.address = address
self.postal_code = postal_code
self.tenure = tenure
self.completion_year = completion_year
self.property_type = property_type
self.area = area
self.valuation = valuation
self.commission_rate = commission_rate

def calculate_commission(self, sale_price):

""" Calculates the commission based on the sale price."""

return sale_price * (self.commission_rate / 100)

def __str__(self):

"""Returns a string representation of the Property object."""

return (f"Property at {self.address}, {self.postal_code}
({self.property_type}) "
f"completed in {self.completion_year}, {self.tenure}
tenure, area: {self.area}"
f" sqm, valuation: ${self.valuation:.2f}")

b. Design the class CommercialProperty, that extends from the class Property, with an additional data
member to store the commercial property type (for office, flatted factory, factory). Add appropriate
constructors and member functions to initialize, access, and manipulate the data members.

from property import Property

class CommercialProperty(Property):
def __init__(self, address, postal_code, tenure, completion_year,
property_type, area, valuation, commercial_type, commission_rate=1.0):
"""
Initializes a CommercialProperty object by extending the Property
class.
Args:
commercial_type (str): The commercial property type (e.g.,
office, flatted factory, factory).
"""
super().__init__(address, postal_code, tenure, completion_year,
property_type, area, valuation, commission_rate)
self.commercial_type = commercial_type

def __str__(self):
"""
Returns a string representation of the CommercialProperty object.
"""
return super().__str__() + f", commercial type:
{self.commercial_type}"

class PropertyAgent:
def __init__(self, company, agent_registration_number, start_year):
self.company = company
self.agent_registration_number = agent_registration_number
self.start_year = start_year
self.properties_not_sold = [] # List of properties not yet sold
self.properties_sold = [] # List of properties sold
self.commission_rate = 0.7 # Default commission sharing rate (70%)

def add_property(self, property_info, sold=False):

"""Add a property to the agent's list (either sold or unsold)."""

if sold:
self.properties_sold.append(property_info)
else:
self.properties_not_sold.append(property_info)
 def calculate_commission(self, sale_price):
"""
Calculate the agent's commission based on the sale price and
commission rate.
:param sale_price: Price at which the property was sold
:return: Commission amount
"""
return sale_price * self.commission_rate

c. Create a PropertyAgent class that holds 2 list of properties. One list of properties held are the ones
that the property agent has not sold, while another list of properties holds the properties sold by the
agent during the year. The PropertyAgent would also have data members commission sharing rate
default to 70%, the company he worked for, his/her agent registration number and the year the agent
began working.

# class PropertyAgent:
# def __init__(self, company, agent_registration_number, start_year):
# self.company = company
# self.agent_registration_number = agent_registration_number
# self.start_year = start_year
# self.properties_not_sold = [] # List of properties not yet sold
# self.properties_sold = [] # List of properties sold
# self.commission_rate = 0.7 # Default commission sharing rate
(70%)
#
# def add_property(self, property_info, sold=False):
# """
# Add a property to the agent's list (either sold or unsold).
# :param property_info: Information about the property (e.g.,
address, price, etc.)
# :param sold: True if the property is sold, False if not sold
(default is False)
# """
# if sold:
# self.properties_sold.append(property_info)
# else:
# self.properties_not_sold.append(property_info)
#
# def calculate_commission(self, sale_price):
# """
# Calculate the agent's commission based on the sale price and
commission rate.
# :param sale_price: Price at which the property was sold
# :return: Commission amount
# """
# return sale_price * self.commission_rate

class PropertyAgent:
def __init__(self, company, agent_registration_number, start_year):
self.company = company
self.agent_registration_number = agent_registration_number
self.start_year = start_year
self.properties_sold = [] # List of sold properties
self.commission_rate = 0.03 # Default commission rate (3%)

def add_property(self, property, sold):

"""
Add a property to the agent's list of properties, indicating if
it's sold or unsold.
:param property: Property object
:param sold: Boolean indicating if the property is sold
"""
if sold:
self.properties_sold.append(property)

def calculate_commission(self, sale_price):

"""
Calculate the agent's commission based on the sale price and
commission rate.
:param sale_price: Price at which the property was sold
:return: Commission amount
"""
return sale_price * self.commission_rate

d. Design the class PropertyAgencyDirector that extends from the PropertyAgent class with an
additional data member default to 5% to a maximum of 15% of the commission earned by the agent
and a list of agents working under him/her. The commission sharing rate is now default to 75% and is
at maximum 90% of commissions earned.

from property_agent import PropertyAgent

class PropertyAgencyDirector(PropertyAgent):
def __init__(self, company, agent_registration_number, start_year):
super().__init__(company, agent_registration_number, start_year)
self.additional_commission_rate = 0.05 # Default additional
commission rate (5%)
self.max_additional_commission_rate = 0.15 # Maximum additional
commission rate (15%)
self.agents_working_under = [] # List of agents working under the
director
self.commission_sharing_rate = 0.75 # Default commission sharing
rate (75%)
self.max_commission_sharing_rate = 0.90 # Maximum commission
sharing rate (90%)

def add_agent(self, agent_info):

"""
Add an agent to the list of agents working under the director.
:param agent_info: PropertyAgent object
"""
self.agents_working_under.append(agent_info)

def calculate_commission(self, sale_price):

"""
Calculate the director's commission based on the sale price,
commission rate,
and additional commission rate.
:param sale_price: Price at which the property was sold
:return: Commission amount
"""
base_commission = super().calculate_commission(sale_price)
additional_commission = min(base_commission *
self.additional_commission_rate,
self.max_additional_commission_rate *
base_commission)
return base_commission + additional_commission

def calculate_director_commission(self, sale_price):

"""
Calculate the director's share of the commission from agents'
sales.
:param sale_price: Price at which the property was sold
:return: Director's commission amount
"""
agent_commission = super().calculate_commission(sale_price)
shared_commission = min(agent_commission *
self.commission_sharing_rate,
self.max_commission_sharing_rate *
agent_commission)
return shared_commission

e. Design the class CommissionSlip to calculate and display an agent’s commission earned for the
year based on the properties sold (based on the commission rate) multiplied by the commission
sharing rate. Eg. If the agent sold a property worth $1 million with commission rate of 1% and his
sharing rate is 70%, the commission earned will be $1,000,000 * 0.01 * 0.7 = $7,000. If the agent is a
Property Agent Director, then he/she will have overriding commission of his/her agents at the rate.
The commission slip shall therefore show the breakdown of commissions earned per property, the
commission sharing for each property, the total commission earned for the property agent. If the agent
is a directory, there will be the breakdown of the overriding income for each agent and the total
overriding income earned as well as the total income earned.

class CommissionSlip:
def __init__(self, agent_or_director):
self.agent_or_director = agent_or_director
self.sales = []

def add_property_sale(self, property, sale_price):

self.sales.append((property, sale_price))

def display_commission_slip(self):
print(f"Commission Slip for
{self.agent_or_director.agent_registration_number}")
print("=" * 30)
total_commission = 0
for property, sale_price in self.sales:
commission = sale_price * 0.03 # Assume 3% commission rate
total_commission += commission
print(f"Property: {property.address}, Sale Price: {sale_price},
Commission: {commission}")
 print(f"Total Commission: {total_commission}")
print("=" * 30)

f. Write a program to create at least 2 different directors with at least 3

different agents each. Each agent shall hold at least 5 properties that are
unsold and 3 to 10 properties sold per agent. Print the commission slip for
each agent and direct. from property import Property

def main():
directors = []
agents = []
properties = []

def create_directors(): # create directors

while True:
try:
num_directors = int(input("Enter the number of directors to
create: "))
break
except ValueError:
print("Invalid input. Please enter a valid number.")

for i in range(num_directors):
print(f"\nEntering details for director {i + 1}:")
company = input("Enter the director's company: ")
registration_number = input("Enter the director's registration
number: ")
while True:
try:
start_year = input("Enter the director's start year: ")
 if len(start_year) == 4 and start_year.isdigit():
start_year = int(start_year)
break
else:
raise ValueError
except ValueError:
print("Invalid input. Please enter a valid 4-digit
year.")

directors.append(PropertyAgencyDirector(company,
registration_number, start_year))
print("Directors created successfully!\n")

def create_agents():
while True:
try:
num_agents = int(input("Enter the number of agents to
create: "))
break
except ValueError:
print("Invalid input. Please enter a valid number.")

for i in range(num_agents):
print(f"\nEntering details for agent {i + 1}:")
company = input("Enter the agent's company: ")
registration_number = input("Enter the agent's registration
number: ")
while True:
try:
start_year = input("Enter the agent's start year: ")
if len(start_year) == 4 and start_year.isdigit():
start_year = int(start_year)
break
else:
raise ValueError
except ValueError:
print("Invalid input. Please enter a valid 4-digit
year.")

agents.append(PropertyAgent(company, registration_number,
start_year))
print("Agents created successfully!\n")

def create_properties():
 while True:
try:
num_properties = int(input("Enter the number of properties
to create: "))
break
except ValueError:
print("Invalid input. Please enter a valid number.")

for i in range(num_properties):
print(f"\nEntering details for property {i + 1}:")
while True:
address = input("Enter the property address: ")
if address.strip():
break
else:
print("Invalid input. Address cannot be empty.")

while True:
try:
postal_code = input("Enter the property postal code: ")
if len(postal_code) == 6 and postal_code.isdigit():
postal_code = int(postal_code)
break
else:
raise ValueError
except ValueError:
print("Invalid input. Please enter a valid 6-digit
postal code.")

tenure = input("Enter the property tenure (Freehold/Leasehold):

")
while True:
try:
completion_year = input("Enter the property completion
year: ")
if len(completion_year) == 4 and
completion_year.isdigit():
completion_year = int(completion_year)
break
else:
raise ValueError
except ValueError:
print("Invalid input. Please enter a valid 4-digit
year.")
 property_type = input("Enter the property type
(Residential/Commercial): ")
while True:
try:
area = float(input("Enter the property area in sqm: "))
break
except ValueError:
print("Invalid input. Please enter a valid area.")

while True:
try:
valuation = float(input("Enter the property valuation:
"))
break
except ValueError:
print("Invalid input. Please enter a valid valuation.")

properties.append(Property(address, postal_code, tenure,

completion_year, property_type, area, valuation))
print("Properties created successfully!\n")

def assign_properties_to_agents():
for agent in agents:
while True:
try:
num_unsold = int(input(
f"Enter the number of unsold properties to assign
to agent {agent.agent_registration_number}: "))
if 0 <= num_unsold <= len(properties):
break
else:
raise ValueError
except ValueError:
print("Invalid input. Please enter a valid number
within the range.")

for _ in range(num_unsold):
while True:
try:
property_index = int(
input(f"Enter the property index (0 to
{len(properties) - 1}) to assign: "))
if 0 <= property_index < len(properties):
 break
else:
print(f"Invalid index. Please enter a number
between 0 and {len(properties) - 1}.")
except ValueError:
print("Invalid input. Please enter a valid
number.")
agent.add_property(properties[property_index], sold=False)

while True:
try:
num_sold = int(input(
f"Enter the number of sold properties to assign to
agent {agent.agent_registration_number}: "))
if 0 <= num_sold <= len(properties):
break
else:
raise ValueError
except ValueError:
print("Invalid input. Please enter a valid number
within the range.")

for _ in range(num_sold):
while True:
try:
property_index = int(
input(f"Enter the property index (0 to
{len(properties) - 1}) to assign: "))
if 0 <= property_index < len(properties):
break
else:
print(f"Invalid index. Please enter a number
between 0 and {len(properties) - 1}.")
except ValueError:
print("Invalid input. Please enter a valid
number.")
agent.add_property(properties[property_index], sold=True)

def assign_agents_to_directors():
for director in directors:
while True:
try:
num_agents = int(input(
f"Enter the number of agents to assign to director
{director.agent_registration_number}: "))
if 0 <= num_agents <= len(agents):
break
else:
raise ValueError
except ValueError:
print("Invalid input. Please enter a valid number
within the range.")

for _ in range(num_agents):
while True:
try:
agent_index = int(input(f"Enter the agent index (0
to {len(agents) - 1}) to assign: "))
if 0 <= agent_index < len(agents):
break
else:
print(f"Invalid index. Please enter a number
between 0 and {len(agents) - 1}.")
except ValueError:
print("Invalid input. Please enter a valid
number.")
director.add_agent(agents[agent_index])

create_directors()
create_agents()
create_properties()
assign_properties_to_agents()
assign_agents_to_directors()

def display_commission_slip(slip, entity):

print("=" * 40)
print(f"Commission Slip for {entity.agent_registration_number}")
print(f"Name: {entity.company}")
print(f"Start Year: {entity.start_year}")
print("-" * 40)
for sale in slip.sales:
print(f"Property Address: {sale['property'].address}")
print(f"Sale Price: ${sale['sale_price']:.2f}")
print(f"Commission Earned: ${sale['commission']:.2f}")
print("-" * 40)
print(f"Total Commission: ${slip.total_commission:.2f}")
print("=" * 40)
 for director in directors:
print(f"Creating commission slip for director
{director.agent_registration_number}")
slip = CommissionSlip(director)
for agent in director.agents_working_under:
for prop in agent.properties_sold:
slip.add_property_sale(prop, prop.valuation)
display_commission_slip(slip, director)
print("\n")

for agent in agents:

print(f"Creating commission slip for agent
{agent.agent_registration_number}")
slip = CommissionSlip(agent)
for prop in agent.properties_sold:
slip.add_property_sale(prop, prop.valuation)
display_commission_slip(slip, agent)
print("\n")

if __name__ == "__main__":
main()