expenses.pay_credit_card_invoice 

  1from dictionary.sql import owner_cards_query, card_invoices_query
  2from dictionary.vars import today, to_remove_list, actual_year
  3from functions.login import Login
  4from functions.credit_card import Credit_Card
  5from functions.get_actual_time import GetActualTime
  6from functions.query_executor import QueryExecutor
  7from functions.variable import Variable
  8from screens.reports.receipts import Receipts
  9from time import sleep
 10import pandas as pd
 11import streamlit as st
 12
 13
 14class CreditCardInvoice:
 15    """
 16    Classe que representa as faturas de cartão.
 17    """
 18    def get_credit_card_expenses_data(
 19            self,
 20            selected_card: str,
 21            selected_month: str,
 22        ):
 23        """
 24        Realiza a consulta dos dados das despesas do cartão no mês.
 25
 26        Parameters
 27        ----------
 28        selected_card : str
 29            O cartão selecionado.
 30        selected_month: str
 31            O mês selecionado.
 32
 33        Returns
 34        -------
 35        month_year : str
 36            O ano do mês selecionado.
 37        month_name : str
 38            O mês selecionado.
 39        month_abbreviation : str
 40            A abreviação do mês.
 41        selected_card_linked_account : str
 42            A conta vinculada ao cartão.
 43        """
 44        user_name, user_document = Login().get_user_data(
 45            return_option="user_doc_name"
 46        )
 47
 48        selected_card_linked_account_query = """
 49        SELECT
 50            DISTINCT(cc.conta_associada)
 51        FROM
 52            contas
 53        INNER JOIN
 54            cartao_credito AS cc
 55            ON contas.proprietario_conta = cc.proprietario_cartao
 56            AND contas.documento_proprietario_conta = cc.documento_titular
 57        WHERE
 58            cc.nome_cartao = %s
 59            AND contas.proprietario_conta = %s
 60            AND contas.documento_proprietario_conta = %s;
 61        """
 62        selected_card_linked_account = (
 63            QueryExecutor().simple_consult_query(
 64                selected_card_linked_account_query,
 65                params=(
 66                    selected_card,
 67                    user_name,
 68                    user_document
 69                )
 70            )
 71        )
 72        selected_card_linked_account = QueryExecutor().treat_simple_result(
 73            selected_card_linked_account,
 74            to_remove_list
 75        )
 76
 77        month_data = selected_month.split()
 78        month_data.pop(1)
 79        month_data[1] = int(month_data[1])
 80
 81        month_name = month_data[0]
 82        month_year = month_data[1]
 83        
 84        months_abbreviation_dictionary = {
 85            "Janeiro": "Jan",
 86            "Fevereiro": "Fev",
 87            "Março": "Mar",
 88            "Abril": "Abr",
 89            "Maio": "Mai",
 90            "Junho": "Jun",
 91            "Julho": "Jul",
 92            "Agosto": "Ago",
 93            "Setembro": "Set",
 94            "Outubro": "Out",
 95            "Novembro": "Nov",
 96            "Dezembro": "Dez"
 97        }
 98        month_abbreviation = months_abbreviation_dictionary[month_name]
 99
