class Controller(object):
def __init__(self):
self.view = View()
self.item_controller = ItemController()
def handle_input(self, input, id):
try:
input_action = input[0]
input_number = input[1:]
except IndexError:
self.view.show_invalid_input()
return
if (input_action == "Q"):
sys.exit()
elif (input_action == "S" and input_number.isdigit()):
response = self.item_controller.remove_units(id, input_number)
self.view.item_units_has_changed(response)
elif (input_action == "I" and input_number.isdigit()):
response = self.item_controller.add_units(id, input_number)
self.view.item_units_has_changed(response)
elif (input_action == "L" and not input_number):
response = self.item_controller.get_item_by_id(id)
self.view.show_item_information(response)
else:
self.view.show_invalid_input()
class ControllerHotel:
def __init__(self):
self.view = View()
def start(self):
dados = self.view.start()
quartos = self.busca(dados['cidade'], dados['tipo'], dados['preço'])
quarto = self.view.mostrar_quartos(quartos)
self.reservar(quarto)
def busca(self, cidade, tipo, preço=None, r=None, d=None, p=None):
result = []
if r:
Hotel.instances.sort(key=lambda h: float(h.recomendacao),
reverse=True)
if d:
Hotel.instances.sort(key=lambda h: float(h.dist_centro),
reverse=False)
for hotel in Hotel.instances:
if hotel.cidade == cidade:
quartos = hotel.get_quartos(tipo, preço)
quartos.sort(key=lambda q: float(q.preço), reverse=False)
for quarto in quartos:
result.append(quarto)
return result
def reservar(self, quarto):
modos = {1: Boleto, 2: CartaoCredito}
dados = self.view.fazer_reserva()
r = Reserva(dados['cliente'], dados['entrada'], dados['saida'], quarto)
modo = dados['modo']
r.modo_pagamento = modos[modo]()
r.realizar_pagamento(quarto.preço)
self.view.mostrar_reservas(Reserva.instances)
def __init__(self):
self.view = View(controller=self)
self.parser = Parser
self.initial_filenames = list()
self.initial_filepath = list()
self.changed_filenames = list()
self.replace_filename = list()
def status():
data = ParkingLot.read()
message = ""
for i in data:
if (i.plate_number == ""):
continue
message = message + f"{i.slot_number} {i.plate_number} \r\n"
View.status(message)
def __init__(self, sys_argv):
super(App, self).__init__(sys_argv)
self.model = Model()
self.controller = Controller(self.model)
self.view = View(self.model, self.controller)
self.view.show()
# self.view.showFullScreen()
self.view.setWindowTitle("App")
def leave(plate_number, hours):
result = ParkingLot.leave(plate_number, hours)
if result == False:
View.not_found(plate_number)
else:
charge = result["charge"]
slot_number = result["ParkingLot"].slot_number
# print(plate_number)
View.leave(slot_number, plate_number, charge)
def setUp(self):
'''Create the model, controller & GUI'''
self.current_version = '4.4.1'
self.model = Model()
self.controller = Controller(self.model)
self.controller.scanner_thread.close(
) # getting PermissionError when left open while testing - Mock it instead
self.view = View(self.model, self.controller)
def __init__(self, controller):
super().__init__(controller)
self.__model = Model(800, 400, 10)
self.__view = View('View', self.__model)
self.__model.add_observer(self.__view)
controller.model = self.__model
controller.view = self.__view
def create_view(map):
"""Create a view object.
This function is a factory method: its create a view object depending on
GRAPH_LIB constant in settings.py.
Args:
map: a Map object reprensenting the labyrinth.
Exceptions:
ValueError if the value of GRAPH_LIB is not manage
Returns:
View object in charge of the display.
"""
if GRAPH_LIB == "pygame":
view = View(map)
else:
raise ValueError(f'Cannot create a view from {GRAPH_LIB}')
return view
def main():
view = View()
def __init__(self):
self.view = View()
self.item_controller = ItemController()
class MultipleRenaming:
"""Class Multiple Renaming."""
def __init__(self):
self.view = View(controller=self)
self.parser = Parser
self.initial_filenames = list()
self.initial_filepath = list()
self.changed_filenames = list()
self.replace_filename = list()
def open_filenames(self):
"""Open files and display the number in the status bar."""
self.initial_filepath = askopenfilenames()
self.initial_filenames = list()
for basename in self.initial_filepath:
self.initial_filenames.append(basename)
self.changed_filenames = self.initial_filenames[:]
self.replace_filename = self.initial_filenames[:]
self.view.statusbar.var_nbfiles.set(len(self.initial_filenames))
self.populate_treeview()
def populate_treeview(self, argument=None):
"""Parse filenames and send to view.display_treeview."""
data = list()
for initial, changed in zip(self.initial_filenames,
self.changed_filenames):
date_creation = datetime.fromtimestamp(os.path.getmtime(initial))
date_modified = datetime.fromtimestamp(os.path.getctime(initial))
new_name, ext = os.path.splitext(os.path.basename(changed))
name_modified = arguments_parsing(argument, new_name, ext)
_data = dict()
_data["old_name"] = os.path.basename(initial)
_data["new_name"] = name_modified
_data["size"] = get_human_readable_size(os.path.getsize(initial))
_data["created_at"] = datetime.strftime(date_creation,
"%Y/%m/%d %H:%M:%S")
_data["modified_at"] = datetime.strftime(date_modified,
"%Y/%m/%d %H:%M:%S")
_data["location"] = os.path.abspath(initial)
data.append(_data)
self.view.display_treeview(data)
def input_filename(self, P):
"""Check the content of the input widget to verify that it is valid
with the rules of the application.
Arguments:
- P (str): Value of the entry if the edit is allowed
Returns:
- str: Output text processed by application rules
"""
user_input = P
date_format, alert = self.view.get_format_date()
if alert:
self.view.statusbar.var_alert.set(alert)
self.view.statusbar.update()
else:
self.view.statusbar.var_alert.set("")
counter = int(self.view.params.start_sbox.get())
step = int(self.view.params.step_sbox.get())
digits = self.view.params.digits_sbox.get()
if sys.platform == "win32":
self.view.check_valid_characters_filename(user_input)
for index, initial in enumerate(self.initial_filenames):
dirname, filename = os.path.split(initial)
filename, ext = os.path.splitext(filename)
self.parser = Parser(self.changed_filenames, user_input, filename,
dirname)
# Name [n]
temp_input = self.parser.name_n(ext, index)
# Name from first character [nX]
temp_input = self.parser.name_truncate_x(temp_input, ext, index)
# Name from last character [n-X]
temp_input = self.parser.name_last_x(temp_input, ext, index)
# Name from n character [n,X]
temp_input = self.parser.name_start_x(temp_input, ext, index)
# Add counter
temp_input = self.parser.add_counter(temp_input, digits, counter,
ext, index)
counter += step
# Add date
try:
temp_input = self.parser.add_date(temp_input, date_format, ext,
index)
except TypeError:
pass
self.replace_filename = self.changed_filenames[:]
self.populate_treeview(self.replace_filename)
return True
def search_and_replace(self, event):
"""Search and replace function.
Arguments:
- event (dict): Bind event.
"""
search_expr = self.view.params.find_entry.get()
replace_expr = self.view.params.replace_entry.get()
if sys.platform == "win32":
self.view.check_valid_characters_filename(replace_expr)
if len(search_expr) > 0:
self.changed_filenames = self.replace_filename[:]
for index, word in enumerate(self.replace_filename):
_dirname = os.path.dirname(word)
_basename = os.path.basename(word)
if search_expr in word:
self.changed_filenames[index] = os.path.join(
_dirname, _basename.replace(search_expr, replace_expr))
else:
self.changed_filenames = self.replace_filename[:]
self.populate_treeview(self.changed_filenames)
def rename(self):
"""Execute file renaming."""
for index, (initial, modified) in enumerate(
zip(self.initial_filenames, self.changed_filenames)):
dirname = os.path.dirname(initial)
basename_initial = os.path.basename(initial)
extension_initial = os.path.splitext(basename_initial)[1]
for key, value in self.view.arguments_dict.items():
if self.view.params.arguments_cbox.get() in value:
arg_key = key
# Apply argument options
modified = arguments_parsing(arg_key,
os.path.splitext(modified)[0],
extension_initial)
os.rename(initial, os.path.join(dirname, modified))
# Convert tuple to list.
self.initial_filenames = list(self.initial_filenames)
# Update renamed file
self.initial_filenames[index] = os.path.join(dirname, modified)
self.populate_treeview()
self.view.params.filename_entry.focus()
if self.view.params.close_var.get():
sys.exit()
def __init__(self) -> None:
View.__init__(self, [SettingsArtist()])
def __init__(self) -> None:
View.__init__(self, [CombatArtist()])
from controllers.controller import Controller
from views.view import View
from models.model import Model
model=Model("ecole","postgres","as122014","localhost","5432")
view=View(model)
controller=Controller(model,view)
if __name__ == "__main__":
controller.dispatcher()
def create_parking_lot(capacity):
ParkingLot.create(capacity)
View.create_parking_lot(capacity)
def park(plate_number):
allocated_slot_number = ParkingLot.park(plate_number)
if allocated_slot_number == 0:
View.full()
else:
View.park(allocated_slot_number)
def __init__(self):
self.view = View()
