API tools faq
paste
Advertisement
ALEXANDAR_GEORGIEV

mz_import_form

ALEXANDAR_GEORGIEV
Jan 14th, 2023 (edited)
95
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 39.36 KB | Source Code | 0 0
raw download clone embed print report
  1. from tkinter import *
  2. from widget_factory import *
  3. from mapped_acc_calculations import *
  4. from json_file_io import JsonFileIo
  5. from Opiti.from_excel.classes.global_inc import registry
  6.  
  7.  
  8. class StockInventory(Tk):
  9.     def __init__(self):
  10.         Tk.__init__(self)
  11.         self.account_tree = AccountTree()
  12.         self.widget_factory = WidgetsFactory()
  13.         self.excel_acc_data = ExcelAccData()
  14.         self.mapped_calculations = MappedCalculations()
  15.         self.excel_acc_data.convert_json_data()
  16.         self.acc_data_bycode = self.excel_acc_data.get_acc_data_bycode()
  17.         self.min_top_group_digits = self.excel_acc_data.get_min_top_group_digits()
  18.         self.max_top_group_digits = self.excel_acc_data.get_max_top_group_digits()
  19.         self.max_groups = self.excel_acc_data.get_max_groups()
  20.  
  21.         json_file_io = JsonFileIo(file_name=registry["mapped_account_file_name"])
  22.         acc_data_mapped = json_file_io.read_content()  # {"121": ["СК"], "121-13": ["СК"], "121-14": ["СК"],
  23.         if acc_data_mapped is None:
  24.             print("?? acc_data_mapped is NONE!!!")
  25.         self.acc_data_mapped_da = {}  # Речник с маркираните сметки с вид 'ДА'
  26.         for acc_code in self.acc_data_bycode:
  27.             self.account_tree.add_code(acc_code)  # Захранваме наследственото дърво
  28.         self.acc_data = []
  29.         self.max_depth_rx = 0
  30.         for acc_code in acc_data_mapped:
  31.             acc_types = acc_data_mapped[acc_code]
  32.             # TODO -> 'МЗ' и 'Рх' ако Рх имат Дебитно НС или КС !!!!
  33.             if 'МЗ' in acc_types and len(acc_types) == 1:
  34.                 self.acc_data_mapped_da[acc_code] = acc_data_mapped[acc_code]
  35.                 depth = self.account_tree.get_depth(acc_code)
  36.                 if depth > self.max_depth_rx:
  37.                     self.max_depth_rx = depth
  38.         for acc_code in self.acc_data_bycode:
  39.             if acc_code in self.acc_data_mapped_da:
  40.                 acc_row = self.acc_data_bycode[acc_code]
  41.                 self.acc_data.append(acc_row)
  42.         # -----------------------
  43.         self.acc_rec_mz = {
  44.             'mat': {'ns': 0, 'ks': 0, 'assets': []},
  45.             'st': {'ns': 0, 'ks': 0, 'assets': []},
  46.             'prod': {'ns': 0, 'ks': 0, 'assets': []},
  47.             'nezpr': {'ns': 0, 'ks': 0, 'assets': []},
  48.             'mzadv': {'ns': 0, 'ks': 0, 'assets': []},
  49.             'prod_diff': {'ns': 0, 'ks': 0},
  50.             'nezpr_diff': {'ns': 0, 'ks': 0},
  51.             'total_diff': {'ns': 0, 'ks': 0},
  52.             }
  53.         # -------------------------
  54.         self.last_entry = Entry()  # Четене на Entry code
  55.         self.acc_data = []
  56.         self.scr_bar = None
  57.         self.term = None
  58.         self.all_accounts = []
  59.         self.list_unadded_accs = []
  60.         self.unadded_spin = ''
  61.         self.selected_accs = []  # Данните, които трябва да се запишат във файл за да се маркират сметките в Treeview
  62.         self.dict_entries = {}  # Списък с Ентритата на Активите
  63.         self.get_sums = {}
  64.         self.get_total = {'total': {'od': 0.0, 'oc': 0.0, 'td': 0.0, 'tc': 0.0, 'cd': 0.0, 'cc': 0.0}}
  65.         self.pop_message_answer = ''
  66.         self.total_cd = 0
  67.  
  68.         # TODO -> Главен прозорец
  69.         self.title('Материални запаси')  # TODO -> Главен прозорец
  70.         self.geometry('1300x600+200+150')  # 480
  71.         self.resizable(True, False)
  72.         self.attributes('-topmost', 'true')
  73.         # TODO -> Label frame top
  74.         self.lab_frame_top = self.widget_factory.get_label_frame(self, 'Материални запаси')
  75.         self.lab_frame_top.configure(width=540, height=300, padx=1, pady=2, relief='sunken', font=('Timesbd', 12, 'italic') )
  76.         self.lab_frame_top.place(x=10, y=20, )
  77.         # TODO -> LABELS
  78.         self.widget_factory.get_label_un(self, 'Налични сметки:', 720, 1, 'w', 20, 'blue', bg_color=None, bg_border='red')
  79.         self.widget_factory.get_label_un(self.lab_frame_top, '2022\n(хил.лв)', 210, 1, 'w', 6, 'black', bg_border='red', j='center')
  80.         self.widget_factory.get_label_un(self.lab_frame_top, '2023\n(хил.лв)', 275, 1, 'w', 6, 'black', bg_border='red', j='center')
  81.         self.widget_factory.get_label_un(self.lab_frame_top, '2023\n(лева)', 340, 1, 'center', 11, 'black', bg_border='red', j='center')
  82.         self.widget_factory.get_label_un(self.lab_frame_top, 'с/ка:\n(код)', 460, 1, 'center', 4, 'black', bg_border='green')
  83.         self.widget_factory.get_label_un(self.lab_frame_top, '1. Суровини и материали', 20, 50, 'w', 24, bg_border='green', j='left')
  84.         self.widget_factory.get_label_un(self.lab_frame_top, '2. Стоки', 20, 80, 'w', 24, bg_border='green', j='left')
  85.         self.widget_factory.get_label_un(self.lab_frame_top, '3. Продукция', 20, 110, 'w', 24, bg_border='green', j='left')
  86.         self.widget_factory.get_label_un(self.lab_frame_top, '4 Незавършено производство', 20, 140, 'w', 24, bg_border='green', j='left')
  87.         self.widget_factory.get_label_un(self.lab_frame_top, '5. Платени аванси', 20, 170, 'w', 24, bg_border='green')
  88.         # TODO -> Entries
  89.         self.ns_mat = self.widget_factory.get_entry(self.lab_frame_top, 220, 50, 5, 'right')
  90.         self.ns_mat.bind('<KeyRelease>', lambda e: self.update_total_sum_ns())
  91.         self.ks_mat = self.widget_factory.get_entry(self.lab_frame_top, 280, 50, 5, 'right')
  92.         self.ks_mat.bind("<KeyRelease>", lambda e: self.update_total_sum_ks())
  93.         self.l_mat = self.widget_factory.get_label_un(self.lab_frame_top, '0', 340, 50, 'e', 11, 'black', bg_border='green', j='left')
  94.         self.e_mat = self.widget_factory.get_entry(self.lab_frame_top, 450, 50, 9, 'left', name='mat')
  95.         self.e_mat.bind("<KeyRelease>", lambda e: self.on_entry_key_release(self.e_mat))
  96.         self.e_mat.bind("<FocusIn>", lambda e: self.entry_on_focus(self.e_mat))
  97.         #
  98.         self.ns_st = self.widget_factory.get_entry(self.lab_frame_top, 220, 80, 5, 'right')
  99.         self.ns_st.bind('<KeyRelease>', lambda e: self.update_total_sum_ns())
  100.         self.ks_st = self.widget_factory.get_entry(self.lab_frame_top, 280, 80, 5, 'right')
  101.         self.ks_st.bind("<KeyRelease>", lambda e: self.update_total_sum_ks())
  102.         self.l_ks_st = self.widget_factory.get_label_un(self.lab_frame_top, '0', 340, 80, 'e', 11, 'black', bg_border='green', j='left')
  103.         self.e_st = self.widget_factory.get_entry(self.lab_frame_top, 450, 80, 9, name='st')
  104.         self.e_st.bind("<KeyRelease>", lambda e: self.on_entry_key_release(self.e_st))
  105.         self.e_st.bind("<FocusIn>", lambda e: self.entry_on_focus(self.e_st))
  106.         #
  107.         self.ns_prod = self.widget_factory.get_entry(self.lab_frame_top, 220, 110, 5, 'right')
  108.         self.ns_prod.bind('<KeyRelease>', lambda e: self.update_total_sum_ns())
  109.         self.ks_prod = self.widget_factory.get_entry(self.lab_frame_top, 280, 110, 5, 'right')
  110.         self.ks_prod.bind("<KeyRelease>", lambda e: self.update_total_sum_ks())
  111.         self.l_ks_prod = self.widget_factory.get_label_un(self.lab_frame_top, '0', 340, 110, 'e', 11, 'black', bg_border='green', j='left')
  112.         self.e_prod = self.widget_factory.get_entry(self.lab_frame_top, 450, 110, 9, name='prod')
  113.         self.e_prod.bind("<KeyRelease>", lambda e: self.on_entry_key_release(self.e_prod))
  114.         self.e_prod.bind("<FocusIn>", lambda e: self.entry_on_focus(self.e_prod))
  115.         #
  116.         self.ns_nezpr = self.widget_factory.get_entry(self.lab_frame_top, 220, 140, 5, 'right')
  117.         self.ns_nezpr.bind('<KeyRelease>', lambda e: self.update_total_sum_ns())
  118.         self.ks_nezpr = self.widget_factory.get_entry(self.lab_frame_top, 280, 140, 5, 'right')
  119.         self.ks_nezpr.bind("<KeyRelease>", lambda e: self.update_total_sum_ks())
  120.         self.l_ks_nezpr = self.widget_factory.get_label_un(self.lab_frame_top, '0', 340, 140, 'e', 11, 'black', bg_border='green', j='left')
  121.         self.e_nezpr = self.widget_factory.get_entry(self.lab_frame_top, 450, 140, 9, name='nezpr')
  122.         self.e_nezpr.bind("<KeyRelease>", lambda e: self.on_entry_key_release(self.e_nezpr))
  123.         self.e_nezpr.bind("<FocusIn>", lambda e: self.entry_on_focus(self.e_nezpr))
  124.         #
  125.         self.ns_mzadv = self.widget_factory.get_entry(self.lab_frame_top, 220, 170, 5, 'right')
  126.         self.ns_mzadv.bind('<KeyRelease>', lambda e: self.update_total_sum_ns())
  127.         self.ks_mzadv = self.widget_factory.get_entry(self.lab_frame_top, 280, 170, 5, 'right')
  128.         self.ks_mzadv.bind("<KeyRelease>", lambda e: self.update_total_sum_ks())
  129.         self.l_ks_mzadv = self.widget_factory.get_label_un(self.lab_frame_top, '0', 340, 170, 'e', 11, 'black', bg_border='green', j='left')
  130.         self.e_mzadv = self.widget_factory.get_entry(self.lab_frame_top, 450, 170, 9, name='mzadv')
  131.         self.e_mzadv.bind("<KeyRelease>", lambda e: self.on_entry_key_release(self.e_mzadv))
  132.         self.e_mzadv.bind("<FocusIn>", lambda e: self.entry_on_focus(self.e_mzadv))
  133.         # TODO -> DOWN LABELS
  134.         self.widget_factory.get_label(self.lab_frame_top, 20, 230, 'Общо материални запаси:', 24, 'w', font=10)
  135.         self.l_user_od_total = self.widget_factory.get_label(self.lab_frame_top, 210, 230, 0, 5, 'e', color='black', font=10)
  136.         self.l_user_cd_total = self.widget_factory.get_label(self.lab_frame_top, 270, 230, 0, 5, 'e', color='black', font=10)
  137.         self.l_cd_total = self.widget_factory.get_label(self.lab_frame_top, 330, 230, 0.0, 12, 'e', color='black', font=10)
  138.  
  139.         # TODO -> Label_frame_Bottom
  140.         self.lab_frame_bottom = self.widget_factory.get_label_frame(self, 'Изменение на материалните запаси')
  141.         self.lab_frame_bottom.configure(width=540, height=200, padx=1, pady=2, relief='sunken', font=('Timesbd', 12, 'italic'), fg='darkgreen')
  142.         self.lab_frame_bottom.place(x=10, y=340)
  143.  
  144.         self.widget_factory.get_label_un(self.lab_frame_bottom, '2022\n(хил.лв)', 275, 1, 'w', 6, 'black', bg_border='red', j='center')
  145.         self.widget_factory.get_label_un(self.lab_frame_bottom, '2023\n(хил.лв)', 350, 1, 'center', 6, 'black', bg_border='red', j='center')
  146.         self.widget_factory.get_label_un(self.lab_frame_bottom, '2023\n(лева)', 420, 1, 'center', 11, 'black', bg_border='green')
  147.         self.widget_factory.get_label_un(self.lab_frame_bottom, 'Продукция:', 20, 50, 'w', 24, bg_border='green', j='left')
  148.         self.widget_factory.get_label(self.lab_frame_bottom, 215, 50, '+ / -', 6, 'center')
  149.         self.widget_factory.get_label_un(self.lab_frame_bottom, 'Незавършено производство:', 20, 80, 'w', 24, bg_border='green', j='left')
  150.         self.widget_factory.get_label(self.lab_frame_bottom, 215, 80, '+ / -', 6, 'center')
  151.         self.widget_factory.get_label_un(self.lab_frame_bottom, 'Общо:', 20, 110, 'w', 20, bg_border='green')
  152.         self.widget_factory.get_label(self.lab_frame_bottom, 215, 110, '+ / -', 6, 'center')
  153.  
  154.         self.ns_prod_diff = self.widget_factory.get_entry(self.lab_frame_bottom, 280, 50, 5, 'right')
  155.         self.ns_prod_diff.bind("<KeyRelease>", lambda e: self.update_ns_diff('ns_prod_diff'))
  156.         self.ks_prod_diff = self.widget_factory.get_entry(self.lab_frame_bottom, 360, 50, 5, 'right')
  157.         self.ks_prod_diff.bind("<KeyRelease>", lambda e: self.update_total_diff())
  158.         self.l_prod_diff = self.widget_factory.get_label_un(self.lab_frame_bottom, '0', 420, 50, 'e', 11, 'black', bg_border='green', j='left')
  159.  
  160.         self.ns_nezpr_diff = self.widget_factory.get_entry(self.lab_frame_bottom, 280, 80, 5, 'right')
  161.         self.ns_nezpr_diff.bind("<KeyRelease>", lambda e: self.update_ns_diff('ns_nezpr_diff'))
  162.         self.ks_nezpr_diff = self.widget_factory.get_entry(self.lab_frame_bottom, 360, 80, 5, 'right')
  163.         self.ks_nezpr_diff.bind("<KeyRelease>", lambda e: self.update_total_diff())
  164.         self.l_nezpr_diff = self.widget_factory.get_label_un(self.lab_frame_bottom, '0', 420, 80, 'e', 11, 'black', bg_border='green', j='left')
  165.  
  166.         self.tot_ns_diff = self.widget_factory.get_entry(self.lab_frame_bottom, 280, 110, 5, 'right')
  167.         self.tot_ns_diff.bind("<KeyRelease>", lambda e: self.update_ns_diff('tot_ns_diff'))
  168.         self.l_tot_ks_diff = self.widget_factory.get_label_un(self.lab_frame_bottom, 'n/a', 350, 110, 'e', 5, 'black', bg_border='green', j='left')
  169.         self.l_tot_diff_leva = self.widget_factory.get_label_un(self.lab_frame_bottom, 'n/a', 420, 110, 'e', 11, 'black', bg_border='green', j='left')
  170.  
  171.         # TODO TREEVIEW
  172.         self.tv_frame = Frame(self)  # 'open_di', 'turn_di', 'turn_ci':, "close_di": -> ширината на колоните в Treeview
  173.         self.tv_frame.place(x=560, y=30)
  174.         self.dict_columns = {"code": 'код', "acc_name": 'Сметка', 'open_di': 'НС Дебит', 'turn_di': 'Оборот Дт',
  175.                              'turn_ci': 'Оборот Кт', "close_di": 'КС Дебит'}
  176.         self.treeview_acc = self.widget_factory.get_treeview(self.tv_frame, **self.dict_columns)
  177.         self.treeview_acc.config(selectmode='browse')
  178.         self.treeview_acc.bind('<ButtonRelease-1>', lambda e: self.on_selected_acc(self.treeview_acc))
  179.         self.treeview_acc.pack(side=LEFT)
  180.         # TODO SCROLLBAR
  181.         self.scr_bar = Scrollbar(self.tv_frame, orient=VERTICAL)
  182.         self.scr_bar.pack(side=RIGHT, fill=Y)
  183.         self.treeview_acc.config(yscrollcommand=self.scr_bar.set)
  184.         self.scr_bar.config(command=self.treeview_acc.yview, bg="red", activebackground="orange")
  185.         # TODO Spinboxes
  186.         self.min_spin_2 = self.min_top_group_digits
  187.         self.max_spin_2 = self.max_top_group_digits + self.max_groups
  188.         self.var_spin_1 = StringVar(self)
  189.         self.list_spin_1 = ['всички', 'недобавени']
  190.         self.spin_1 = self.widget_factory.get_list_spinbox(self, self.list_spin_1, 12, 'center',
  191.                                                            self.var_spin_1, 560, 4)
  192.         self.spin_1.configure(command=lambda: self.fill_treeview())
  193.         max_spin_2 = self.max_depth_rx
  194.         if max_spin_2 < self.min_spin_2:
  195.             max_spin_2 = self.min_spin_2
  196.         print("self.min_spin_2", self.min_spin_2, "self.max_depth_rx", self.max_depth_rx, "max_spin_2", max_spin_2)
  197.         self.var_spin_2 = StringVar(self, value=str(max_spin_2))
  198.         self.spin_2 = self.widget_factory.get_spinbox(self, self.min_spin_2, str(max_spin_2), 4,
  199.                                                       'center', self.var_spin_2, 660, 4)
  200.         self.spin_2.configure(command=lambda: self.fill_treeview())
  201.         # TODO Buttons
  202.         # Button Помощ
  203.         self.b_help = self.widget_factory.get_help_button(self, 20, 555)
  204.         self.b_help.bind('<ButtonRelease-1>')
  205.         # Button Корекции
  206.         self.b_note = self.widget_factory.get_correction_button(self, 350, 555)
  207.         self.b_note.bind('<ButtonRelease-1>', lambda e: self.on_correction())
  208.         # Button Добави
  209.         self.b_add = self.widget_factory.get_save_button(self, 456, 555, text='ДОБАВИ')  # 460, 435
  210.         self.b_add.bind('<ButtonRelease-1>', lambda e: self.on_add())
  211.         # Button Save
  212.         self.b_save = self.widget_factory.get_ok_button(self, 830, 555)
  213.         self.b_save.bind('<ButtonRelease-1>', lambda e: self.on_save())
  214.         # Button Отказ
  215.         self.b_exit = self.widget_factory.get_correction_esc(self, 930, 555)
  216.         self.b_exit.config(command=self.destroy)
  217.  
  218.     def set_pop_message_answer(self, answer):
  219.         self.pop_message_answer = answer
  220.  
  221.     def on_save(self):
  222.         # TODO -> Попълваме Началното салдо, въведено от потребителя:
  223.         # for entry in self.user_ns:
  224.         #     self.acc_rec_rx[entry]['ns'] = self.user_ns[entry]
  225.         # for entry in self.user_ns_amo:
  226.         #     self.acc_rec_rx[entry]['ns_amo'] = self.user_ns_amo[entry]
  227.         # TODO -> Попълваме сметките, по Ентрита на активи и амортизации
  228.         if not self.dict_entries:  # Речника е празен
  229.             for entry in self.acc_rec_rx:
  230.                 self.acc_rec_rx[entry]['assets'].clear()
  231.         # if not self.dict_entries_amo:  # Речника е празен
  232.         #     for entry in self.acc_rec_rx:
  233.         #         self.acc_rec_rx[entry]['amort'].clear()
  234.         for entry in self.dict_entries:
  235.             if self.dict_entries[entry] is None:
  236.                 self.dict_entries[entry] = []
  237.             self.acc_rec_rx[entry]['assets'] = self.dict_entries[entry]
  238.         # for entry in self.dict_entries_amo:
  239.         #     if self.dict_entries_amo[entry] is None:
  240.         #         self.dict_entries_amo[entry] = []
  241.         #     self.acc_rec_rx[entry]['amort'] = self.dict_entries_amo[entry]
  242.         # TODO -> попълване на сумите на преоценката
  243.         # for entry in self.assets_re:
  244.         #     for dir in self.assets_re[entry]:
  245.         #         self.acc_rec_rx[entry]['assets_re'][dir] = self.assets_re[entry][dir]
  246.         # for entry in self.amort_re:
  247.         #     for dir in self.amort_re[entry]:
  248.         #         self.acc_rec_rx[entry]['amort_re'][dir] = self.amort_re[entry][dir]
  249.         # print('self.acc_rec_rx: ', self.acc_rec_rx)
  250.  
  251.         json_file_io = JsonFileIo(file_name=registry['mz_import_form_acc_rec_mz_file_name'])
  252.         json_file_io.write_content(self.acc_rec_rx)
  253.         # TODO -> Проверка за недобавена сметка и съобщение !!!!!
  254.         if len(self.list_unadded_accs) > 0:
  255.             # TODO -> Показва pop_message "Има недобавени сметки !
  256.             pop_message = self.widget_factory.get_pop_message(self, lambda answer: self.set_pop_message_answer(answer),
  257.                                                               "Има недобавени сметки !", 1, 'red')
  258.             self.wait_window(pop_message.pop)
  259.             # TODO -> Ако "ДА"
  260.             self.destroy()
  261.             return
  262.         else:
  263.             pop_message = self.widget_factory.get_pop_message(self, lambda answer: self.set_pop_message_answer(answer),
  264.                                                               "Всички сметки са добавени !", 1, 'green')
  265.             self.wait_window(pop_message.pop)
  266.             # TODO -> Ако "ДА"
  267.             self.destroy()
  268.             return
  269.  
  270.     def on_correction(self):
  271.         # TODO -> Махаме маркировката на Treeview и забраната за селекция
  272.         for code in self.selected_accs:
  273.             self.treeview_acc.tag_configure(code, background='lightgrey')
  274.         self.selected_accs.clear()
  275.         # TODO -> Изтриваме стойностите на речника, на ентритата и лейбълите
  276.         self.dict_entries.clear()
  277.         self.get_total = {'total': {'od': 0.0, 'oc': 0.0, 'td': 0.0, 'tc': 0.0, 'cd': 0.0, 'cc': 0.0}}
  278.         self.ns_mat.delete(0, 'end')
  279.         self.ks_mat.delete(0, 'end')
  280.         self.l_mat['text'] = '0.00'
  281.         self.ns_st.delete(0, 'end')
  282.         self.ks_st.delete(0, 'end')
  283.         self.l_ks_st['text'] = '0.00'
  284.         self.ns_prod.delete(0, 'end')
  285.         self.ks_prod.delete(0, 'end')
  286.         self.l_ks_prod['text'] = '0.00'
  287.         self.ns_nezpr.delete(0, 'end')
  288.         self.ks_nezpr.delete(0, 'end')
  289.         self.l_ks_nezpr['text'] = '0.00'
  290.         self.ns_mzadv.delete(0, 'end')
  291.         self.ks_mzadv.delete(0, 'end')
  292.         self.l_ks_mzadv['text'] = '0.00'
  293.         self.ns_prod_diff.delete(0, 'end')
  294.         self.ks_prod_diff.delete(0, 'end')
  295.         self.l_prod_diff['text'] = '0.00'
  296.         self.ns_nezpr_diff.delete(0, 'end')
  297.         self.ks_nezpr_diff.delete(0, 'end')
  298.         self.l_nezpr_diff['text'] = '0.00'
  299.         self.tot_ns_diff.delete(0, 'end')
  300.         self.l_tot_ks_diff['text'] = '0'
  301.         self.tot_ns_diff.configure(state='normal')
  302.         self.ns_prod_diff.configure(state='normal')
  303.         self.ns_nezpr_diff.configure(state='normal')
  304.  
  305.         self.fill_labels()
  306.         self.fill_treeview()
  307.  
  308.     def update_total_sum_ks(self):
  309.         ks_mat = self.ks_mat.get()
  310.         ks_st = self.ks_st.get()
  311.         ks_prod = self.ks_prod.get()
  312.         ks_nezpr = self.ks_nezpr.get()
  313.         ks_mzadv = self.ks_mzadv.get()
  314.         dict_ks = {'ks_mat': ks_mat, 'ks_st': ks_st, 'ks_prod': ks_prod, 'ks_nezpr': ks_nezpr, 'ks_mzadv': ks_mzadv}
  315.         for _ in range(len(dict_ks)):
  316.             for ks in dict_ks:
  317.                 try:
  318.                     int(dict_ks[ks])
  319.                     dict_ks[ks] = int(dict_ks[ks])
  320.                 except:
  321.                     dict_ks[ks] = 0
  322.         total_ks = dict_ks['ks_mat'] + dict_ks['ks_st'] + dict_ks['ks_prod'] + dict_ks['ks_nezpr'] + dict_ks['ks_mzadv']
  323.         if total_ks != self.total_cd:
  324.             self.l_user_cd_total.configure(fg='red')
  325.         else:
  326.             self.l_user_cd_total.configure(fg='black')
  327.  
  328.     def update_total_sum_ns(self):
  329.         ns_mat = self.ns_mat.get()
  330.         ns_st = self.ns_st.get()
  331.         ns_prod = self.ns_prod.get()
  332.         ns_nezpr = self.ns_nezpr.get()
  333.         ns_mzadv = self.ns_mzadv.get()
  334.         dict_ns = {'ns_mat': ns_mat, 'ns_st': ns_st, 'ns_prod': ns_prod, 'ns_nezpr': ns_nezpr, 'ns_maadv': ns_mzadv}
  335.         for _ in range(len(dict_ns)):
  336.             for ns in dict_ns:
  337.                 try:
  338.                     int(dict_ns[ns])
  339.                     dict_ns[ns] = int(dict_ns[ns])
  340.                 except:
  341.                     dict_ns[ns] = 0
  342.         total_ns = dict_ns['ns_mat'] + dict_ns['ns_st'] + dict_ns['ns_prod'] + dict_ns['ns_nezpr'] + dict_ns['ns_maadv']
  343.         self.l_user_od_total['text'] = total_ns
  344.  
  345.     def update_total_diff(self):
  346.         prod_diff = self.ks_prod_diff.get()
  347.         nezpr_diff = self.ks_nezpr_diff.get()
  348.         try:
  349.             int(nezpr_diff)
  350.             nezpr_diff = int(nezpr_diff)
  351.         except:
  352.             nezpr_diff = 0
  353.         try:
  354.             int(prod_diff)
  355.             prod_diff = int(prod_diff)
  356.         except:
  357.             prod_diff = 0
  358.         if (prod_diff >= 0 and nezpr_diff >= 0) or (prod_diff <= 0 and nezpr_diff <= 0):
  359.             self.l_tot_ks_diff['text'] = prod_diff + nezpr_diff
  360.         else:
  361.             self.l_tot_ks_diff['text'] = 'n/a'
  362.  
  363.     def update_ns_diff(self, name_entry):
  364.         ns_prod = self.ns_prod_diff.get()
  365.         ns_nezpr = self.ns_nezpr_diff.get()
  366.         tot_ns = self.tot_ns_diff.get()
  367.         print(f'ns_prod: {ns_prod} ns_nezpr: {ns_nezpr} tot_ns: {tot_ns}')
  368.         if ns_prod == '' and ns_nezpr == '' and tot_ns == '':
  369.             self.tot_ns_diff.configure(state='normal')
  370.             self.ns_prod_diff.configure(state='normal')
  371.             self.ns_nezpr_diff.configure(state='normal')
  372.         elif name_entry == 'ns_prod_diff' or name_entry == 'ns_nezpr_diff':
  373.             self.tot_ns_diff.configure(state='disabled')
  374.         elif name_entry == 'tot_ns_diff':
  375.             self.ns_prod_diff.configure(state='disabled')
  376.             self.ns_nezpr_diff.configure(state='disabled')
  377.  
  378.     def round_1000(self, sum):
  379.         try:
  380.             sum = float(sum)
  381.         except:
  382.             sum = 0.0
  383.         sum_1000 = float(round(sum / 1000))
  384.         return sum_1000
  385.  
  386.     def fill_labels(self):
  387.         for entry in self.dict_entries:
  388.             if self.dict_entries[entry] is None:
  389.                 self.dict_entries[entry] = []
  390.         if len(self.dict_entries) > 0:
  391.             self.get_sums, self.get_total = self.mapped_calculations.get_sum_list_accounts(self.dict_entries)
  392.             for entr in self.get_sums:
  393.                 if entr == 'mat':
  394.                     self.l_mat['text'] = f"{self.get_sums['mat']['cd']:,.2f}".replace(',', ' ')
  395.                     sum = self.get_sums['mat']['cd']
  396.                     round_sum = int(self.round_1000(sum))
  397.                     self.ks_mat.delete(0, 'end')
  398.                     self.ks_mat.insert(0, round_sum)
  399.  
  400.                 elif entr == 'st':
  401.                     self.l_ks_st['text'] = f"{self.get_sums['st']['cd']:,.2f}".replace(',', ' ')
  402.                     sum = self.get_sums['st']['cd']
  403.                     round_sum = int(self.round_1000(sum))
  404.                     self.ks_st.delete(0, 'end')
  405.                     self.ks_st.insert(0, round_sum)
  406.  
  407.                 elif entr == 'prod':
  408.                     self.l_ks_prod['text'] = f"{self.get_sums['prod']['cd']:,.2f}".replace(',', ' ')
  409.                     sum = self.get_sums['prod']['cd']
  410.                     round_sum = int(self.round_1000(sum))
  411.                     self.ks_prod.delete(0, 'end')
  412.                     self.ks_prod.insert(0, round_sum)
  413.  
  414.                 elif entr == 'nezpr':
  415.                     self.l_ks_nezpr['text'] = f"{self.get_sums['nezpr']['cd']:,.2f}".replace(',', ' ')
  416.                     sum = self.get_sums['nezpr']['cd']
  417.                     round_sum = int(self.round_1000(sum))
  418.                     self.ks_nezpr.delete(0, 'end')
  419.                     self.ks_nezpr.insert(0, round_sum)
  420.  
  421.                 elif entr == 'mzadv':
  422.                     self.l_ks_mzadv['text'] = f"{self.get_sums['mzadv']['cd']:,.2f}".replace(',', ' ')
  423.                     sum = self.get_sums['mzadv']['cd']
  424.                     round_sum = int(self.round_1000(sum))
  425.                     self.ks_mzadv.delete(0, 'end')
  426.                     self.ks_mzadv.insert(0, round_sum)
  427.  
  428.         self.total_cd = self.round_1000(self.get_total['total']['cd'])
  429.         self.l_user_cd_total['text'] = f"{self.total_cd:,.0f}".replace(',', ' ')
  430.         ks_mat = self.ks_mat.get()
  431.         ks_st = self.ks_st.get()
  432.         ks_prod = self.ks_prod.get()
  433.         ks_nezpr = self.ks_nezpr.get()
  434.         ks_mzadv = self.ks_mzadv.get()
  435.         dict_ks = {'ks_mat': ks_mat, 'ks_st': ks_st, 'ks_prod': ks_prod, 'ks_nezpr': ks_nezpr, 'ks_mzadv': ks_mzadv}
  436.         for _ in range(len(dict_ks)):
  437.             for ks in dict_ks:
  438.                 try:
  439.                     int(dict_ks[ks])
  440.                     dict_ks[ks] = int(dict_ks[ks])
  441.                 except:
  442.                     dict_ks[ks] = 0
  443.         total_ks = dict_ks['ks_mat'] + dict_ks['ks_st'] + dict_ks['ks_prod'] + dict_ks['ks_nezpr'] + dict_ks['ks_mzadv']
  444.         if total_ks != int(self.total_cd):
  445.             self.l_user_cd_total.configure(fg='red')
  446.         else:
  447.             self.l_user_cd_total.configure(fg='black')
  448.         self.l_cd_total['text'] = f"{self.get_total['total']['cd']:,.2f}".replace(',', ' ')
  449.         # TODO -> Попълване на долната таблица
  450.         # TODO -> Изменение на продукцията
  451.         suma_p = suma = 0
  452.         for ent in self.dict_entries:
  453.             if ent == 'prod' and len(self.dict_entries['prod']) > 0:
  454.                 prod_leva = self.mapped_calculations.sum_by_accs(self.dict_entries['prod'])
  455.                 suma_p = prod_leva['cd'] - prod_leva['od']
  456.                 suma_1000 = suma_p / 1000
  457.                 summa = f"{suma_p:,.2f}".replace(',', ' ')
  458.                 self.l_prod_diff['text'] = summa
  459.                 suma_1000 = f"{suma_1000:,.0f}".replace(',', ' ')
  460.                 self.ks_prod_diff.delete(0, 'end')
  461.                 self.ks_prod_diff.insert(0, suma_1000)
  462.         # TODO -> Изменение на незавършеното производство
  463.             elif ent == 'nezpr' and len(self.dict_entries['nezpr']) > 0:
  464.                 prod_leva = self.mapped_calculations.sum_by_accs(self.dict_entries['nezpr'])
  465.                 suma = prod_leva['cd'] - prod_leva['od']
  466.                 suma_1000 = suma / 1000
  467.                 summa = f"{suma:,.2f}".replace(',', ' ')
  468.                 self.l_nezpr_diff['text'] = summa
  469.                 suma_1000 = f"{suma_1000:,.0f}".replace(',', ' ')
  470.                 self.ks_nezpr_diff.delete(0, 'end')
  471.                 self.ks_nezpr_diff.insert(0, suma_1000)
  472.         # TODO -> Изменения в TOTAL
  473.         if (suma_p >= 0 and suma >= 0) or (suma_p <= 0 and suma <= 0):
  474.             tot_diff_leva = suma_p + suma
  475.             self.l_tot_diff_leva['text'] = f'{tot_diff_leva:,.2f}'.replace(',', ' ')
  476.             self.l_tot_ks_diff['text'] = f'{tot_diff_leva / 1000:,.0f}'.replace(',', ' ')
  477.         else:
  478.             self.l_tot_diff_leva['text'] = 'n/a'
  479.             self.l_tot_ks_diff['text'] = 'n/a'
  480.  
  481.     def on_add(self):
  482.         acc_code = self.last_entry.get()  # '203'
  483.         if acc_code is None or acc_code == '':
  484.             return
  485.         tuple_accs = self.treeview_acc.selection()
  486.         self.selected_accs.append(tuple_accs[0])
  487.         # TODO -> На името на Entry да добавим сметката
  488.         name_entry = self.last_entry.winfo_name()
  489.         if name_entry not in self.dict_entries:
  490.             self.dict_entries[name_entry] = ()
  491.         self.dict_entries[name_entry] += self.treeview_acc.selection()  # Добавям маркираната сметка
  492.         # TODO -> Добавяне на децата и родителите на добавената сметка
  493.         all_children = self.account_tree.get_all_children(acc_code)  # all_children:  ['200', '203', '205']
  494.         all_parents = self.account_tree.get_all_parents(acc_code)  # acc_code = 223
  495.         self.selected_accs.extend(all_children)
  496.         self.selected_accs.extend(all_parents)
  497.         # TODO -> След добавяне да се изпразват всички ентрита, а не само добавеното !!!!!
  498.         if self.e_mat.get() != '': self.e_mat.delete(0, 'end')
  499.         if self.e_st.get() != '': self.e_st.delete(0, 'end')
  500.         if self.e_prod.get() != '': self.e_prod.delete(0, 'end')
  501.         if self.e_nezpr.get() != '': self.e_nezpr.delete(0, 'end')
  502.         if self.e_mzadv.get() != '': self.e_mzadv.delete(0, 'end')
  503.  
  504.         self.fill_labels()
  505.         # TODO -> Попълваме Treeview
  506.         self.fill_treeview()
  507.  
  508.     def verify_selection(self):  # Забрана за маркиране
  509.         for code in self.selected_accs:
  510.             if self.treeview_acc.exists(code):
  511.                 self.treeview_acc.selection_remove(code)
  512.  
  513.     def on_selected_acc(self, source_treeview):
  514.         self.verify_selection()
  515.         current_item = source_treeview.focus()
  516.         if current_item in self.selected_accs:   # <class 'list'>
  517.             return
  518.         values = source_treeview.item(current_item)["values"]
  519.         if not isinstance(values, list):
  520.             return
  521.         code = values[0]
  522.         self.last_entry.delete(0, END)
  523.         self.last_entry.insert(0, code)
  524.  
  525.     def entry_on_focus(self, entry):
  526.         self.last_entry = entry
  527.  
  528.     def on_entry_key_release(self, entry):
  529.         self.last_entry = entry
  530.         entry_text = entry.get()
  531.         if len(entry_text) < 2:
  532.             self.fill_treeview()
  533.             return
  534.         term = entry_text
  535.         self.fill_treeview(term=term)
  536.  
  537.     def mz(self):
  538.         try:
  539.             json_file_io = JsonFileIo(file_name=registry["mz_import_form_acc_rec_mz_file_name"])
  540.             tmp_acc_rec_rx = json_file_io.read_content()
  541.             if tmp_acc_rec_rx is not None:
  542.                 self.acc_rec_rx = tmp_acc_rec_rx
  543.             self.refill_form()
  544.         except:
  545.             pass
  546.         self.fill_treeview()
  547.         self.mainloop()
  548.  
  549.     def refill_form(self):
  550.         # TODO -> Попълваме Treeview с маркирани и забранени за селектиране сметки
  551.         for entry in self.acc_rec_rx:
  552.             self.dict_entries[entry] = self.acc_rec_rx[entry]['assets']
  553.         for entry in self.acc_rec_rx:
  554.             self.dict_entries_amo[entry] = self.acc_rec_rx[entry]['amort']
  555.         # TODO -> Попълваме сметките, децата и родителите на сметките в self.selected_accs, self.selected_accs_amo
  556.         for entry_name in self.dict_entries:
  557.             for acc_code in self.dict_entries[entry_name]:
  558.                 if acc_code not in self.selected_accs:
  559.                     self.selected_accs.append(acc_code)
  560.                     all_children = self.account_tree.get_all_children(acc_code)  # all_children:['200', '203'']
  561.                     all_parents = self.account_tree.get_all_parents(acc_code)  # acc_code = 223 all_parents:['22',]
  562.                     self.selected_accs.extend([a for a in all_children if a not in self.selected_accs])
  563.                     self.selected_accs.extend([a for a in all_parents if a not in self.selected_accs])
  564.         # for entry_name in self.dict_entries_amo:
  565.         #     for acc_code in self.dict_entries_amo[entry_name]:
  566.         #         if acc_code not in self.selected_accs_amo:
  567.         #             self.selected_accs_amo.append(acc_code)
  568.         #             all_children = self.account_tree.get_all_children(acc_code)  # all_children:['200', '203',]
  569.         #             all_parents = self.account_tree.get_all_parents(acc_code)
  570.                     # self.selected_accs_amo.extend([a for a in all_children if a not in self.selected_accs_amo])
  571.                     # self.selected_accs_amo.extend([a for a in all_parents if a not in self.selected_accs_amo])
  572.         # TODO -> Попълваме Ентритата с НС user_ns и user_ns_amo
  573.         for entry_name in self.user_ns:
  574.             self.user_ns[entry_name] = self.acc_rec_rx[entry_name]['ns']
  575.         if self.user_ns['adp'] > 0:
  576.             self.user_adp.insert(0, self.user_ns['adp'])
  577.         if self.user_ns['pzp'] > 0:
  578.             self.user_pzp.insert(0, self.user_ns['pzp'])
  579.         if self.user_ns['adas'] > 0:
  580.             self.user_a.insert(0, self.user_ns['a'])
  581.         if self.user_ns['pzas'] > 0:
  582.             self.user_pzas.insert(0, self.user_ns['pzas'])
  583.         if self.user_ns['di'] > 0:
  584.             self.user_di.insert(0, self.user_ns['di'])
  585.         if self.user_ns['drz'] > 0:
  586.             self.user_drz.insert(0, self.user_ns['drz'])
  587.         if self.user_ns['isa'] > 0:
  588.             self.user_isa.insert(0, self.user_ns['isa'])
  589.  
  590.         for entry_name in self.user_ns_amo:
  591.             self.user_ns_amo[entry_name] = self.acc_rec_rx[entry_name]['ns_amo']
  592.         if self.user_ns_amo['di'] > 0:
  593.             self.user_amo_di.insert(0, self.user_ns_amo['di'])
  594.         # TODO -> Попълваме Ентритата с Преоценките
  595.         print('self.assets_re: ', self.assets_re)
  596.         for entry in self.assets_re:
  597.             for dir in self.assets_re[entry]:
  598.                 self.assets_re[entry][dir] = self.acc_rec_rx[entry]['assets_re'][dir]
  599.         print('self.assets_re след refill: ', self.assets_re)
  600.         if self.assets_re['adp']['inc'] > 0:
  601.             self.turn_d_adp.insert(0, self.assets_re['adp']['inc'])
  602.         if self.assets_re['adp']['dec'] > 0:
  603.             self.turn_c_adp.insert(0, self.assets_re['adp']['dec'])
  604.         if self.assets_re['pzp']['inc'] > 0:
  605.             self.turn_d_pzp.insert(0, self.assets_re['pzp']['inc'])
  606.         if self.assets_re['pzp']['dec'] > 0:
  607.             self.turn_c_pzp.insert(0, self.assets_re['pzp']['dec'])
  608.         if self.assets_re['adas']['inc'] > 0:
  609.             self.turn_d_adas.insert(0, self.assets_re['adas']['inc'])
  610.         if self.assets_re['adas']['dec'] > 0:
  611.             self.turn_c_adas.insert(0, self.assets_re['adas']['dec'])
  612.  
  613.         if self.assets_re['pzas']['inc'] > 0:
  614.             self.turn_d_pzas.insert(0, self.assets_re['pzas']['inc'])
  615.         if self.assets_re['pzas']['dec'] > 0:
  616.             self.turn_c_pzas.insert(0, self.assets_re['pzas']['dec'])
  617.  
  618.         if self.assets_re['di']['inc'] > 0:
  619.             self.turn_d_di.insert(0, self.assets_re['di']['inc'])
  620.         if self.assets_re['di']['dec'] > 0:
  621.             self.turn_c_di.insert(0, self.assets_re['di']['dec'])
  622.  
  623.         if self.assets_re['drz']['inc'] > 0:
  624.             self.turn_d_drz.insert(0, self.assets_re['drz']['inc'])
  625.         if self.assets_re['drz']['dec'] > 0:
  626.             self.turn_c_drz.insert(0, self.assets_re['drz']['dec'])
  627.  
  628.         if self.assets_re['isa']['inc'] > 0:
  629.             self.turn_d_isa.insert(0, self.assets_re['isa']['inc'])
  630.         if self.assets_re['isa']['dec'] > 0:
  631.             self.turn_c_isa.insert(0, self.assets_re['isa']['dec'])
  632.  
  633.         for entry in self.amort_re:
  634.             for dir in self.amort_re[entry]:
  635.                 self.amort_re[entry][dir] = self.acc_rec_rx[entry]['amort_re'][dir]
  636.         print('self.amort_re след refill: ', self.amort_re)
  637.         if self.amort_re['di']['inc'] > 0:
  638.             self.turn_d_amo_di.insert(0, self.amort_re['di']['inc'])
  639.         if self.amort_re['di']['dec'] > 0:
  640.             self.turn_c_amo_di.insert(0, self.amort_re['di']['dec'])
  641.  
  642.     def fill_treeview(self, term=None):
  643.         self.treeview_acc.delete(*self.treeview_acc.get_children())  # Вградена функция за изтриване на Treeview
  644.         # TODO -> Spinboxes
  645.         self.unadded_spin = self.var_spin_1.get()  # Взима стойността на спинбокса за недобавени
  646.         spin_2 = int(self.var_spin_2.get())
  647.         self.all_accounts.extend(self.selected_accs)
  648.         self.list_unadded_accs = self.account_tree.get_unadded_acc(self.all_accounts, self.acc_data_mapped_da)
  649.  
  650.         count_rows = 0
  651.         for acc_code in self.acc_data_bycode:
  652.             if acc_code not in self.acc_data_mapped_da:
  653.                 continue
  654.             if term is not None:  # Искаме само сметките дето кода им започва с term
  655.                 term_len = len(term)
  656.                 code_piece = self.acc_data_bycode[acc_code]['code'][0:term_len]
  657.                 # Ако сметката не започва с term
  658.                 if term != code_piece:
  659.                     continue  # прескачаме тая сметка, не отговаря на търсеното
  660.             # TODO -> Ако spin_1 = 'недобавени' -> извежда само недобавените сметки в ентритата
  661.             if self.unadded_spin == 'недобавени':
  662.                 if acc_code not in self.list_unadded_accs:
  663.                     continue
  664.             # TODO -> spin_2 type of spin_2:  <class 'int'>
  665.             groups_in_acc_code = re.findall('[0-9]+', acc_code)  # Връща list със групите на сметката
  666.             top_group = groups_in_acc_code[0]
  667.             depth = self.account_tree.get_depth(acc_code)
  668.             if len(top_group) > spin_2 or depth > spin_2:
  669.                 continue
  670.             count_rows += 1
  671.             row = [self.acc_data_bycode[acc_code]['code'],
  672.                    self.acc_data_bycode[acc_code]['name'],
  673.                    self.acc_data_bycode[acc_code]['str_open_d'],
  674.                    self.acc_data_bycode[acc_code]['str_turn_d'],
  675.                    self.acc_data_bycode[acc_code]['str_turn_c'],
  676.                    self.acc_data_bycode[acc_code]['str_close_d']]
  677.             tags = acc_code
  678.             iid = acc_code
  679.             self.treeview_acc.insert('', END, values=row, tags=tags, iid=iid)  # ????
  680.         self.treeview_acc.config(height=count_rows)
  681.         if count_rows > 20:
  682.             self.treeview_acc.configure(height=20)
  683.         for code in self.selected_accs:  # Оцветяване на добавените сметки
  684.             if self.treeview_acc.exists(code):
  685.                 self.treeview_acc.tag_configure(code, background='powderblue')
  686.  
  687.  
  688.  
  689. if __name__ == '__main__':
  690.     mz = StockInventory()
  691.     mz.mz()
  692.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!