100        return month_year, month_name, month_abbreviation, selected_card_linked_account
101
102    def show_expenses(
103            self,
104            selected_card: str,
105            selected_month: str,
106            column_disposition:
107            any
108    ):
109        """
110        Exibe as faturas de cartão que ainda não foram pagas.
111
112        Parameters
113        ----------
114        selected_card : str
115            O cartão de crédito selecionado pelo usuário.
116        selected_month : str
117            O mês da fatura selecionado pelo usuário.
118        """
119        user_name, user_document = Login().get_user_data(
120            return_option="user_doc_name"
121        )
122        logged_user, logged_user_password = Login().get_user_data(
123            return_option="user_login_password"
124        )
125
126        month_year, month_name, month_abbreviation, selected_card_linked_account = self.get_credit_card_expenses_data(selected_card, selected_month)
127
128        month_expenses = Credit_Card().month_expenses(
129            selected_card,
130            month_year,
131            month_name
132        )
133
134        str_month_expenses = Variable().treat_complex_string(month_expenses)
135
136        if month_expenses == 0:
137            with st.expander(label="Informação", expanded=True):
138                st.info(
139                    body="""
140                    Você não tem valores a pagar neste cartão no mês de {}.
141                    """.format(selected_month)
142                )
143
144        elif month_expenses > 0:
145            id_list = Credit_Card().get_card_id_month_expenses(
146                selected_card,
147                month_year, month_name
148            )
149            (
150                descricao_list,
151                valor_list,
152                data_list,
153                categoria_list,
154                parcela_list
155            ) = (
156                Credit_Card().get_complete_card_month_expenses(
157                    selected_card,
158                    month_year,
159                    month_name
160                )
161            )
162
163            credit_card_month_expenses_list_df = pd.DataFrame({
164                "Descrição": descricao_list,
165                "Valor": valor_list,
166                "Data": data_list,
167                "Categoria": categoria_list,
168                "Parcela": parcela_list, })
169            credit_card_month_expenses_list_df["Valor"] = (
170                credit_card_month_expenses_list_df["Valor"].apply(
171                    lambda x: f"R$ {x:.2f}".replace(".", ",")
172                )
173            )
174            credit_card_month_expenses_list_df["Data"] = pd.to_datetime(
175                credit_card_month_expenses_list_df["Data"]
176            ).dt.strftime("%d/%m/%Y")
177
178            st.subheader(
179                body=":credit_card: Fatura de {}".format(selected_month)
180            )
181
182            with st.expander(label="Valores", expanded=True):
183                st.info(
184                    body="""
185                    Valor total da fatura: :heavy_dollar_sign:{}
186                    """.format(str_month_expenses)
187                )
188                st.data_editor(
189                    credit_card_month_expenses_list_df,
190                    hide_index=True,
191                    use_container_width=True
192                )
193                confirm_values_checkbox = st.checkbox(
194                    label="Confirmar valores"
195                )
196
197            description = "Fatura {}/{}".format(month_abbreviation, month_year)
198            st.info(description)
199            actual_horary = GetActualTime().get_actual_time()
200
201            pay_button = st.button(label=":pencil: Pagar Fatura")
202            expense_query = """
203            INSERT INTO
204                despesas (
205                    descricao,
206                    valor,
207                    data,
208                    horario,
209                    categoria,
210                    conta,
211                    proprietario_despesa,
212                    documento_proprietario_despesa,
213                    pago
214                )
215            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s);
216            """
217            values = (
218                description,
219                month_expenses,
220                today,
221                actual_horary,
222                "Fatura Cartão",
223                selected_card_linked_account,
224                user_name,
225                user_document,
226                "S"
227            )
228
229            update_invoice_query = '''
230            UPDATE
231                fechamentos_cartao
232            SET fechado = 'S'
233            WHERE nome_cartao = '{}'
234                AND mes = '{}'
235                AND ano = '{}'
236                AND documento_titular = {};
237            '''.format(
238                selected_card,
239                selected_month,
240                actual_year,
241                user_document
242            )
243
244            if confirm_values_checkbox and pay_button:
245                QueryExecutor().update_table_registers(
246                    "despesas_cartao_credito",
247                    "despesa_cartao",
248                    id_list
249                )
250                QueryExecutor().insert_query(
251                    expense_query,
252                    values,
253                    "Fatura paga com sucesso!",
254                    "Erro ao pagar fatura:"
255                )
256                QueryExecutor().update_table_unique_register(
257                    update_invoice_query,
258                    "Fatura fechada com sucesso!",
259                    "Falha ao fechar fatura:"
260                )
261
262                str_value = Variable().treat_complex_string(month_expenses)
263
264                log_query = '''
265                INSERT INTO
266                    financas.logs_atividades (
267                        usuario_log,
268                        tipo_log,
269                        conteudo_log
270                    )
271                VALUES ( %s, %s, %s);
272                '''
273                log_values = (
274                    logged_user,
275                    "Registro",
276                    """
277                    Registrou uma despesa no valor de R$ {}
278                    associada a conta {}.""".format(
279                        str_value,
280                        selected_card
281                    )
282                )
283                QueryExecutor().insert_query(
284                    log_query,
285                    log_values,
286                    "Log gravado.",
287                    "Erro ao gravar log:"
288                )
289
290                with column_disposition:
291                    with st.spinner(text="Aguarde..."):
292                        sleep(2.5)
293                    st.subheader(
294                        body=":pencil: Comprovante de Pagamento"
295                    )
296                    with st.expander(label="Arquivo", expanded=True):
297                        Receipts().generate_receipt(
298                            "despesas",
299                            id_list[0],
300                            description="Fatura Cartão de {}".format(
301                                selected_month
302                            ),
303                            value=month_expenses,
304                            date=today,
305                            category="Fatura Cartão",
306                            account=selected_card_linked_account
307                        )
308
309    def main_menu(self):
310        """
311        Exibe as faturas de cartão que ainda não foram pagas.
312        """
313        user_name, user_document = Login().get_user_data(
314            return_option="user_doc_name"
315        )
316        logged_user, logged_user_password = Login().get_user_data(
317            return_option="user_login_password"
318        )
319
320        col1, col2, col3 = st.columns(3)
321
322        user_cards = QueryExecutor().complex_consult_query(
323            query=owner_cards_query,
324            params=(user_name, user_document)
325        )
326        user_cards = QueryExecutor().treat_numerous_simple_result(
327            user_cards, to_remove_list
328        )
329
330        if len(user_cards) == 0:
331            with col2:
332                st.info(body="Você ainda não possui cartões cadastrados.")
333
334        elif len(user_cards) >= 1:
335            with col3:
336                cl1, cl2 = st.columns(2)
337                with cl2:
338                    selected_card = st.selectbox(
339                        label="Selecione o cartão",
340                        options=user_cards
341                    )
342
343            card_invoices_data = QueryExecutor().complex_consult_query(
344                query=card_invoices_query,
345                params=(selected_card, user_name, user_document)
346            )
347            card_invoices_data = QueryExecutor().treat_numerous_simple_result(
348                card_invoices_data, to_remove_list
349            )
350
351            with cl2:
352                selected_month = st.selectbox(
353                    label="Selecione o mês", options=card_invoices_data
354                )
355
356            with col1:
357                self.show_expenses(
358                    selected_card,
359                    selected_month,
360                    column_disposition=col2
361                )
class CreditCardInvoice: 
 15class CreditCardInvoice:
 16    """
 17    Classe que representa as faturas de cartão.
 18    """
 19    def get_credit_card_expenses_data(
 20            self,
 21            selected_card: str,
 22            selected_month: str,
 23        ):
 24        """
 25        Realiza a consulta dos dados das despesas do cartão no mês.
 26
 27        Parameters
 28        ----------
 29        selected_card : str
 30            O cartão selecionado.
 31        selected_month: str
 32            O mês selecionado.
 33
 34        Returns
 35        -------
 36        month_year : str
 37            O ano do mês selecionado.
 38        month_name : str
 39            O mês selecionado.
 40        month_abbreviation : str
 41            A abreviação do mês.
 42        selected_card_linked_account : str
 43            A conta vinculada ao cartão.
 44        """
 45        user_name, user_document = Login().get_user_data(
 46            return_option="user_doc_name"
 47        )
 48
 49        selected_card_linked_account_query = """
 50        SELECT
 51            DISTINCT(cc.conta_associada)
 52        FROM
 53            contas
 54        INNER JOIN
 55            cartao_credito AS cc
 56            ON contas.proprietario_conta = cc.proprietario_cartao
 57            AND contas.documento_proprietario_conta = cc.documento_titular
 58        WHERE
 59            cc.nome_cartao = %s
 60            AND contas.proprietario_conta = %s
 61            AND contas.documento_proprietario_conta = %s;
 62        """
 63        selected_card_linked_account = (
 64            QueryExecutor().simple_consult_query(
 65                selected_card_linked_account_query,
 66                params=(
 67                    selected_card,
 68                    user_name,
 69                    user_document
 70                )
 71            )
 72        )
 73        selected_card_linked_account = QueryExecutor().treat_simple_result(
 74            selected_card_linked_account,
 75            to_remove_list
 76        )
 77
 78        month_data = selected_month.split()
 79        month_data.pop(1)
 80        month_data[1] = int(month_data[1])
 81
 82        month_name = month_data[0]
 83        month_year = month_data[1]
 84        
 85        months_abbreviation_dictionary = {
 86            "Janeiro": "Jan",
 87            "Fevereiro": "Fev",
 88            "Março": "Mar",
 89            "Abril": "Abr",
 90            "Maio": "Mai",
 91            "Junho": "Jun",
 92            "Julho": "Jul",
 93            "Agosto": "Ago",
 94            "Setembro": "Set",
 95            "Outubro": "Out",
 96            "Novembro": "Nov",
 97            "Dezembro": "Dez"
 98        }
 99        month_abbreviation = months_abbreviation_dictionary[month_name]
