Activité pratique 1

# With Floor class
rdc = Floor(0, "rdc")
etage4 = Floor (4, "etage4")
ascenseur_bibliotheque = Elevator(rdc)
ascenseur_bibliotheque.close_doors()
ascenseur_bibliotheque.go_to(etage4)

# Without Floor class
asascenseur_bibliotheque = Elevator(0)
ascenseur_bibliotheque.close_doors()
ascenseur_bibliotheque.go_to(4)

# Create the bank
cmb = Bank("Credit Mutuel")
# Create the client
client1 = Client("Dupond", "Louis")
# Open a new account in the bank for the client
compte1 = cmb.open_account(client1)
# Credit some euros into the new account
cmb.credit(compte1, 100)

CLASS Bank() :
	# Attributes of the class
	PRIVATE ATTRIBUTE name: str
	PRIVATE ATTRIBUTE accounts: [Account]

	# The constructor initializes attributs
	CONSTRUCT Bank(name: str) :
		self.name = name
		self.accounts = []

	# Open an account = create the new account and
	# add it to the list of accounts of the bank
	METHOD open_account(client: Client) -> Account:
		account = Account(client)
		self.accounts.append(account)
		return account

CLASS Account:
	# Attributes of the class
	PRIVATE ATTRIBUTE client: Client
	PRIVATE ATTRIBUTE balance: float
	PRIVATE ATTRIBUTE transactions: [Transaction]

	# The constructor initializes attributs
	CONSTRUCT Account(client: Client) :
		self.client = client
		self.balance = 0
		self.transactions = []

	# Compute the new balance and
	# add the transaction to the list of transactions of the account
	METHOD credit(amount: float) -> float:
		self.balance += amount
		tx1 = Transaction(now, montant, "CREDIT")
		self.transactions.append(tx1)
		return self.balance

	# Compute the new balance and
	# add the transaction to the list of transactions of the account
	METHOD debit(amount: float) -> float:
		if self.balance - amount > 0 :
			self.balance -= amount
			tx1 = Transaction(now, amount, "DEBIT")
			self.transactions.append(tx1)
		return self.balance

CLASS Account:
	# Attributes of the class
	PRIVATE ATTRIBUTE client: Client
	PRIVATE ATTRIBUTE balance: float
	PRIVATE ATTRIBUTE transactions: [Transaction]

	# The constructor initializes attributs
	CONSTRUCT Account(client: Client) :
		self.client = client
		self.balance = 0
		self.transactions = []

	# Compute the new balance and
	# add the transaction to the list of transactions of the account
	METHOD credit(amount: float) -> float:
		if amount > 0:
			self.balance += montant
			tx1 = Transaction(now, montant, "CREDIT")
			self.transactions.append(tx1)
		return self.balance


	# Compute the new balance and
	# add the transaction to the list of transactions of the account
	METHOD debit(amount: float) -> float :
		if amount > 0:
			if self.balance - amount > 0 :
				self.balance -= amount
				tx1 = Transaction(now, amount, "DEBIT")
				self.transactions.append(tx1)
		return self.balance

CLASS YoungAccount(Account) :
	PRIVATE ATTRIBUTE opened: Date

	CONSTRUCT YoungAccount(client: Client) :
		self.client = client
		self.balance = 500
		self.opened = now
		self.transactions = []

	METHOD debit(amount: float) -> float:
		if now < self.opened + 10 :
			if self.balance - amount > 0 :
				self.balance -= amount
				tx1 = Transaction(now, amount, "DEBIT")
				self.transactions.append(tx1)
		return self.balance


CLASS Bank() :

	METHOD open_young_account(client: Client) --> YoungAccount :
		account = YoungAccount(client)
		self.accounts.append(account)
		return account

# Create the hospital
cavale = Hospital("Cavale Blanche")
# Create the patient
patient1 = cavale.new_patient("Dupond", "Louis", Date("2002-12-10"), "Male")
# Create the medical act
medical_act = Diagnose(Date("2025/07/08"), "Mme Sabre", "Zona", 90)
cavale.new_medical_act(patient1, medical_act)

CLASS Hospital() :
	ATTRIBUTE name: str
	ATTRIBUTE patients: [Patient]

	CONSTRUCT (name: str) :
		self.name = name
		self.patients = []

	METHOD new_patient (lastname: str, firstname: str, birthday: Date, gender: str) :
		patient = Patient(lastname, firstname, birthday, gender)
		self.patients.append(patient)
		return patient

	METHOD new_medical_act(patient: Patient, act: MedicalAct):
		# Search the patient in the patients list
		if not patient in self.patients:
			return None
		the_patient = self.patients.search(patient)

		the_patient.new_medical_act(act)

	METHOD consult_patient(patient: Patient):
		# Search the patient in the patients list
		if not patient in self.patients:
			return None
		the_patient = self.patients.search(patient)
		return the_patient.get_medical_history()

CLASS Patient:
	lastname: str
	firstname: str
	birthday: Date
	gender: str
	medical_history:[MedicalAct]

	CONSTRUCT (lastname: str, firstname: str, birthday: Date, gender: str):
		self.lastname = lastname
		self.firstname = firstname
		self.birthday = birthday
		self.gender = gender
		self.medical_history = []

	METHOD new_medical_act(act: MedicalAct):
		self.medical_history.append(act)

	METHOD get_medical_history():
		return medical_history

CLASS MedicalAct :
	date: Date
	caregiver: str

	METHOD constructor(date: Date, caregiver: str) :
		self.date = date
		self.caregiver = caregiver

CLASS Diagnose(MedicalAct) :
	disease: str
	validity: int

	CONSTRUCT (date: Date, caregiver: str, disease: str, validity: int) :
		super(date, caregiver)
		self.disease = disease
		self.validity = validity

class Care(MedicalAct) :
	improvement: int

	CONSTRUCT (date: Date, caregiver: str, improvement: int) :
		super(date, caregiver)
		self.disease = disease
		self.improvement = improvement