API tools faq
paste
Advertisement
ALEXANDAR_GEORGIEV

rpda_import_form

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