100
101        return month_year, month_name, month_abbreviation, selected_card_linked_account
102
103    def show_expenses(
104            self,
105            selected_card: str,
106            selected_month: str,
107            column_disposition:
108            any
109    ):
110        """
111        Exibe as faturas de cartão que ainda não foram pagas.
112
113        Parameters
114        ----------
115        selected_card : str
116            O cartão de crédito selecionado pelo usuário.
117        selected_month : str
118            O mês da fatura selecionado pelo usuário.
119        """
120        user_name, user_document = Login().get_user_data(
121            return_option="user_doc_name"
122        )
123        logged_user, logged_user_password = Login().get_user_data(
124            return_option="user_login_password"
125        )
126
127        month_year, month_name, month_abbreviation, selected_card_linked_account = self.get_credit_card_expenses_data(selected_card, selected_month)
128
129        month_expenses = Credit_Card().month_expenses(
130            selected_card,
131            month_year,
132            month_name
133        )
134
135        str_month_expenses = Variable().treat_complex_string(month_expenses)
136
137        if month_expenses == 0:
138            with st.expander(label="Informação", expanded=True):
139                st.info(
140                    body="""
141                    Você não tem valores a pagar neste cartão no mês de {}.
142                    """.format(selected_month)
143                )
144
145        elif month_expenses > 0:
146            id_list = Credit_Card().get_card_id_month_expenses(
147                selected_card,
148                month_year, month_name
149            )
150            (
151                descricao_list,
152                valor_list,
153                data_list,
154                categoria_list,
155                parcela_list
156            ) = (
157                Credit_Card().get_complete_card_month_expenses(
158                    selected_card,
159                    month_year,
160                    month_name
161                )
162            )
163
164            credit_card_month_expenses_list_df = pd.DataFrame({
165                "Descrição": descricao_list,
166                "Valor": valor_list,
167                "Data": data_list,
168                "Categoria": categoria_list,
169                "Parcela": parcela_list, })
170            credit_card_month_expenses_list_df["Valor"] = (
171                credit_card_month_expenses_list_df["Valor"].apply(
172                    lambda x: f"R$ {x:.2f}".replace(".", ",")
173                )
174            )
175            credit_card_month_expenses_list_df["Data"] = pd.to_datetime(
176                credit_card_month_expenses_list_df["Data"]
177            ).dt.strftime("%d/%m/%Y")
178
179            st.subheader(
180                body=":credit_card: Fatura de {}".format(selected_month)
181            )
182
183            with st.expander(label="Valores", expanded=True):
184                st.info(
185                    body="""
186                    Valor total da fatura: :heavy_dollar_sign:{}
187                    """.format(str_month_expenses)
188                )
189                st.data_editor(
190                    credit_card_month_expenses_list_df,
191                    hide_index=True,
192                    use_container_width=True
193                )
194                confirm_values_checkbox = st.checkbox(
195                    label="Confirmar valores"
196                )
197
198            description = "Fatura {}/{}".format(month_abbreviation, month_year)
199            st.info(description)
200            actual_horary = GetActualTime().get_actual_time()
201
202            pay_button = st.button(label=":pencil: Pagar Fatura")
203            expense_query = """
204            INSERT INTO
205                despesas (
206                    descricao,
207                    valor,
208                    data,
209                    horario,
210                    categoria,
211                    conta,
212                    proprietario_despesa,
213                    documento_proprietario_despesa,
214                    pago
215                )
216            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s);
217            """
218            values = (
219                description,
220                month_expenses,
221                today,
222                actual_horary,
223                "Fatura Cartão",
224                selected_card_linked_account,
225                user_name,
226                user_document,
227                "S"
228            )
229
230            update_invoice_query = '''
231            UPDATE
232                fechamentos_cartao
233            SET fechado = 'S'
234            WHERE nome_cartao = '{}'
235                AND mes = '{}'
236                AND ano = '{}'
237                AND documento_titular = {};
238            '''.format(
239                selected_card,
240                selected_month,
241                actual_year,
242                user_document
243            )
244
245            if confirm_values_checkbox and pay_button:
246                QueryExecutor().update_table_registers(
247                    "despesas_cartao_credito",
248                    "despesa_cartao",
249                    id_list
250                )
251                QueryExecutor().insert_query(
252                    expense_query,
253                    values,
254                    "Fatura paga com sucesso!",
255                    "Erro ao pagar fatura:"
256                )
257                QueryExecutor().update_table_unique_register(
258                    update_invoice_query,
259                    "Fatura fechada com sucesso!",
260                    "Falha ao fechar fatura:"
261                )
262
263                str_value = Variable().treat_complex_string(month_expenses)
264
265                log_query = '''
266                INSERT INTO
267                    financas.logs_atividades (
268                        usuario_log,
269                        tipo_log,
270                        conteudo_log
271                    )
272                VALUES ( %s, %s, %s);
273                '''
274                log_values = (
275                    logged_user,
276                    "Registro",
277                    """
278                    Registrou uma despesa no valor de R$ {}
279                    associada a conta {}.""".format(
280                        str_value,
281                        selected_card
282                    )
283                )
284                QueryExecutor().insert_query(
285                    log_query,
286                    log_values,
287                    "Log gravado.",
288                    "Erro ao gravar log:"
289                )
290
291                with column_disposition:
292                    with st.spinner(text="Aguarde..."):
293                        sleep(2.5)
294                    st.subheader(
295                        body=":pencil: Comprovante de Pagamento"
296                    )
297                    with st.expander(label="Arquivo", expanded=True):
298                        Receipts().generate_receipt(
299                            "despesas",
300                            id_list[0],
301                            description="Fatura Cartão de {}".format(
302                                selected_month
303                            ),
304                            value=month_expenses,
305                            date=today,
306                            category="Fatura Cartão",
307                            account=selected_card_linked_account
308                        )
309
310    def main_menu(self):
311        """
312        Exibe as faturas de cartão que ainda não foram pagas.
313        """
314        user_name, user_document = Login().get_user_data(
315            return_option="user_doc_name"
316        )
317        logged_user, logged_user_password = Login().get_user_data(
318            return_option="user_login_password"
319        )
320
321        col1, col2, col3 = st.columns(3)
322
323        user_cards = QueryExecutor().complex_consult_query(
324            query=owner_cards_query,
325            params=(user_name, user_document)
326        )
327        user_cards = QueryExecutor().treat_numerous_simple_result(
328            user_cards, to_remove_list
329        )
330
331        if len(user_cards) == 0:
332            with col2:
333                st.info(body="Você ainda não possui cartões cadastrados.")
334
335        elif len(user_cards) >= 1:
336            with col3:
337                cl1, cl2 = st.columns(2)
338                with cl2:
339                    selected_card = st.selectbox(
340                        label="Selecione o cartão",
341                        options=user_cards
342                    )
343
344            card_invoices_data = QueryExecutor().complex_consult_query(
345                query=card_invoices_query,
346                params=(selected_card, user_name, user_document)
347            )
348            card_invoices_data = QueryExecutor().treat_numerous_simple_result(
349                card_invoices_data, to_remove_list
350            )
351
352            with cl2:
353                selected_month = st.selectbox(
354                    label="Selecione o mês", options=card_invoices_data
355                )
356
357            with col1:
358                self.show_expenses(
359                    selected_card,
360                    selected_month,
361                    column_disposition=col2
362                )

Classe que representa as faturas de cartão.

def get_credit_card_expenses_data(self, selected_card: str, selected_month: str): 
 19    def get_credit_card_expenses_data(
 20            self,
 21            selected_card: str,
 22            selected_month: str,
 23        ):
 24        """
 25        Realiza a consulta dos dados das despesas do cartão no mês.
 26
 27        Parameters
 28        ----------
 29        selected_card : str
 30            O cartão selecionado.
 31        selected_month: str
 32            O mês selecionado.
 33
 34        Returns
 35        -------
 36        month_year : str
 37            O ano do mês selecionado.
 38        month_name : str
 39            O mês selecionado.
 40        month_abbreviation : str
 41            A abreviação do mês.
 42        selected_card_linked_account : str
 43            A conta vinculada ao cartão.
 44        """
 45        user_name, user_document = Login().get_user_data(
 46            return_option="user_doc_name"
 47        )
 48
 49        selected_card_linked_account_query = """
 50        SELECT
 51            DISTINCT(cc.conta_associada)
 52        FROM
 53            contas
 54        INNER JOIN
 55            cartao_credito AS cc
 56            ON contas.proprietario_conta = cc.proprietario_cartao
 57            AND contas.documento_proprietario_conta = cc.documento_titular
 58        WHERE
 59            cc.nome_cartao = %s
 60            AND contas.proprietario_conta = %s
 61            AND contas.documento_proprietario_conta = %s;
 62        """
 63        selected_card_linked_account = (
 64            QueryExecutor().simple_consult_query(
 65                selected_card_linked_account_query,
 66                params=(
 67                    selected_card,
 68                    user_name,
 69                    user_document
 70                )
 71            )
 72        )
 73        selected_card_linked_account = QueryExecutor().treat_simple_result(
 74            selected_card_linked_account,
 75            to_remove_list
 76        )
 77
 78        month_data = selected_month.split()
 79        month_data.pop(1)
 80        month_data[1] = int(month_data[1])
 81
 82        month_name = month_data[0]
 83        month_year = month_data[1]
 84        
 85        months_abbreviation_dictionary = {
 86            "Janeiro": "Jan",
 87            "Fevereiro": "Fev",
 88            "Março": "Mar",
 89            "Abril": "Abr",
 90            "Maio": "Mai",
 91            "Junho": "Jun",
 92            "Julho": "Jul",
 93            "Agosto": "Ago",
 94            "Setembro": "Set",
 95            "Outubro": "Out",
 96            "Novembro": "Nov",
 97            "Dezembro": "Dez"
 98        }
 99        month_abbreviation = months_abbreviation_dictionary[month_name]
100
101        return month_year, month_name, month_abbreviation, selected_card_linked_account

Realiza a consulta dos dados das despesas do cartão no mês.

Parameters
  • selected_card (str): O cartão selecionado.
  • selected_month (str): O mês selecionado.
Returns
  • month_year (str): O ano do mês selecionado.
  • month_name (str): O mês selecionado.
  • month_abbreviation (str): A abreviação do mês.
  • selected_card_linked_account (str): A conta vinculada ao cartão.
def show_expenses( self, selected_card: str, selected_month: str, column_disposition: <built-in function any>): 
103    def show_expenses(
104            self,
105            selected_card: str,
106            selected_month: str,
107            column_disposition:
108            any
109    ):
110        """
111        Exibe as faturas de cartão que ainda não foram pagas.
112
113        Parameters
114        ----------
115        selected_card : str
116            O cartão de crédito selecionado pelo usuário.
117        selected_month : str
118            O mês da fatura selecionado pelo usuário.
119        """
120        user_name, user_document = Login().get_user_data(
121            return_option="user_doc_name"
122        )
123        logged_user, logged_user_password = Login().get_user_data(
124            return_option="user_login_password"
125        )
126
127        month_year, month_name, month_abbreviation, selected_card_linked_account = self.get_credit_card_expenses_data(selected_card, selected_month)
128
129        month_expenses = Credit_Card().month_expenses(
130            selected_card,
131            month_year,
132            month_name
133        )
134
135        str_month_expenses = Variable().treat_complex_string(month_expenses)
136
137        if month_expenses == 0:
138            with st.expander(label="Informação", expanded=True):
139                st.info(
140                    body="""
141                    Você não tem valores a pagar neste cartão no mês de {}.
142                    """.format(selected_month)
143                )
144
145        elif month_expenses > 0:
146            id_list = Credit_Card().get_card_id_month_expenses(
147                selected_card,
148                month_year, month_name
149            )
150            (
151                descricao_list,
152                valor_list,
153                data_list,
154                categoria_list,
155                parcela_list
156            ) = (
157                Credit_Card().get_complete_card_month_expenses(
158                    selected_card,
159                    month_year,
160                    month_name
161                )
162            )
163
164            credit_card_month_expenses_list_df = pd.DataFrame({
165                "Descrição": descricao_list,
166                "Valor": valor_list,
167                "Data": data_list,
168                "Categoria": categoria_list,
169                "Parcela": parcela_list, })
170            credit_card_month_expenses_list_df["Valor"] = (
171                credit_card_month_expenses_list_df["Valor"].apply(
172                    lambda x: f"R$ {x:.2f}".replace(".", ",")
173                )
174            )
175            credit_card_month_expenses_list_df["Data"] = pd.to_datetime(
176                credit_card_month_expenses_list_df["Data"]
177            ).dt.strftime("%d/%m/%Y")
178
179            st.subheader(
180                body=":credit_card: Fatura de {}".format(selected_month)
181            )
182
183            with st.expander(label="Valores", expanded=True):
184                st.info(
185                    body="""
186                    Valor total da fatura: :heavy_dollar_sign:{}
187                    """.format(str_month_expenses)
188                )
189                st.data_editor(
190                    credit_card_month_expenses_list_df,
191                    hide_index=True,
192                    use_container_width=True
193                )
194                confirm_values_checkbox = st.checkbox(
195                    label="Confirmar valores"
196                )
197
198            description = "Fatura {}/{}".format(month_abbreviation, month_year)
199            st.info(description)
200            actual_horary = GetActualTime().get_actual_time()
201
202            pay_button = st.button(label=":pencil: Pagar Fatura")
203            expense_query = """
204            INSERT INTO
205                despesas (
206                    descricao,
207                    valor,
208                    data,
209                    horario,
210                    categoria,
211                    conta,
212                    proprietario_despesa,
213                    documento_proprietario_despesa,
214                    pago
215                )
216            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s);
217            """
218            values = (
219                description,
220                month_expenses,
221                today,
222                actual_horary,
223                "Fatura Cartão",
224                selected_card_linked_account,
225                user_name,
226                user_document,
227                "S"
228            )
229
230            update_invoice_query = '''
231            UPDATE
232                fechamentos_cartao
233            SET fechado = 'S'
234            WHERE nome_cartao = '{}'
235                AND mes = '{}'
236                AND ano = '{}'
237                AND documento_titular = {};
238            '''.format(
239                selected_card,
240                selected_month,
241                actual_year,
242                user_document
243            )
244
245            if confirm_values_checkbox and pay_button:
246                QueryExecutor().update_table_registers(
247                    "despesas_cartao_credito",
248                    "despesa_cartao",
249                    id_list
250                )
251                QueryExecutor().insert_query(
252                    expense_query,
253                    values,
254                    "Fatura paga com sucesso!",
255                    "Erro ao pagar fatura:"
256                )
257                QueryExecutor().update_table_unique_register(
258                    update_invoice_query,
259                    "Fatura fechada com sucesso!",
260                    "Falha ao fechar fatura:"
261                )
262
263                str_value = Variable().treat_complex_string(month_expenses)
264
265                log_query = '''
266                INSERT INTO
267                    financas.logs_atividades (
268                        usuario_log,
269                        tipo_log,
270                        conteudo_log
271                    )
272                VALUES ( %s, %s, %s);
273                '''
274                log_values = (
275                    logged_user,
276                    "Registro",
277                    """
278                    Registrou uma despesa no valor de R$ {}
279                    associada a conta {}.""".format(
280                        str_value,
281                        selected_card
282                    )
283                )
284                QueryExecutor().insert_query(
285                    log_query,
286                    log_values,
287                    "Log gravado.",
288                    "Erro ao gravar log:"
289                )
290
291                with column_disposition:
292                    with st.spinner(text="Aguarde..."):
293                        sleep(2.5)
294                    st.subheader(
295                        body=":pencil: Comprovante de Pagamento"
296                    )
297                    with st.expander(label="Arquivo", expanded=True):
298                        Receipts().generate_receipt(
299                            "despesas",
300                            id_list[0],
301                            description="Fatura Cartão de {}".format(
302                                selected_month
303                            ),
304                            value=month_expenses,
305                            date=today,
306                            category="Fatura Cartão",
307                            account=selected_card_linked_account
308                        )

Exibe as faturas de cartão que ainda não foram pagas.

Parameters
  • selected_card (str): O cartão de crédito selecionado pelo usuário.
  • selected_month (str): O mês da fatura selecionado pelo usuário.
def main_menu(self): 
310    def main_menu(self):
311        """
312        Exibe as faturas de cartão que ainda não foram pagas.
313        """
314        user_name, user_document = Login().get_user_data(
315            return_option="user_doc_name"
316        )
317        logged_user, logged_user_password = Login().get_user_data(
318            return_option="user_login_password"
319        )
320
321        col1, col2, col3 = st.columns(3)
322
323        user_cards = QueryExecutor().complex_consult_query(
324            query=owner_cards_query,
325            params=(user_name, user_document)
326        )
327        user_cards = QueryExecutor().treat_numerous_simple_result(
328            user_cards, to_remove_list
329        )
330
331        if len(user_cards) == 0:
332            with col2:
333                st.info(body="Você ainda não possui cartões cadastrados.")
334
335        elif len(user_cards) >= 1:
336            with col3:
337                cl1, cl2 = st.columns(2)
338                with cl2:
339                    selected_card = st.selectbox(
340                        label="Selecione o cartão",
341                        options=user_cards
342                    )
343
344            card_invoices_data = QueryExecutor().complex_consult_query(
345                query=card_invoices_query,
346                params=(selected_card, user_name, user_document)
347            )
348            card_invoices_data = QueryExecutor().treat_numerous_simple_result(
349                card_invoices_data, to_remove_list
350            )
351
352            with cl2:
353                selected_month = st.selectbox(
354                    label="Selecione o mês", options=card_invoices_data
355                )
356
357            with col1:
358                self.show_expenses(
359                    selected_card,
360                    selected_month,
361                    column_disposition=col2
362                )

Exibe as faturas de cartão que ainda não foram pagas.