Google-Sheets-System.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b812efac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['Estado', 'Cidade', 'Vendedor', 'Produto', 'Preço'],\n",
       " ['São Paulo', 'Osasco', 'Allan', 'Escova', '21'],\n",
       " ['São Paulo', 'Campinas', 'Joana', 'Blusa', '120'],\n",
       " ['Rio de Janeiro', 'Niterói', 'Paulo', 'Calças jeans', '130'],\n",
       " ['Santa Catarina', 'Florianópolis', 'Maria', 'Bermuda', '45'],\n",
       " ['São Paulo', 'Santos', 'Lucas', 'Vestido', '200'],\n",
       " ['São Paulo', 'Osasco', 'Ana', 'Jaqueta', '130'],\n",
       " ['São Paulo', 'Campinas', 'Rafael', 'Regata', '38'],\n",
       " ['São Paulo', 'Osasco', 'Fabiana', 'Roupa íntima', '25'],\n",
       " ['Santa Catarina', 'Florianópolis', 'Gustavo', 'Meia', '15'],\n",
       " ['Santa Catarina', 'Joinville', 'Carolina', 'Boné', '34'],\n",
       " ['Rio de Janeiro', 'Petrópolis', 'Diego', 'Camiseta', '18'],\n",
       " ['Santa Catarina', 'Florianópolis', 'Bruno', 'Blusa', '32'],\n",
       " ['São Paulo', 'Santos', 'Mariana', 'Calças jeans', '29'],\n",
       " ['São Paulo', 'Campinas', 'Thiago', 'Bermuda', '30'],\n",
       " ['Santa Catarina', 'Blumenau', 'Laura', 'Vestido', '31'],\n",
       " ['Paraná', 'Curitiba', 'Ana', 'Jaqueta', '130'],\n",
       " ['Santa Catarina', 'Blumenau', 'Cintia', 'Vestido', '300'],\n",
       " ['São Paulo', 'Osasco', 'Allan', 'Escova', '21']]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from __future__ import print_function\n",
    "\n",
    "import os.path\n",
    "\n",
    "from google.auth.transport.requests import Request\n",
    "from google.oauth2.credentials import Credentials\n",
    "from google_auth_oauthlib.flow import InstalledAppFlow\n",
    "from googleapiclient.discovery import build\n",
    "from googleapiclient.errors import HttpError\n",
    "\n",
    "# If modifying these scopes, delete the file token.json.\n",
    "SCOPES = ['https://www.googleapis.com/auth/spreadsheets']\n",
    "\n",
    "# The ID and range of a sample spreadsheet.\n",
    "SAMPLE_SPREADSHEET_ID = '1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM'\n",
    "SAMPLE_RANGE_NAME = 'Dados!A1:E'\n",
    "\n",
    "#https://docs.google.com/spreadsheets/d/1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM/edit?usp=sharing\n",
    "\n",
    "def main():\n",
    "    \"\"\"Shows basic usage of the Sheets API.\n",
    "    Prints values from a sample spreadsheet.\n",
    "    \"\"\"\n",
    "    creds = None\n",
    "    # The file token.json stores the user's access and refresh tokens, and is\n",
    "    # created automatically when the authorization flow completes for the first\n",
    "    # time.\n",
    "    if os.path.exists('token.json'):\n",
    "        creds = Credentials.from_authorized_user_file('token.json', SCOPES)\n",
    "    # If there are no (valid) credentials available, let the user log in.\n",
    "    if not creds or not creds.valid:\n",
    "        if creds and creds.expired and creds.refresh_token:\n",
    "            creds.refresh(Request())\n",
    "        else:\n",
    "            flow = InstalledAppFlow.from_client_secrets_file(\n",
    "                'credentials.json', SCOPES)\n",
    "            creds = flow.run_local_server(port=0)\n",
    "        # Save the credentials for the next run\n",
    "        with open('token.json', 'w') as token:\n",
    "            token.write(creds.to_json())\n",
    "\n",
    "    try:\n",
    "        service = build('sheets', 'v4', credentials=creds)\n",
    "\n",
    "        # Call the Sheets API\n",
    "        sheet = service.spreadsheets()\n",
    "        result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                  range=SAMPLE_RANGE_NAME).execute()\n",
    "        \n",
    "        #Lê os dados da planilha do google sheets\n",
    "        valores = result.get('values', [])\n",
    "        \n",
    "        display(valores)\n",
    "\n",
    "        \n",
    "    except HttpError as err:\n",
    "        print(err)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecff3cd8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "30a65663",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['Estado', 'Cidade', 'Vendedor', 'Produto', 'Preço'],\n",
       " ['São Paulo', 'Osasco', 'Allan', 'Escova', '21'],\n",
       " ['São Paulo', 'Campinas', 'Joana', 'Blusa', '120'],\n",
       " ['Rio de Janeiro', 'Niterói', 'Paulo', 'Calças jeans', '130'],\n",
       " ['Santa Catarina', 'Florianópolis', 'Maria', 'Bermuda', '45'],\n",
       " ['São Paulo', 'Santos', 'Lucas', 'Vestido', '200'],\n",
       " ['São Paulo', 'Osasco', 'Ana', 'Jaqueta', '130'],\n",
       " ['São Paulo', 'Campinas', 'Rafael', 'Regata', '38'],\n",
       " ['São Paulo', 'Osasco', 'Fabiana', 'Roupa íntima', '25'],\n",
       " ['Santa Catarina', 'Florianópolis', 'Gustavo', 'Meia', '15'],\n",
       " ['Santa Catarina', 'Joinville', 'Carolina', 'Boné', '34'],\n",
       " ['Rio de Janeiro', 'Petrópolis', 'Diego', 'Camiseta', '18'],\n",
       " ['Santa Catarina', 'Florianópolis', 'Bruno', 'Blusa', '32'],\n",
       " ['São Paulo', 'Santos', 'Mariana', 'Calças jeans', '29'],\n",
       " ['São Paulo', 'Campinas', 'Thiago', 'Bermuda', '30'],\n",
       " ['Santa Catarina', 'Blumenau', 'Laura', 'Vestido', '31'],\n",
       " ['Paraná', 'Curitiba', 'Ana', 'Jaqueta', '130'],\n",
       " ['Santa Catarina', 'Blumenau', 'Cintia', 'Vestido', '300'],\n",
       " ['São Paulo', 'Osasco', 'Allan', 'Escova', '21']]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tkinter import *\n",
    "from tkinter import ttk\n",
    "import os.path\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "import os.path\n",
    "\n",
    "from google.auth.transport.requests import Request\n",
    "from google.oauth2.credentials import Credentials\n",
    "from google_auth_oauthlib.flow import InstalledAppFlow\n",
    "from googleapiclient.discovery import build\n",
    "from googleapiclient.errors import HttpError\n",
    "\n",
    "# If modifying these scopes, delete the file token.json.\n",
    "SCOPES = ['https://www.googleapis.com/auth/spreadsheets']\n",
    "\n",
    "# The ID and range of a sample spreadsheet.\n",
    "SAMPLE_SPREADSHEET_ID = '1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM'\n",
    "SAMPLE_RANGE_NAME = 'Dados!A1:E'\n",
    "\n",
    "#https://docs.google.com/spreadsheets/d/1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM/edit?usp=sharing\n",
    "\n",
    "def main():\n",
    "    \"\"\"Shows basic usage of the Sheets API.\n",
    "    Prints values from a sample spreadsheet.\n",
    "    \"\"\"\n",
    "    creds = None\n",
    "    # The file token.json stores the user's access and refresh tokens, and is\n",
    "    # created automatically when the authorization flow completes for the first\n",
    "    # time.\n",
    "    if os.path.exists('token.json'):\n",
    "        creds = Credentials.from_authorized_user_file('token.json', SCOPES)\n",
    "    # If there are no (valid) credentials available, let the user log in.\n",
    "    if not creds or not creds.valid:\n",
    "        if creds and creds.expired and creds.refresh_token:\n",
    "            creds.refresh(Request())\n",
    "        else:\n",
    "            flow = InstalledAppFlow.from_client_secrets_file(\n",
    "                'credentials.json', SCOPES)\n",
    "            creds = flow.run_local_server(port=0)\n",
    "        # Save the credentials for the next run\n",
    "        with open('token.json', 'w') as token:\n",
    "            token.write(creds.to_json())\n",
    "\n",
    "    try:\n",
    "        service = build('sheets', 'v4', credentials=creds)\n",
    "\n",
    "        # Call the Sheets API\n",
    "        sheet = service.spreadsheets()\n",
    "        result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                  range=SAMPLE_RANGE_NAME).execute()\n",
    "        \n",
    "        #Lê os dados da planilha do google sheets\n",
    "        valores = result.get('values', [])\n",
    "        \n",
    "        display(valores)\n",
    "        \n",
    "        #Criando a janela do Tkinter\n",
    "        root = Tk()\n",
    "        root.title(\"Sistema Google Sheets\")\n",
    "        \n",
    "        #Cria uma treeview para exibir os dados da planilha\n",
    "        tree = ttk.Treeview(root)\n",
    "                \n",
    "        #Define as colunas da Treeview com base nos valores da linha 1 da planilha\n",
    "        colunas = valores[0]\n",
    "        tree[\"columns\"] = colunas\n",
    "        \n",
    "        #for - para\n",
    "        #Define o cabeçalho da Treeview\n",
    "        for linha in colunas:\n",
    "            tree.heading(linha, text=linha)\n",
    "        \n",
    "        #Adiciona os valores da planilha à Treeview\n",
    "        for row in valores[1:]:\n",
    "            tree.insert(\"\", \"end\", values=row)\n",
    "            \n",
    "        #Exibe a Treeview\n",
    "        tree.pack()\n",
    "        \n",
    "        #Exibo a tela\n",
    "        root.mainloop()\n",
    "\n",
    "        \n",
    "    except HttpError as err:\n",
    "        print(err)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d1d46e1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "79ef1771",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "from tkinter import ttk\n",
    "import os.path\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "import os.path\n",
    "\n",
    "from google.auth.transport.requests import Request\n",
    "from google.oauth2.credentials import Credentials\n",
    "from google_auth_oauthlib.flow import InstalledAppFlow\n",
    "from googleapiclient.discovery import build\n",
    "from googleapiclient.errors import HttpError\n",
    "\n",
    "# If modifying these scopes, delete the file token.json.\n",
    "SCOPES = ['https://www.googleapis.com/auth/spreadsheets']\n",
    "\n",
    "# The ID and range of a sample spreadsheet.\n",
    "SAMPLE_SPREADSHEET_ID = '1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM'\n",
    "SAMPLE_RANGE_NAME = 'Dados!A1:E'\n",
    "\n",
    "#https://docs.google.com/spreadsheets/d/1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM/edit?usp=sharing\n",
    "\n",
    "def main():\n",
    "    \"\"\"Shows basic usage of the Sheets API.\n",
    "    Prints values from a sample spreadsheet.\n",
    "    \"\"\"\n",
    "    creds = None\n",
    "    # The file token.json stores the user's access and refresh tokens, and is\n",
    "    # created automatically when the authorization flow completes for the first\n",
    "    # time.\n",
    "    if os.path.exists('token.json'):\n",
    "        creds = Credentials.from_authorized_user_file('token.json', SCOPES)\n",
    "    # If there are no (valid) credentials available, let the user log in.\n",
    "    if not creds or not creds.valid:\n",
    "        if creds and creds.expired and creds.refresh_token:\n",
    "            creds.refresh(Request())\n",
    "        else:\n",
    "            flow = InstalledAppFlow.from_client_secrets_file(\n",
    "                'credentials.json', SCOPES)\n",
    "            creds = flow.run_local_server(port=0)\n",
    "        # Save the credentials for the next run\n",
    "        with open('token.json', 'w') as token:\n",
    "            token.write(creds.to_json())\n",
    "\n",
    "    try:\n",
    "        service = build('sheets', 'v4', credentials=creds)\n",
    "\n",
    "        # Call the Sheets API\n",
    "        sheet = service.spreadsheets()\n",
    "        result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                  range=SAMPLE_RANGE_NAME).execute()\n",
    "        \n",
    "        #Lê os dados da planilha do google sheets\n",
    "        valores = result.get('values', [])\n",
    "        \n",
    "              \n",
    "        #Criando a janela do Tkinter\n",
    "        root = Tk()\n",
    "        root.title(\"Sistema Google Sheets\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        estado_label = Label(root, text=\"Estado:\", font=\"Arial 14\")\n",
    "        estado_label.grid(row=0, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna A a partir da segunda linha\n",
    "        estados = sorted(list(set(value[0] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        estado_combobox = ttk.Combobox(root, values=estados, font=\"Arial 14\")\n",
    "        estado_combobox.grid(row=1, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        cidade_label = Label(root, text=\"Cidade:\", font=\"Arial 14\")\n",
    "        cidade_label.grid(row=0, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna B a partir da segunda linha\n",
    "        cidades = sorted(list(set(value[1] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        cidade_combobox = ttk.Combobox(root, values=cidades, font=\"Arial 14\")\n",
    "        cidade_combobox.grid(row=1, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        vendedor_label = Label(root, text=\"Vendedor:\", font=\"Arial 14\")\n",
    "        vendedor_label.grid(row=0, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna C a partir da segunda linha\n",
    "        vendedores = sorted(list(set(value[2] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        vendedor_combobox = ttk.Combobox(root, values=vendedores, font=\"Arial 14\")\n",
    "        vendedor_combobox.grid(row=1, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        produto_label = Label(root, text=\"Produto:\", font=\"Arial 14\")\n",
    "        produto_label.grid(row=0, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna D a partir da segunda linha\n",
    "        produtos = sorted(list(set(value[3] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        produtos_combobox = ttk.Combobox(root, values=produtos, font=\"Arial 14\")\n",
    "        produtos_combobox.grid(row=1, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Cria uma treeview para exibir os dados da planilha\n",
    "        tree = ttk.Treeview(root)\n",
    "                \n",
    "        #Define as colunas da Treeview com base nos valores da linha 1 da planilha\n",
    "        colunas = valores[0]\n",
    "        tree[\"columns\"] = colunas\n",
    "        \n",
    "        #for - para\n",
    "        #Define o cabeçalho da Treeview\n",
    "        for linha in colunas:\n",
    "            tree.heading(linha, text=linha)\n",
    "        \n",
    "        #Adiciona os valores da planilha à Treeview\n",
    "        for row in valores[1:]:\n",
    "            tree.insert(\"\", \"end\", values=row)\n",
    "            \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena parte como se fosse uma planilha\n",
    "        tree.grid(row=3, column=0, columnspan=6, padx=5, pady=5, stick=\"NSEW\")\n",
    "        \n",
    "        #Exibo a tela\n",
    "        root.mainloop()\n",
    "\n",
    "        \n",
    "    except HttpError as err:\n",
    "        print(err)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eade7125",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4f414d38",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "from tkinter import ttk\n",
    "import os.path\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "import os.path\n",
    "\n",
    "from google.auth.transport.requests import Request\n",
    "from google.oauth2.credentials import Credentials\n",
    "from google_auth_oauthlib.flow import InstalledAppFlow\n",
    "from googleapiclient.discovery import build\n",
    "from googleapiclient.errors import HttpError\n",
    "\n",
    "# If modifying these scopes, delete the file token.json.\n",
    "SCOPES = ['https://www.googleapis.com/auth/spreadsheets']\n",
    "\n",
    "# The ID and range of a sample spreadsheet.\n",
    "SAMPLE_SPREADSHEET_ID = '1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM'\n",
    "SAMPLE_RANGE_NAME = 'Dados!A1:E'\n",
    "\n",
    "#https://docs.google.com/spreadsheets/d/1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM/edit?usp=sharing\n",
    "\n",
    "def main():\n",
    "    \"\"\"Shows basic usage of the Sheets API.\n",
    "    Prints values from a sample spreadsheet.\n",
    "    \"\"\"\n",
    "    creds = None\n",
    "    # The file token.json stores the user's access and refresh tokens, and is\n",
    "    # created automatically when the authorization flow completes for the first\n",
    "    # time.\n",
    "    if os.path.exists('token.json'):\n",
    "        creds = Credentials.from_authorized_user_file('token.json', SCOPES)\n",
    "    # If there are no (valid) credentials available, let the user log in.\n",
    "    if not creds or not creds.valid:\n",
    "        if creds and creds.expired and creds.refresh_token:\n",
    "            creds.refresh(Request())\n",
    "        else:\n",
    "            flow = InstalledAppFlow.from_client_secrets_file(\n",
    "                'credentials.json', SCOPES)\n",
    "            creds = flow.run_local_server(port=0)\n",
    "        # Save the credentials for the next run\n",
    "        with open('token.json', 'w') as token:\n",
    "            token.write(creds.to_json())\n",
    "\n",
    "    try:\n",
    "        service = build('sheets', 'v4', credentials=creds)\n",
    "\n",
    "        # Call the Sheets API\n",
    "        sheet = service.spreadsheets()\n",
    "        result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                  range=SAMPLE_RANGE_NAME).execute()\n",
    "        \n",
    "        #Lê os dados da planilha do google sheets\n",
    "        valores = result.get('values', [])\n",
    "        \n",
    "              \n",
    "        #Criando a janela do Tkinter\n",
    "        root = Tk()\n",
    "        root.title(\"Sistema Google Sheets\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        estado_label = Label(root, text=\"Estado:\", font=\"Arial 14\")\n",
    "        estado_label.grid(row=0, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna A a partir da segunda linha\n",
    "        estados = sorted(list(set(value[0] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        estado_combobox = ttk.Combobox(root, values=estados, font=\"Arial 14\")\n",
    "        estado_combobox.grid(row=1, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        cidade_label = Label(root, text=\"Cidade:\", font=\"Arial 14\")\n",
    "        cidade_label.grid(row=0, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna B a partir da segunda linha\n",
    "        cidades = sorted(list(set(value[1] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        cidade_combobox = ttk.Combobox(root, values=cidades, font=\"Arial 14\")\n",
    "        cidade_combobox.grid(row=1, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        vendedor_label = Label(root, text=\"Vendedor:\", font=\"Arial 14\")\n",
    "        vendedor_label.grid(row=0, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna C a partir da segunda linha\n",
    "        vendedores = sorted(list(set(value[2] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        vendedor_combobox = ttk.Combobox(root, values=vendedores, font=\"Arial 14\")\n",
    "        vendedor_combobox.grid(row=1, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        produto_label = Label(root, text=\"Produto:\", font=\"Arial 14\")\n",
    "        produto_label.grid(row=0, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna D a partir da segunda linha\n",
    "        produtos = sorted(list(set(value[3] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        produtos_combobox = ttk.Combobox(root, values=produtos, font=\"Arial 14\")\n",
    "        produtos_combobox.grid(row=1, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Cria uma treeview para exibir os dados da planilha\n",
    "        tree = ttk.Treeview(root)\n",
    "                \n",
    "        #Define as colunas da Treeview com base nos valores da linha 1 da planilha\n",
    "        colunas = valores[0]\n",
    "        tree[\"columns\"] = colunas\n",
    "        \n",
    "        #for - para\n",
    "        #Define o cabeçalho da Treeview\n",
    "        for linha in colunas:\n",
    "            tree.heading(linha, text=linha)\n",
    "        \n",
    "        #Adiciona os valores da planilha à Treeview\n",
    "        for row in valores[1:]:\n",
    "            tree.insert(\"\", \"end\", values=row)\n",
    "            \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena parte como se fosse uma planilha\n",
    "        tree.grid(row=3, column=0, columnspan=6, padx=5, pady=5, stick=\"NSEW\")\n",
    "        \n",
    "        #Função que filtra os dados\n",
    "        def filtro():\n",
    "            \n",
    "            #Lê as informações da planilha\n",
    "            sheet = service.spreadsheets()\n",
    "            result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                      range=SAMPLE_RANGE_NAME).execute()\n",
    "\n",
    "            #Lê os dados da planilha do google sheets\n",
    "            valores = result['values']\n",
    "            \n",
    "            #Opçoes filtro pega o texto das combobox\n",
    "            estado = estado_combobox.get()\n",
    "            cidade = cidade_combobox.get()\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            produto = produtos_combobox.get()\n",
    "            \n",
    "            dados_filtrados = [valores[0]] #Inclui a linha do cabeçalho\n",
    "            for row in valores[1:]:\n",
    "                \n",
    "                if(not estado or row[0] == estado) and \\\n",
    "                    (not cidade or row[1] == cidade) and \\\n",
    "                    (not vendedor or row[2] == vendedor) and \\\n",
    "                    (not produto or row[3] == produto) and \\\n",
    "                    (not estado or row[0] == estado) :\n",
    "                    dados_filtrados.append(row)\n",
    "            \n",
    "            #Limpa os dados\n",
    "            for row in tree.get_children():\n",
    "                tree.delete(row)\n",
    "                \n",
    "            #Atualiza os dados da treeview\n",
    "            for row in dados_filtrados[1:]:\n",
    "                tree.insert(\"\", \"end\", values=row) \n",
    "                \n",
    "        #Cria botão Filtro\n",
    "        botao_filtrar = Button(root, text=\"Filtrar\", font=\"Arial 14\", command=filtro)\n",
    "        botao_filtrar.grid(row=4, column=1, padx=2, pady=2, stick=\"NSEW\")        \n",
    "            \n",
    "            \n",
    "        \n",
    "        #Exibo a tela\n",
    "        root.mainloop()\n",
    "\n",
    "        \n",
    "    except HttpError as err:\n",
    "        print(err)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ffd01669",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b21a2fb1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "from tkinter import ttk\n",
    "import os.path\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "import os.path\n",
    "\n",
    "from google.auth.transport.requests import Request\n",
    "from google.oauth2.credentials import Credentials\n",
    "from google_auth_oauthlib.flow import InstalledAppFlow\n",
    "from googleapiclient.discovery import build\n",
    "from googleapiclient.errors import HttpError\n",
    "\n",
    "# If modifying these scopes, delete the file token.json.\n",
    "SCOPES = ['https://www.googleapis.com/auth/spreadsheets']\n",
    "\n",
    "# The ID and range of a sample spreadsheet.\n",
    "SAMPLE_SPREADSHEET_ID = '1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM'\n",
    "SAMPLE_RANGE_NAME = 'Dados!A1:E'\n",
    "\n",
    "#https://docs.google.com/spreadsheets/d/1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM/edit?usp=sharing\n",
    "\n",
    "def main():\n",
    "    \"\"\"Shows basic usage of the Sheets API.\n",
    "    Prints values from a sample spreadsheet.\n",
    "    \"\"\"\n",
    "    creds = None\n",
    "    # The file token.json stores the user's access and refresh tokens, and is\n",
    "    # created automatically when the authorization flow completes for the first\n",
    "    # time.\n",
    "    if os.path.exists('token.json'):\n",
    "        creds = Credentials.from_authorized_user_file('token.json', SCOPES)\n",
    "    # If there are no (valid) credentials available, let the user log in.\n",
    "    if not creds or not creds.valid:\n",
    "        if creds and creds.expired and creds.refresh_token:\n",
    "            creds.refresh(Request())\n",
    "        else:\n",
    "            flow = InstalledAppFlow.from_client_secrets_file(\n",
    "                'credentials.json', SCOPES)\n",
    "            creds = flow.run_local_server(port=0)\n",
    "        # Save the credentials for the next run\n",
    "        with open('token.json', 'w') as token:\n",
    "            token.write(creds.to_json())\n",
    "\n",
    "    try:\n",
    "        service = build('sheets', 'v4', credentials=creds)\n",
    "\n",
    "        # Call the Sheets API\n",
    "        sheet = service.spreadsheets()\n",
    "        result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                  range=SAMPLE_RANGE_NAME).execute()\n",
    "        \n",
    "        #Lê os dados da planilha do google sheets\n",
    "        valores = result.get('values', [])\n",
    "        \n",
    "              \n",
    "        #Criando a janela do Tkinter\n",
    "        root = Tk()\n",
    "        root.title(\"Sistema Google Sheets\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        estado_label = Label(root, text=\"Estado:\", font=\"Arial 14\")\n",
    "        estado_label.grid(row=0, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna A a partir da segunda linha\n",
    "        estados = sorted(list(set(value[0] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        estado_combobox = ttk.Combobox(root, values=estados, font=\"Arial 14\")\n",
    "        estado_combobox.grid(row=1, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        cidade_label = Label(root, text=\"Cidade:\", font=\"Arial 14\")\n",
    "        cidade_label.grid(row=0, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna B a partir da segunda linha\n",
    "        cidades = sorted(list(set(value[1] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        cidade_combobox = ttk.Combobox(root, values=cidades, font=\"Arial 14\")\n",
    "        cidade_combobox.grid(row=1, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        vendedor_label = Label(root, text=\"Vendedor:\", font=\"Arial 14\")\n",
    "        vendedor_label.grid(row=0, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna C a partir da segunda linha\n",
    "        vendedores = sorted(list(set(value[2] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        vendedor_combobox = ttk.Combobox(root, values=vendedores, font=\"Arial 14\")\n",
    "        vendedor_combobox.grid(row=1, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        produto_label = Label(root, text=\"Produto:\", font=\"Arial 14\")\n",
    "        produto_label.grid(row=0, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna D a partir da segunda linha\n",
    "        produtos = sorted(list(set(value[3] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        produtos_combobox = ttk.Combobox(root, values=produtos, font=\"Arial 14\")\n",
    "        produtos_combobox.grid(row=1, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Cria uma treeview para exibir os dados da planilha\n",
    "        tree = ttk.Treeview(root)\n",
    "                \n",
    "        #Define as colunas da Treeview com base nos valores da linha 1 da planilha\n",
    "        colunas = valores[0]\n",
    "        tree[\"columns\"] = colunas\n",
    "        \n",
    "        #for - para\n",
    "        #Define o cabeçalho da Treeview\n",
    "        for linha in colunas:\n",
    "            tree.heading(linha, text=linha)\n",
    "        \n",
    "        #Adiciona os valores da planilha à Treeview\n",
    "        for row in valores[1:]:\n",
    "            tree.insert(\"\", \"end\", values=row)\n",
    "            \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena parte como se fosse uma planilha\n",
    "        tree.grid(row=3, column=0, columnspan=6, padx=5, pady=5, stick=\"NSEW\")\n",
    "        \n",
    "        #Função que filtra os dados\n",
    "        def filtro():\n",
    "            \n",
    "            #Lê as informações da planilha\n",
    "            sheet = service.spreadsheets()\n",
    "            result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                      range=SAMPLE_RANGE_NAME).execute()\n",
    "\n",
    "            #Lê os dados da planilha do google sheets\n",
    "            valores = result['values']\n",
    "            \n",
    "            #Opçoes filtro pega o texto das combobox\n",
    "            estado = estado_combobox.get()\n",
    "            cidade = cidade_combobox.get()\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            produto = produtos_combobox.get()\n",
    "            \n",
    "            dados_filtrados = [valores[0]] #Inclui a linha do cabeçalho\n",
    "            for row in valores[1:]:\n",
    "                \n",
    "                if(not estado or row[0] == estado) and \\\n",
    "                    (not cidade or row[1] == cidade) and \\\n",
    "                    (not vendedor or row[2] == vendedor) and \\\n",
    "                    (not produto or row[3] == produto) and \\\n",
    "                    (not estado or row[0] == estado) :\n",
    "                    dados_filtrados.append(row)\n",
    "            \n",
    "            #Limpa os dados\n",
    "            for row in tree.get_children():\n",
    "                tree.delete(row)\n",
    "                \n",
    "            #Atualiza os dados da treeview\n",
    "            for row in dados_filtrados[1:]:\n",
    "                tree.insert(\"\", \"end\", values=row) \n",
    "                \n",
    "        #Cria botão Filtro\n",
    "        botao_filtrar = Button(root, text=\"Filtrar\", font=\"Arial 14\", command=filtro)\n",
    "        botao_filtrar.grid(row=4, column=1, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        def atualiza_cidades(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            estado = estado_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna B a partir da segunda linha\n",
    "            cidades = sorted(list(set([value[1] for value in valores[1:] if value[0] == estado])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            cidade_combobox['values'] = cidades\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        estado_combobox.bind(\"<<ComboboxSelected>>\", atualiza_cidades)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_vendedores(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            cidade = cidade_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna C a partir da segunda linha\n",
    "            vendedores = sorted(list(set([value[2] for value in valores[1:] if value[1] == cidade])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            vendedor_combobox['values'] = vendedores\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        cidade_combobox.bind(\"<<ComboboxSelected>>\", atualiza_vendedores)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_produtos(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna D a partir da segunda linha\n",
    "            produtos = sorted(list(set([value[3] for value in valores[1:] if value[2] == vendedor])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            produtos_combobox['values'] = produtos\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        vendedor_combobox.bind(\"<<ComboboxSelected>>\", atualiza_produtos)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def chama_filtro_a_cada_mudanca(event):\n",
    "            \n",
    "            filtro()\n",
    "        \n",
    "        #Filtro as informações quando selecionar algo no campo de produtos\n",
    "        produtos_combobox.bind(\"<<ComboboxSelected>>\", chama_filtro_a_cada_mudanca)\n",
    "            \n",
    "        \n",
    "        #Exibo a tela\n",
    "        root.mainloop()\n",
    "\n",
    "        \n",
    "    except HttpError as err:\n",
    "        print(err)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3b2066a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "290e03b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "from tkinter import ttk\n",
    "import os.path\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "import os.path\n",
    "\n",
    "from google.auth.transport.requests import Request\n",
    "from google.oauth2.credentials import Credentials\n",
    "from google_auth_oauthlib.flow import InstalledAppFlow\n",
    "from googleapiclient.discovery import build\n",
    "from googleapiclient.errors import HttpError\n",
    "\n",
    "# If modifying these scopes, delete the file token.json.\n",
    "SCOPES = ['https://www.googleapis.com/auth/spreadsheets']\n",
    "\n",
    "# The ID and range of a sample spreadsheet.\n",
    "SAMPLE_SPREADSHEET_ID = '1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM'\n",
    "SAMPLE_RANGE_NAME = 'Dados!A1:E'\n",
    "\n",
    "#https://docs.google.com/spreadsheets/d/1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM/edit?usp=sharing\n",
    "\n",
    "def main():\n",
    "    \"\"\"Shows basic usage of the Sheets API.\n",
    "    Prints values from a sample spreadsheet.\n",
    "    \"\"\"\n",
    "    creds = None\n",
    "    # The file token.json stores the user's access and refresh tokens, and is\n",
    "    # created automatically when the authorization flow completes for the first\n",
    "    # time.\n",
    "    if os.path.exists('token.json'):\n",
    "        creds = Credentials.from_authorized_user_file('token.json', SCOPES)\n",
    "    # If there are no (valid) credentials available, let the user log in.\n",
    "    if not creds or not creds.valid:\n",
    "        if creds and creds.expired and creds.refresh_token:\n",
    "            creds.refresh(Request())\n",
    "        else:\n",
    "            flow = InstalledAppFlow.from_client_secrets_file(\n",
    "                'credentials.json', SCOPES)\n",
    "            creds = flow.run_local_server(port=0)\n",
    "        # Save the credentials for the next run\n",
    "        with open('token.json', 'w') as token:\n",
    "            token.write(creds.to_json())\n",
    "\n",
    "    try:\n",
    "        service = build('sheets', 'v4', credentials=creds)\n",
    "\n",
    "        # Call the Sheets API\n",
    "        sheet = service.spreadsheets()\n",
    "        result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                  range=SAMPLE_RANGE_NAME).execute()\n",
    "        \n",
    "        #Lê os dados da planilha do google sheets\n",
    "        valores = result.get('values', [])\n",
    "        \n",
    "              \n",
    "        #Criando a janela do Tkinter\n",
    "        root = Tk()\n",
    "        root.title(\"Sistema Google Sheets\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        estado_label = Label(root, text=\"Estado:\", font=\"Arial 14\")\n",
    "        estado_label.grid(row=0, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna A a partir da segunda linha\n",
    "        estados = sorted(list(set(value[0] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        estado_combobox = ttk.Combobox(root, values=estados, font=\"Arial 14\")\n",
    "        estado_combobox.grid(row=1, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        cidade_label = Label(root, text=\"Cidade:\", font=\"Arial 14\")\n",
    "        cidade_label.grid(row=0, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna B a partir da segunda linha\n",
    "        cidades = sorted(list(set(value[1] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        cidade_combobox = ttk.Combobox(root, values=cidades, font=\"Arial 14\")\n",
    "        cidade_combobox.grid(row=1, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        vendedor_label = Label(root, text=\"Vendedor:\", font=\"Arial 14\")\n",
    "        vendedor_label.grid(row=0, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna C a partir da segunda linha\n",
    "        vendedores = sorted(list(set(value[2] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        vendedor_combobox = ttk.Combobox(root, values=vendedores, font=\"Arial 14\")\n",
    "        vendedor_combobox.grid(row=1, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        produto_label = Label(root, text=\"Produto:\", font=\"Arial 14\")\n",
    "        produto_label.grid(row=0, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna D a partir da segunda linha\n",
    "        produtos = sorted(list(set(value[3] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        produtos_combobox = ttk.Combobox(root, values=produtos, font=\"Arial 14\")\n",
    "        produtos_combobox.grid(row=1, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Cria uma treeview para exibir os dados da planilha\n",
    "        tree = ttk.Treeview(root)\n",
    "                \n",
    "        #Define as colunas da Treeview com base nos valores da linha 1 da planilha\n",
    "        colunas = valores[0]\n",
    "        tree[\"columns\"] = colunas\n",
    "        \n",
    "        #for - para\n",
    "        #Define o cabeçalho da Treeview\n",
    "        for linha in colunas:\n",
    "            tree.heading(linha, text=linha)\n",
    "        \n",
    "        #Adiciona os valores da planilha à Treeview\n",
    "        for row in valores[1:]:\n",
    "            tree.insert(\"\", \"end\", values=row)\n",
    "            \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena parte como se fosse uma planilha\n",
    "        tree.grid(row=3, column=0, columnspan=6, padx=5, pady=5, stick=\"NSEW\")\n",
    "        \n",
    "        #Função que filtra os dados\n",
    "        def filtro():\n",
    "            \n",
    "            #Lê as informações da planilha\n",
    "            sheet = service.spreadsheets()\n",
    "            result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                      range=SAMPLE_RANGE_NAME).execute()\n",
    "\n",
    "            #Lê os dados da planilha do google sheets\n",
    "            valores = result['values']\n",
    "            \n",
    "            #Opçoes filtro pega o texto das combobox\n",
    "            estado = estado_combobox.get()\n",
    "            cidade = cidade_combobox.get()\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            produto = produtos_combobox.get()\n",
    "            \n",
    "            dados_filtrados = [valores[0]] #Inclui a linha do cabeçalho\n",
    "            for row in valores[1:]:\n",
    "                \n",
    "                if(not estado or row[0] == estado) and \\\n",
    "                    (not cidade or row[1] == cidade) and \\\n",
    "                    (not vendedor or row[2] == vendedor) and \\\n",
    "                    (not produto or row[3] == produto) and \\\n",
    "                    (not estado or row[0] == estado) :\n",
    "                    dados_filtrados.append(row)\n",
    "            \n",
    "            #Limpa os dados\n",
    "            for row in tree.get_children():\n",
    "                tree.delete(row)\n",
    "                \n",
    "            #Atualiza os dados da treeview\n",
    "            for row in dados_filtrados[1:]:\n",
    "                tree.insert(\"\", \"end\", values=row) \n",
    "                \n",
    "        #Cria botão Filtro\n",
    "        botao_filtrar = Button(root, text=\"Filtrar\", font=\"Arial 14\", command=filtro)\n",
    "        botao_filtrar.grid(row=4, column=1, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        def atualiza_cidades(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            estado = estado_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna B a partir da segunda linha\n",
    "            cidades = sorted(list(set([value[1] for value in valores[1:] if value[0] == estado])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            cidade_combobox['values'] = cidades\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        estado_combobox.bind(\"<<ComboboxSelected>>\", atualiza_cidades)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_vendedores(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            cidade = cidade_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna C a partir da segunda linha\n",
    "            vendedores = sorted(list(set([value[2] for value in valores[1:] if value[1] == cidade])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            vendedor_combobox['values'] = vendedores\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        cidade_combobox.bind(\"<<ComboboxSelected>>\", atualiza_vendedores)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_produtos(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna D a partir da segunda linha\n",
    "            produtos = sorted(list(set([value[3] for value in valores[1:] if value[2] == vendedor])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            produtos_combobox['values'] = produtos\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        vendedor_combobox.bind(\"<<ComboboxSelected>>\", atualiza_produtos)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def chama_filtro_a_cada_mudanca(event):\n",
    "            \n",
    "            filtro()\n",
    "        \n",
    "        #Filtro as informações quando selecionar algo no campo de produtos\n",
    "        produtos_combobox.bind(\"<<ComboboxSelected>>\", chama_filtro_a_cada_mudanca)\n",
    "            \n",
    "        def novo_registro():\n",
    "            \n",
    "            #Cria uma janela secundária para cadastrar os dados\n",
    "            janela_cadastro = Toplevel(root)\n",
    "            janela_cadastro.title(\"Cadastrar Produto\")\n",
    "            \n",
    "            Label(janela_cadastro, text=\"Estado:\", font=\"Arial 16\").grid(row=0, column=0, padx=2, pady=2) \n",
    "            estado_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            estado_cadastro.grid(row=0, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Cidade:\", font=\"Arial 16\").grid(row=1, column=0, padx=2, pady=2) \n",
    "            cidade_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            cidade_cadastro.grid(row=1, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Vendedor:\", font=\"Arial 16\").grid(row=2, column=0, padx=2, pady=2) \n",
    "            vendedor_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            vendedor_cadastro.grid(row=2, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Produto:\", font=\"Arial 16\").grid(row=3, column=0, padx=2, pady=2) \n",
    "            produto_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            produto_cadastro.grid(row=3, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Preço:\", font=\"Arial 16\").grid(row=4, column=0, padx=2, pady=2) \n",
    "            preco_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            preco_cadastro.grid(row=4, column=1, padx=2, pady=2) \n",
    "            \n",
    "            \n",
    "            #Cria botão Filtro\n",
    "            botao_salvar_novo_registro = Button(janela_cadastro, text=\"Cadastrar\", font=\"Arial 16\", command=filtro)\n",
    "            botao_salvar_novo_registro.grid(row=6, column=0, columnspan=2, padx=2, pady=2, stick=\"NSEW\")\n",
    "            \n",
    "        #Cria botão Filtro\n",
    "        botao_novo = Button(root, text=\"Novo\", font=\"Arial 14\", command=novo_registro)\n",
    "        botao_novo.grid(row=4, column=0, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        #Exibo a tela\n",
    "        root.mainloop()\n",
    "\n",
    "        \n",
    "    except HttpError as err:\n",
    "        print(err)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c85a17b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b7a9582",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "cc0111b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "from tkinter import ttk\n",
    "import os.path\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "import os.path\n",
    "\n",
    "from google.auth.transport.requests import Request\n",
    "from google.oauth2.credentials import Credentials\n",
    "from google_auth_oauthlib.flow import InstalledAppFlow\n",
    "from googleapiclient.discovery import build\n",
    "from googleapiclient.errors import HttpError\n",
    "\n",
    "# If modifying these scopes, delete the file token.json.\n",
    "SCOPES = ['https://www.googleapis.com/auth/spreadsheets']\n",
    "\n",
    "# The ID and range of a sample spreadsheet.\n",
    "SAMPLE_SPREADSHEET_ID = '1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM'\n",
    "SAMPLE_RANGE_NAME = 'Dados!A1:E'\n",
    "\n",
    "CREDENTIALS_FILE = 'token.json'\n",
    "\n",
    "#https://docs.google.com/spreadsheets/d/1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM/edit?usp=sharing\n",
    "\n",
    "def main():\n",
    "    \"\"\"Shows basic usage of the Sheets API.\n",
    "    Prints values from a sample spreadsheet.\n",
    "    \"\"\"\n",
    "    creds = None\n",
    "    # The file token.json stores the user's access and refresh tokens, and is\n",
    "    # created automatically when the authorization flow completes for the first\n",
    "    # time.\n",
    "    if os.path.exists('token.json'):\n",
    "        creds = Credentials.from_authorized_user_file('token.json', SCOPES)\n",
    "    # If there are no (valid) credentials available, let the user log in.\n",
    "    if not creds or not creds.valid:\n",
    "        if creds and creds.expired and creds.refresh_token:\n",
    "            creds.refresh(Request())\n",
    "        else:\n",
    "            flow = InstalledAppFlow.from_client_secrets_file(\n",
    "                'credentials.json', SCOPES)\n",
    "            creds = flow.run_local_server(port=0)\n",
    "        # Save the credentials for the next run\n",
    "        with open('token.json', 'w') as token:\n",
    "            token.write(creds.to_json())\n",
    "\n",
    "    try:\n",
    "        service = build('sheets', 'v4', credentials=creds)\n",
    "\n",
    "        # Call the Sheets API\n",
    "        sheet = service.spreadsheets()\n",
    "        result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                  range=SAMPLE_RANGE_NAME).execute()\n",
    "        \n",
    "        #Lê os dados da planilha do google sheets\n",
    "        valores = result.get('values', [])\n",
    "        \n",
    "              \n",
    "        #Criando a janela do Tkinter\n",
    "        root = Tk()\n",
    "        root.title(\"Sistema Google Sheets\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        estado_label = Label(root, text=\"Estado:\", font=\"Arial 14\")\n",
    "        estado_label.grid(row=0, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna A a partir da segunda linha\n",
    "        estados = sorted(list(set(value[0] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        estado_combobox = ttk.Combobox(root, values=estados, font=\"Arial 14\")\n",
    "        estado_combobox.grid(row=1, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        cidade_label = Label(root, text=\"Cidade:\", font=\"Arial 14\")\n",
    "        cidade_label.grid(row=0, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna B a partir da segunda linha\n",
    "        cidades = sorted(list(set(value[1] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        cidade_combobox = ttk.Combobox(root, values=cidades, font=\"Arial 14\")\n",
    "        cidade_combobox.grid(row=1, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        vendedor_label = Label(root, text=\"Vendedor:\", font=\"Arial 14\")\n",
    "        vendedor_label.grid(row=0, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna C a partir da segunda linha\n",
    "        vendedores = sorted(list(set(value[2] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        vendedor_combobox = ttk.Combobox(root, values=vendedores, font=\"Arial 14\")\n",
    "        vendedor_combobox.grid(row=1, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        produto_label = Label(root, text=\"Produto:\", font=\"Arial 14\")\n",
    "        produto_label.grid(row=0, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna D a partir da segunda linha\n",
    "        produtos = sorted(list(set(value[3] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        produtos_combobox = ttk.Combobox(root, values=produtos, font=\"Arial 14\")\n",
    "        produtos_combobox.grid(row=1, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Cria uma treeview para exibir os dados da planilha\n",
    "        tree = ttk.Treeview(root)\n",
    "                \n",
    "        #Define as colunas da Treeview com base nos valores da linha 1 da planilha\n",
    "        colunas = valores[0]\n",
    "        tree[\"columns\"] = colunas\n",
    "        \n",
    "        #for - para\n",
    "        #Define o cabeçalho da Treeview\n",
    "        for linha in colunas:\n",
    "            tree.heading(linha, text=linha)\n",
    "        \n",
    "        #Adiciona os valores da planilha à Treeview\n",
    "        for row in valores[1:]:\n",
    "            tree.insert(\"\", \"end\", values=row)\n",
    "            \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena parte como se fosse uma planilha\n",
    "        tree.grid(row=3, column=0, columnspan=6, padx=5, pady=5, stick=\"NSEW\")\n",
    "        \n",
    "        #Função que filtra os dados\n",
    "        def filtro():\n",
    "            \n",
    "            #Lê as informações da planilha\n",
    "            sheet = service.spreadsheets()\n",
    "            result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                      range=SAMPLE_RANGE_NAME).execute()\n",
    "\n",
    "            #Lê os dados da planilha do google sheets\n",
    "            valores = result['values']\n",
    "            \n",
    "            #Opçoes filtro pega o texto das combobox\n",
    "            estado = estado_combobox.get()\n",
    "            cidade = cidade_combobox.get()\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            produto = produtos_combobox.get()\n",
    "            \n",
    "            dados_filtrados = [valores[0]] #Inclui a linha do cabeçalho\n",
    "            for row in valores[1:]:\n",
    "                \n",
    "                if(not estado or row[0] == estado) and \\\n",
    "                    (not cidade or row[1] == cidade) and \\\n",
    "                    (not vendedor or row[2] == vendedor) and \\\n",
    "                    (not produto or row[3] == produto) and \\\n",
    "                    (not estado or row[0] == estado) :\n",
    "                    dados_filtrados.append(row)\n",
    "            \n",
    "            #Limpa os dados\n",
    "            for row in tree.get_children():\n",
    "                tree.delete(row)\n",
    "                \n",
    "            #Atualiza os dados da treeview\n",
    "            for row in dados_filtrados[1:]:\n",
    "                tree.insert(\"\", \"end\", values=row) \n",
    "                \n",
    "        #Cria botão Filtro\n",
    "        botao_filtrar = Button(root, text=\"Filtrar\", font=\"Arial 14\", command=filtro)\n",
    "        botao_filtrar.grid(row=4, column=1, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        def atualiza_cidades(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            estado = estado_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna B a partir da segunda linha\n",
    "            cidades = sorted(list(set([value[1] for value in valores[1:] if value[0] == estado])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            cidade_combobox['values'] = cidades\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        estado_combobox.bind(\"<<ComboboxSelected>>\", atualiza_cidades)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_vendedores(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            cidade = cidade_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna C a partir da segunda linha\n",
    "            vendedores = sorted(list(set([value[2] for value in valores[1:] if value[1] == cidade])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            vendedor_combobox['values'] = vendedores\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        cidade_combobox.bind(\"<<ComboboxSelected>>\", atualiza_vendedores)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_produtos(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna D a partir da segunda linha\n",
    "            produtos = sorted(list(set([value[3] for value in valores[1:] if value[2] == vendedor])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            produtos_combobox['values'] = produtos\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        vendedor_combobox.bind(\"<<ComboboxSelected>>\", atualiza_produtos)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def chama_filtro_a_cada_mudanca(event):\n",
    "            \n",
    "            filtro()\n",
    "        \n",
    "        #Filtro as informações quando selecionar algo no campo de produtos\n",
    "        produtos_combobox.bind(\"<<ComboboxSelected>>\", chama_filtro_a_cada_mudanca)\n",
    "            \n",
    "        def novo_registro():\n",
    "            \n",
    "            #Cria uma janela secundária para cadastrar os dados\n",
    "            janela_cadastro = Toplevel(root)\n",
    "            janela_cadastro.title(\"Cadastrar Produto\")\n",
    "            \n",
    "            Label(janela_cadastro, text=\"Estado:\", font=\"Arial 16\").grid(row=0, column=0, padx=2, pady=2) \n",
    "            estado_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            estado_cadastro.grid(row=0, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Cidade:\", font=\"Arial 16\").grid(row=1, column=0, padx=2, pady=2) \n",
    "            cidade_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            cidade_cadastro.grid(row=1, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Vendedor:\", font=\"Arial 16\").grid(row=2, column=0, padx=2, pady=2) \n",
    "            vendedor_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            vendedor_cadastro.grid(row=2, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Produto:\", font=\"Arial 16\").grid(row=3, column=0, padx=2, pady=2) \n",
    "            produto_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            produto_cadastro.grid(row=3, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Preço:\", font=\"Arial 16\").grid(row=4, column=0, padx=2, pady=2) \n",
    "            preco_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            preco_cadastro.grid(row=4, column=1, padx=2, pady=2) \n",
    "            \n",
    "            def salvar_dados_google_sheets():\n",
    "                \n",
    "                #Obtem os valores dos campos de entrada de dados\n",
    "                estado = estado_cadastro.get()\n",
    "                cidade = cidade_cadastro.get()\n",
    "                vendedor = vendedor_cadastro.get()\n",
    "                produto = produto_cadastro.get()\n",
    "                preco = preco_cadastro.get()\n",
    "                \n",
    "                creds = None\n",
    "                if os.path.exists(CREDENTIALS_FILE): #Verifica se o arquivo de credenciais exsite\n",
    "                    creds = Credentials.from_authorized_user_file(CREDENTIALS_FILE, SCOPES) #Carrega as credenciais a partir do arquuivo\n",
    "                    \n",
    "                if not creds or not creds.valid: #Verifica se as credenciais são inválidas ou inexistes\n",
    "                    if creds and creds.expired and creds.reflesh_token: #Verifica se as credenciais expiraram e existe um token de atualização\n",
    "                        creds.refresh(Request()) #Atualiza as credenciais com o token de atualização\n",
    "                    else:\n",
    "                        \n",
    "                        #Se não houver credenciais ou elas forem inválidas abre o fluxo de autenticação do Google Sheets\n",
    "                        flow = InstalledAppFlow.from_client_secrets_file(                        \n",
    "                            'credentials.json', SCOPES)\n",
    "                        creds = flow.run_local_server(port=0) #Executa o fluxo de autenticação\n",
    "                        \n",
    "                    with open(CREDENTIALS_FILE, 'w') as token: #Abre o arquivo de credenciais para escrita\n",
    "                        token.write(creds.to_json()) #Escreve as credenciais no arquivo\n",
    "                        \n",
    "                #Cria uma instancia da API da planilha do Google\n",
    "                service = build('sheets', 'v4', credentials=creds)\n",
    "                \n",
    "                values = [[estado, cidade, vendedor, produto, preco]] #Cria uma lista com os valores obtidos dos campos de entrada\n",
    "                \n",
    "                body = {'values': values} #Cria um dicionário com a lista de valores\n",
    "\n",
    "                # Call the Sheets API\n",
    "                result = service.spreadsheets().values().append(\n",
    "                                spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=SAMPLE_RANGE_NAME,\n",
    "                                valueInputOption='USER_ENTERED', insertDataOption='INSERT_ROWS', body=body).execute()\n",
    "                                #Executa o método append para adicionar uma nova linha à planilha do Google Sheets\n",
    "            \n",
    "                tree.delete(tree.get_children()) #Remove todas as linhas da Treeview\n",
    "                result = service.spreadsheets().values().get(\n",
    "                            spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=SAMPLE_RANGE_NAME).execute() #Executa o método get() para obter os dados da planilha\n",
    "                \n",
    "                valores = result['values'] #Obtem os valores da planilha em formato de lista\n",
    "                for row in valores[1:]:\n",
    "                    tree.insert(\"\", \"end\", values=row)\n",
    "                \n",
    "            #Cria botão Filtro\n",
    "            botao_salvar_novo_registro = Button(janela_cadastro, text=\"Cadastrar\", font=\"Arial 16\", command=salvar_dados_google_sheets)\n",
    "            botao_salvar_novo_registro.grid(row=6, column=0, columnspan=2, padx=2, pady=2, stick=\"NSEW\")\n",
    "            \n",
    "        #Cria botão Filtro\n",
    "        botao_novo = Button(root, text=\"Novo\", font=\"Arial 14\", command=novo_registro)\n",
    "        botao_novo.grid(row=4, column=0, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        #Exibo a tela\n",
    "        root.mainloop()\n",
    "\n",
    "        \n",
    "    except HttpError as err:\n",
    "        print(err)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c004c581",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6ccc8032",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "from tkinter import ttk\n",
    "import os.path\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "import os.path\n",
    "\n",
    "from google.auth.transport.requests import Request\n",
    "from google.oauth2.credentials import Credentials\n",
    "from google_auth_oauthlib.flow import InstalledAppFlow\n",
    "from googleapiclient.discovery import build\n",
    "from googleapiclient.errors import HttpError\n",
    "\n",
    "# If modifying these scopes, delete the file token.json.\n",
    "SCOPES = ['https://www.googleapis.com/auth/spreadsheets']\n",
    "\n",
    "# The ID and range of a sample spreadsheet.\n",
    "SAMPLE_SPREADSHEET_ID = '1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM'\n",
    "SAMPLE_RANGE_NAME = 'Dados!A1:E'\n",
    "\n",
    "CREDENTIALS_FILE = 'token.json'\n",
    "\n",
    "#https://docs.google.com/spreadsheets/d/1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM/edit?usp=sharing\n",
    "\n",
    "def main():\n",
    "    \"\"\"Shows basic usage of the Sheets API.\n",
    "    Prints values from a sample spreadsheet.\n",
    "    \"\"\"\n",
    "    creds = None\n",
    "    # The file token.json stores the user's access and refresh tokens, and is\n",
    "    # created automatically when the authorization flow completes for the first\n",
    "    # time.\n",
    "    if os.path.exists('token.json'):\n",
    "        creds = Credentials.from_authorized_user_file('token.json', SCOPES)\n",
    "    # If there are no (valid) credentials available, let the user log in.\n",
    "    if not creds or not creds.valid:\n",
    "        if creds and creds.expired and creds.refresh_token:\n",
    "            creds.refresh(Request())\n",
    "        else:\n",
    "            flow = InstalledAppFlow.from_client_secrets_file(\n",
    "                'credentials.json', SCOPES)\n",
    "            creds = flow.run_local_server(port=0)\n",
    "        # Save the credentials for the next run\n",
    "        with open('token.json', 'w') as token:\n",
    "            token.write(creds.to_json())\n",
    "\n",
    "    try:\n",
    "        service = build('sheets', 'v4', credentials=creds)\n",
    "\n",
    "        # Call the Sheets API\n",
    "        sheet = service.spreadsheets()\n",
    "        result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                  range=SAMPLE_RANGE_NAME).execute()\n",
    "        \n",
    "        #Lê os dados da planilha do google sheets\n",
    "        valores = result.get('values', [])\n",
    "        \n",
    "              \n",
    "        #Criando a janela do Tkinter\n",
    "        root = Tk()\n",
    "        root.configure(bg='white') #Cor do fundo\n",
    "        root.title(\"Sistema Google Sheets\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        estado_label = Label(root, text=\"Estado:\", font=\"Arial 14\", bg='white')\n",
    "        estado_label.grid(row=0, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna A a partir da segunda linha\n",
    "        estados = sorted(list(set(value[0] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        estado_combobox = ttk.Combobox(root, values=estados, font=\"Arial 14\")\n",
    "        estado_combobox.grid(row=1, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        cidade_label = Label(root, text=\"Cidade:\", font=\"Arial 14\", bg='white')\n",
    "        cidade_label.grid(row=0, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna B a partir da segunda linha\n",
    "        cidades = sorted(list(set(value[1] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        cidade_combobox = ttk.Combobox(root, values=cidades, font=\"Arial 14\")\n",
    "        cidade_combobox.grid(row=1, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        vendedor_label = Label(root, text=\"Vendedor:\", font=\"Arial 14\", bg='white')\n",
    "        vendedor_label.grid(row=0, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna C a partir da segunda linha\n",
    "        vendedores = sorted(list(set(value[2] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        vendedor_combobox = ttk.Combobox(root, values=vendedores, font=\"Arial 14\")\n",
    "        vendedor_combobox.grid(row=1, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        produto_label = Label(root, text=\"Produto:\", font=\"Arial 14\", bg='white')\n",
    "        produto_label.grid(row=0, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna D a partir da segunda linha\n",
    "        produtos = sorted(list(set(value[3] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        produtos_combobox = ttk.Combobox(root, values=produtos, font=\"Arial 14\")\n",
    "        produtos_combobox.grid(row=1, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Cria uma treeview para exibir os dados da planilha\n",
    "        tree = ttk.Treeview(root)\n",
    "                \n",
    "        #Define as colunas da Treeview com base nos valores da linha 1 da planilha\n",
    "        colunas = valores[0]\n",
    "        tree[\"columns\"] = colunas\n",
    "        \n",
    "        #for - para\n",
    "        #Define o cabeçalho da Treeview\n",
    "        for linha in colunas:\n",
    "            tree.heading(linha, text=linha)\n",
    "        \n",
    "        #Adiciona os valores da planilha à Treeview\n",
    "        for row in valores[1:]:\n",
    "            tree.insert(\"\", \"end\", values=row)\n",
    "            \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena parte como se fosse uma planilha\n",
    "        tree.grid(row=3, column=0, columnspan=6, padx=5, pady=5, stick=\"NSEW\")\n",
    "        \n",
    "        style = ttk.Style()\n",
    "        style.theme_use(\"clam\") #Definindo o tema para a treeview\n",
    "        style.configure(\"Treeview\", background=\"#FFFFE0\", foreground=\"black\",\n",
    "                       font=(\"Arial 12\"), rowheight=25, fiedlbackground=\"#FFFFE0\",\n",
    "                            bordercolor=\"#808080\", borderwidth=1) #Define as cores, fundo, cor do texto, altura da linha, cor do campo, cor e larrgura da borda\n",
    "        style.map(\"Treeview\", background=[('selected', \"#347083\")], foreground=[('selected', 'white')]) #Define a cor de fundo e texto quando uma linha é selecionada\n",
    "        \n",
    "        #Oculta a primeira coluna deixando a largura como 0\n",
    "        tree.column(\"#0\", width=0, stretch=False)\n",
    "        \n",
    "        \n",
    "        #Função que filtra os dados\n",
    "        def filtro():\n",
    "            \n",
    "            #Lê as informações da planilha\n",
    "            sheet = service.spreadsheets()\n",
    "            result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                      range=SAMPLE_RANGE_NAME).execute()\n",
    "\n",
    "            #Lê os dados da planilha do google sheets\n",
    "            valores = result['values']\n",
    "            \n",
    "            #Opçoes filtro pega o texto das combobox\n",
    "            estado = estado_combobox.get()\n",
    "            cidade = cidade_combobox.get()\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            produto = produtos_combobox.get()\n",
    "            \n",
    "            dados_filtrados = [valores[0]] #Inclui a linha do cabeçalho\n",
    "            for row in valores[1:]:\n",
    "                \n",
    "                if(not estado or row[0] == estado) and \\\n",
    "                    (not cidade or row[1] == cidade) and \\\n",
    "                    (not vendedor or row[2] == vendedor) and \\\n",
    "                    (not produto or row[3] == produto) and \\\n",
    "                    (not estado or row[0] == estado) :\n",
    "                    dados_filtrados.append(row)\n",
    "            \n",
    "            #Limpa os dados\n",
    "            for row in tree.get_children():\n",
    "                tree.delete(row)\n",
    "                \n",
    "            #Atualiza os dados da treeview\n",
    "            for row in dados_filtrados[1:]:\n",
    "                tree.insert(\"\", \"end\", values=row) \n",
    "                \n",
    "        #Cria botão Filtro\n",
    "        botao_filtrar = Button(root, text=\"Filtrar\", font=\"Arial 14\", command=filtro)\n",
    "        botao_filtrar.grid(row=4, column=1, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        def atualiza_cidades(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            estado = estado_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna B a partir da segunda linha\n",
    "            cidades = sorted(list(set([value[1] for value in valores[1:] if value[0] == estado])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            cidade_combobox['values'] = cidades\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        estado_combobox.bind(\"<<ComboboxSelected>>\", atualiza_cidades)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_vendedores(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            cidade = cidade_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna C a partir da segunda linha\n",
    "            vendedores = sorted(list(set([value[2] for value in valores[1:] if value[1] == cidade])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            vendedor_combobox['values'] = vendedores\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        cidade_combobox.bind(\"<<ComboboxSelected>>\", atualiza_vendedores)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_produtos(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna D a partir da segunda linha\n",
    "            produtos = sorted(list(set([value[3] for value in valores[1:] if value[2] == vendedor])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            produtos_combobox['values'] = produtos\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        vendedor_combobox.bind(\"<<ComboboxSelected>>\", atualiza_produtos)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def chama_filtro_a_cada_mudanca(event):\n",
    "            \n",
    "            filtro()\n",
    "        \n",
    "        #Filtro as informações quando selecionar algo no campo de produtos\n",
    "        produtos_combobox.bind(\"<<ComboboxSelected>>\", chama_filtro_a_cada_mudanca)\n",
    "            \n",
    "        def novo_registro():\n",
    "            \n",
    "            #Cria uma janela secundária para cadastrar os dados\n",
    "            janela_cadastro = Toplevel(root)\n",
    "            janela_cadastro.title(\"Cadastrar Produto\")\n",
    "            \n",
    "            Label(janela_cadastro, text=\"Estado:\", font=\"Arial 16\").grid(row=0, column=0, padx=2, pady=2) \n",
    "            estado_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            estado_cadastro.grid(row=0, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Cidade:\", font=\"Arial 16\").grid(row=1, column=0, padx=2, pady=2) \n",
    "            cidade_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            cidade_cadastro.grid(row=1, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Vendedor:\", font=\"Arial 16\").grid(row=2, column=0, padx=2, pady=2) \n",
    "            vendedor_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            vendedor_cadastro.grid(row=2, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Produto:\", font=\"Arial 16\").grid(row=3, column=0, padx=2, pady=2) \n",
    "            produto_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            produto_cadastro.grid(row=3, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Preço:\", font=\"Arial 16\").grid(row=4, column=0, padx=2, pady=2) \n",
    "            preco_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            preco_cadastro.grid(row=4, column=1, padx=2, pady=2) \n",
    "            \n",
    "            def salvar_dados_google_sheets():\n",
    "                \n",
    "                #Obtem os valores dos campos de entrada de dados\n",
    "                estado = estado_cadastro.get()\n",
    "                cidade = cidade_cadastro.get()\n",
    "                vendedor = vendedor_cadastro.get()\n",
    "                produto = produto_cadastro.get()\n",
    "                preco = preco_cadastro.get()\n",
    "                \n",
    "                creds = None\n",
    "                if os.path.exists(CREDENTIALS_FILE): #Verifica se o arquivo de credenciais exsite\n",
    "                    creds = Credentials.from_authorized_user_file(CREDENTIALS_FILE, SCOPES) #Carrega as credenciais a partir do arquuivo\n",
    "                    \n",
    "                if not creds or not creds.valid: #Verifica se as credenciais são inválidas ou inexistes\n",
    "                    if creds and creds.expired and creds.reflesh_token: #Verifica se as credenciais expiraram e existe um token de atualização\n",
    "                        creds.refresh(Request()) #Atualiza as credenciais com o token de atualização\n",
    "                    else:\n",
    "                        \n",
    "                        #Se não houver credenciais ou elas forem inválidas abre o fluxo de autenticação do Google Sheets\n",
    "                        flow = InstalledAppFlow.from_client_secrets_file(                        \n",
    "                            'credentials.json', SCOPES)\n",
    "                        creds = flow.run_local_server(port=0) #Executa o fluxo de autenticação\n",
    "                        \n",
    "                    with open(CREDENTIALS_FILE, 'w') as token: #Abre o arquivo de credenciais para escrita\n",
    "                        token.write(creds.to_json()) #Escreve as credenciais no arquivo\n",
    "                        \n",
    "                #Cria uma instancia da API da planilha do Google\n",
    "                service = build('sheets', 'v4', credentials=creds)\n",
    "                \n",
    "                values = [[estado, cidade, vendedor, produto, preco]] #Cria uma lista com os valores obtidos dos campos de entrada\n",
    "                \n",
    "                body = {'values': values} #Cria um dicionário com a lista de valores\n",
    "\n",
    "                # Call the Sheets API\n",
    "                result = service.spreadsheets().values().append(\n",
    "                                spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=SAMPLE_RANGE_NAME,\n",
    "                                valueInputOption='USER_ENTERED', insertDataOption='INSERT_ROWS', body=body).execute()\n",
    "                                #Executa o método append para adicionar uma nova linha à planilha do Google Sheets\n",
    "            \n",
    "                tree.delete(tree.get_children()) #Remove todas as linhas da Treeview\n",
    "                result = service.spreadsheets().values().get(\n",
    "                            spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=SAMPLE_RANGE_NAME).execute() #Executa o método get() para obter os dados da planilha\n",
    "                \n",
    "                valores = result['values'] #Obtem os valores da planilha em formato de lista\n",
    "                for row in valores[1:]:\n",
    "                    tree.insert(\"\", \"end\", values=row)\n",
    "                \n",
    "            #Cria botão Filtro\n",
    "            botao_salvar_novo_registro = Button(janela_cadastro, text=\"Cadastrar\", font=\"Arial 16\", command=salvar_dados_google_sheets)\n",
    "            botao_salvar_novo_registro.grid(row=6, column=0, columnspan=2, padx=2, pady=2, stick=\"NSEW\")\n",
    "            \n",
    "        #Cria botão Filtro\n",
    "        botao_novo = Button(root, text=\"Novo\", font=\"Arial 14\", command=novo_registro)\n",
    "        botao_novo.grid(row=4, column=0, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        #Exibo a tela\n",
    "        root.mainloop()\n",
    "\n",
    "        \n",
    "    except HttpError as err:\n",
    "        print(err)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6add81ae",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b6a600f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "from tkinter import ttk\n",
    "import os.path\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "import os.path\n",
    "\n",
    "from google.auth.transport.requests import Request\n",
    "from google.oauth2.credentials import Credentials\n",
    "from google_auth_oauthlib.flow import InstalledAppFlow\n",
    "from googleapiclient.discovery import build\n",
    "from googleapiclient.errors import HttpError\n",
    "\n",
    "# If modifying these scopes, delete the file token.json.\n",
    "SCOPES = ['https://www.googleapis.com/auth/spreadsheets']\n",
    "\n",
    "# The ID and range of a sample spreadsheet.\n",
    "SAMPLE_SPREADSHEET_ID = '1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM'\n",
    "SAMPLE_RANGE_NAME = 'Dados!A1:E'\n",
    "\n",
    "CREDENTIALS_FILE = 'token.json'\n",
    "\n",
    "#https://docs.google.com/spreadsheets/d/1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM/edit?usp=sharing\n",
    "\n",
    "def main():\n",
    "    \"\"\"Shows basic usage of the Sheets API.\n",
    "    Prints values from a sample spreadsheet.\n",
    "    \"\"\"\n",
    "    creds = None\n",
    "    # The file token.json stores the user's access and refresh tokens, and is\n",
    "    # created automatically when the authorization flow completes for the first\n",
    "    # time.\n",
    "    if os.path.exists('token.json'):\n",
    "        creds = Credentials.from_authorized_user_file('token.json', SCOPES)\n",
    "    # If there are no (valid) credentials available, let the user log in.\n",
    "    if not creds or not creds.valid:\n",
    "        if creds and creds.expired and creds.refresh_token:\n",
    "            creds.refresh(Request())\n",
    "        else:\n",
    "            flow = InstalledAppFlow.from_client_secrets_file(\n",
    "                'credentials.json', SCOPES)\n",
    "            creds = flow.run_local_server(port=0)\n",
    "        # Save the credentials for the next run\n",
    "        with open('token.json', 'w') as token:\n",
    "            token.write(creds.to_json())\n",
    "\n",
    "    try:\n",
    "        service = build('sheets', 'v4', credentials=creds)\n",
    "\n",
    "        # Call the Sheets API\n",
    "        sheet = service.spreadsheets()\n",
    "        result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                  range=SAMPLE_RANGE_NAME).execute()\n",
    "        \n",
    "        #Lê os dados da planilha do google sheets\n",
    "        valores = result.get('values', [])\n",
    "        \n",
    "              \n",
    "        #Criando a janela do Tkinter\n",
    "        root = Tk()\n",
    "        root.configure(bg='white') #Cor do fundo\n",
    "        root.title(\"Sistema Google Sheets\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        estado_label = Label(root, text=\"Estado:\", font=\"Arial 14\", bg='white')\n",
    "        estado_label.grid(row=0, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna A a partir da segunda linha\n",
    "        estados = sorted(list(set(value[0] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        estado_combobox = ttk.Combobox(root, values=estados, font=\"Arial 14\")\n",
    "        estado_combobox.grid(row=1, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        cidade_label = Label(root, text=\"Cidade:\", font=\"Arial 14\", bg='white')\n",
    "        cidade_label.grid(row=0, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna B a partir da segunda linha\n",
    "        cidades = sorted(list(set(value[1] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        cidade_combobox = ttk.Combobox(root, values=cidades, font=\"Arial 14\")\n",
    "        cidade_combobox.grid(row=1, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        vendedor_label = Label(root, text=\"Vendedor:\", font=\"Arial 14\", bg='white')\n",
    "        vendedor_label.grid(row=0, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna C a partir da segunda linha\n",
    "        vendedores = sorted(list(set(value[2] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        vendedor_combobox = ttk.Combobox(root, values=vendedores, font=\"Arial 14\")\n",
    "        vendedor_combobox.grid(row=1, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        produto_label = Label(root, text=\"Produto:\", font=\"Arial 14\", bg='white')\n",
    "        produto_label.grid(row=0, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna D a partir da segunda linha\n",
    "        produtos = sorted(list(set(value[3] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        produtos_combobox = ttk.Combobox(root, values=produtos, font=\"Arial 14\")\n",
    "        produtos_combobox.grid(row=1, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Cria uma treeview para exibir os dados da planilha\n",
    "        tree = ttk.Treeview(root)\n",
    "                \n",
    "        #Define as colunas da Treeview com base nos valores da linha 1 da planilha\n",
    "        colunas = valores[0]\n",
    "        tree[\"columns\"] = colunas\n",
    "        \n",
    "        #for - para\n",
    "        #Define o cabeçalho da Treeview\n",
    "        for linha in colunas:\n",
    "            tree.heading(linha, text=linha)\n",
    "        \n",
    "        #Adiciona os valores da planilha à Treeview\n",
    "        for row in valores[1:]:\n",
    "            tree.insert(\"\", \"end\", values=row)\n",
    "            \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena parte como se fosse uma planilha\n",
    "        tree.grid(row=3, column=0, columnspan=6, padx=5, pady=5, stick=\"NSEW\")\n",
    "        \n",
    "        style = ttk.Style()\n",
    "        style.theme_use(\"clam\") #Definindo o tema para a treeview\n",
    "        style.configure(\"Treeview\", background=\"#FFFFE0\", foreground=\"black\",\n",
    "                       font=(\"Arial 12\"), rowheight=25, fiedlbackground=\"#FFFFE0\",\n",
    "                            bordercolor=\"#808080\", borderwidth=1) #Define as cores, fundo, cor do texto, altura da linha, cor do campo, cor e larrgura da borda\n",
    "        style.map(\"Treeview\", background=[('selected', \"#347083\")], foreground=[('selected', 'white')]) #Define a cor de fundo e texto quando uma linha é selecionada\n",
    "        \n",
    "        #Oculta a primeira coluna deixando a largura como 0\n",
    "        tree.column(\"#0\", width=0, stretch=False)\n",
    "        \n",
    "        \n",
    "        #Função que filtra os dados\n",
    "        def filtro():\n",
    "            \n",
    "            #Lê as informações da planilha\n",
    "            sheet = service.spreadsheets()\n",
    "            result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                      range=SAMPLE_RANGE_NAME).execute()\n",
    "\n",
    "            #Lê os dados da planilha do google sheets\n",
    "            valores = result['values']\n",
    "            \n",
    "            #Opçoes filtro pega o texto das combobox\n",
    "            estado = estado_combobox.get()\n",
    "            cidade = cidade_combobox.get()\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            produto = produtos_combobox.get()\n",
    "            \n",
    "            dados_filtrados = [valores[0]] #Inclui a linha do cabeçalho\n",
    "            for row in valores[1:]:\n",
    "                \n",
    "                if(not estado or row[0] == estado) and \\\n",
    "                    (not cidade or row[1] == cidade) and \\\n",
    "                    (not vendedor or row[2] == vendedor) and \\\n",
    "                    (not produto or row[3] == produto) and \\\n",
    "                    (not estado or row[0] == estado) :\n",
    "                    dados_filtrados.append(row)\n",
    "            \n",
    "            #Limpa os dados\n",
    "            for row in tree.get_children():\n",
    "                tree.delete(row)\n",
    "                \n",
    "            #Atualiza os dados da treeview\n",
    "            for row in dados_filtrados[1:]:\n",
    "                tree.insert(\"\", \"end\", values=row) \n",
    "                \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "                \n",
    "        #Cria botão Filtro\n",
    "        botao_filtrar = Button(root, text=\"Filtrar\", font=\"Arial 14\", command=filtro)\n",
    "        botao_filtrar.grid(row=4, column=1, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        def atualiza_cidades(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            estado = estado_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna B a partir da segunda linha\n",
    "            cidades = sorted(list(set([value[1] for value in valores[1:] if value[0] == estado])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            cidade_combobox['values'] = cidades\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        estado_combobox.bind(\"<<ComboboxSelected>>\", atualiza_cidades)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_vendedores(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            cidade = cidade_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna C a partir da segunda linha\n",
    "            vendedores = sorted(list(set([value[2] for value in valores[1:] if value[1] == cidade])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            vendedor_combobox['values'] = vendedores\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        cidade_combobox.bind(\"<<ComboboxSelected>>\", atualiza_vendedores)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_produtos(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna D a partir da segunda linha\n",
    "            produtos = sorted(list(set([value[3] for value in valores[1:] if value[2] == vendedor])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            produtos_combobox['values'] = produtos\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        vendedor_combobox.bind(\"<<ComboboxSelected>>\", atualiza_produtos)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def chama_filtro_a_cada_mudanca(event):\n",
    "            \n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Filtro as informações quando selecionar algo no campo de produtos\n",
    "        produtos_combobox.bind(\"<<ComboboxSelected>>\", chama_filtro_a_cada_mudanca)\n",
    "            \n",
    "        def novo_registro():\n",
    "            \n",
    "            #Cria uma janela secundária para cadastrar os dados\n",
    "            janela_cadastro = Toplevel(root)\n",
    "            janela_cadastro.title(\"Cadastrar Produto\")\n",
    "            \n",
    "            Label(janela_cadastro, text=\"Estado:\", font=\"Arial 16\").grid(row=0, column=0, padx=2, pady=2) \n",
    "            estado_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            estado_cadastro.grid(row=0, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Cidade:\", font=\"Arial 16\").grid(row=1, column=0, padx=2, pady=2) \n",
    "            cidade_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            cidade_cadastro.grid(row=1, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Vendedor:\", font=\"Arial 16\").grid(row=2, column=0, padx=2, pady=2) \n",
    "            vendedor_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            vendedor_cadastro.grid(row=2, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Produto:\", font=\"Arial 16\").grid(row=3, column=0, padx=2, pady=2) \n",
    "            produto_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            produto_cadastro.grid(row=3, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Preço:\", font=\"Arial 16\").grid(row=4, column=0, padx=2, pady=2) \n",
    "            preco_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            preco_cadastro.grid(row=4, column=1, padx=2, pady=2) \n",
    "            \n",
    "            def salvar_dados_google_sheets():\n",
    "                \n",
    "                #Obtem os valores dos campos de entrada de dados\n",
    "                estado = estado_cadastro.get()\n",
    "                cidade = cidade_cadastro.get()\n",
    "                vendedor = vendedor_cadastro.get()\n",
    "                produto = produto_cadastro.get()\n",
    "                preco = preco_cadastro.get()\n",
    "                \n",
    "                creds = None\n",
    "                if os.path.exists(CREDENTIALS_FILE): #Verifica se o arquivo de credenciais exsite\n",
    "                    creds = Credentials.from_authorized_user_file(CREDENTIALS_FILE, SCOPES) #Carrega as credenciais a partir do arquuivo\n",
    "                    \n",
    "                if not creds or not creds.valid: #Verifica se as credenciais são inválidas ou inexistes\n",
    "                    if creds and creds.expired and creds.reflesh_token: #Verifica se as credenciais expiraram e existe um token de atualização\n",
    "                        creds.refresh(Request()) #Atualiza as credenciais com o token de atualização\n",
    "                    else:\n",
    "                        \n",
    "                        #Se não houver credenciais ou elas forem inválidas abre o fluxo de autenticação do Google Sheets\n",
    "                        flow = InstalledAppFlow.from_client_secrets_file(                        \n",
    "                            'credentials.json', SCOPES)\n",
    "                        creds = flow.run_local_server(port=0) #Executa o fluxo de autenticação\n",
    "                        \n",
    "                    with open(CREDENTIALS_FILE, 'w') as token: #Abre o arquivo de credenciais para escrita\n",
    "                        token.write(creds.to_json()) #Escreve as credenciais no arquivo\n",
    "                        \n",
    "                #Cria uma instancia da API da planilha do Google\n",
    "                service = build('sheets', 'v4', credentials=creds)\n",
    "                \n",
    "                values = [[estado, cidade, vendedor, produto, preco]] #Cria uma lista com os valores obtidos dos campos de entrada\n",
    "                \n",
    "                body = {'values': values} #Cria um dicionário com a lista de valores\n",
    "\n",
    "                # Call the Sheets API\n",
    "                result = service.spreadsheets().values().append(\n",
    "                                spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=SAMPLE_RANGE_NAME,\n",
    "                                valueInputOption='USER_ENTERED', insertDataOption='INSERT_ROWS', body=body).execute()\n",
    "                                #Executa o método append para adicionar uma nova linha à planilha do Google Sheets\n",
    "            \n",
    "                tree.delete(tree.get_children()) #Remove todas as linhas da Treeview\n",
    "                result = service.spreadsheets().values().get(\n",
    "                            spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=SAMPLE_RANGE_NAME).execute() #Executa o método get() para obter os dados da planilha\n",
    "                \n",
    "                valores = result['values'] #Obtem os valores da planilha em formato de lista\n",
    "                for row in valores[1:]:\n",
    "                    tree.insert(\"\", \"end\", values=row)\n",
    "                    \n",
    "                #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "                soma_precos()\n",
    "                \n",
    "            #Cria botão Filtro\n",
    "            botao_salvar_novo_registro = Button(janela_cadastro, text=\"Cadastrar\", font=\"Arial 16\", command=salvar_dados_google_sheets)\n",
    "            botao_salvar_novo_registro.grid(row=6, column=0, columnspan=2, padx=2, pady=2, stick=\"NSEW\")\n",
    "            \n",
    "        #Cria botão Filtro\n",
    "        botao_novo = Button(root, text=\"Novo\", font=\"Arial 14\", command=novo_registro)\n",
    "        botao_novo.grid(row=4, column=0, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        #Cria o Label que exibe o total da coluna de preço e quantidade de itens na tela\n",
    "        total_label = Label(root, text=\"Total: R$ 0\", font=\"Arial 16\")\n",
    "        total_label.grid(row=5, column=0, columnspan=5, padx=2, pady=2, stick=\"W\") \n",
    "        \n",
    "        #Função que soma os preços dos produtos e conta a quantidade de linhas da treeview\n",
    "        def soma_precos():\n",
    "            \n",
    "            #Obtém os indices de todas as linhas\n",
    "            dados = tree.get_children()\n",
    "            \n",
    "            total = 0.0\n",
    "            qtd_linhas = 0.0\n",
    "            \n",
    "            for linha in dados:\n",
    "                \n",
    "                valores_linha = tree.item(linha)['values']\n",
    "                precos = []\n",
    "                \n",
    "                for v in valores_linha[4:]:\n",
    "                    if isinstance(v, str):\n",
    "                        preco = float(v.replace(',', '.'))\n",
    "                        precos.append(preco)\n",
    "                    else:\n",
    "                        precos.append(v)\n",
    "                        \n",
    "                total += sum(precos)\n",
    "                qtd_linhas += 1\n",
    "                \n",
    "            total_label.configure(text=\"Total: {:,.2f} - Linhas: {:,.0f}\". format(total, qtd_linhas))\n",
    "        \n",
    "        #Chama a função para exibir o total de preços e quantidade de linha da Treeview\n",
    "        soma_precos()\n",
    "        \n",
    "        #Exibo a tela\n",
    "        root.mainloop()\n",
    "\n",
    "        \n",
    "    except HttpError as err:\n",
    "        print(err)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0795116",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "28f7a694",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "from tkinter import ttk\n",
    "import os.path\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "import os.path\n",
    "\n",
    "from google.auth.transport.requests import Request\n",
    "from google.oauth2.credentials import Credentials\n",
    "from google_auth_oauthlib.flow import InstalledAppFlow\n",
    "from googleapiclient.discovery import build\n",
    "from googleapiclient.errors import HttpError\n",
    "\n",
    "# If modifying these scopes, delete the file token.json.\n",
    "SCOPES = ['https://www.googleapis.com/auth/spreadsheets']\n",
    "\n",
    "# The ID and range of a sample spreadsheet.\n",
    "SAMPLE_SPREADSHEET_ID = '1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM'\n",
    "SAMPLE_RANGE_NAME = 'Dados!A1:E'\n",
    "\n",
    "CREDENTIALS_FILE = 'token.json'\n",
    "\n",
    "#https://docs.google.com/spreadsheets/d/1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM/edit?usp=sharing\n",
    "\n",
    "def main():\n",
    "    \"\"\"Shows basic usage of the Sheets API.\n",
    "    Prints values from a sample spreadsheet.\n",
    "    \"\"\"\n",
    "    creds = None\n",
    "    # The file token.json stores the user's access and refresh tokens, and is\n",
    "    # created automatically when the authorization flow completes for the first\n",
    "    # time.\n",
    "    if os.path.exists('token.json'):\n",
    "        creds = Credentials.from_authorized_user_file('token.json', SCOPES)\n",
    "    # If there are no (valid) credentials available, let the user log in.\n",
    "    if not creds or not creds.valid:\n",
    "        if creds and creds.expired and creds.refresh_token:\n",
    "            creds.refresh(Request())\n",
    "        else:\n",
    "            flow = InstalledAppFlow.from_client_secrets_file(\n",
    "                'credentials.json', SCOPES)\n",
    "            creds = flow.run_local_server(port=0)\n",
    "        # Save the credentials for the next run\n",
    "        with open('token.json', 'w') as token:\n",
    "            token.write(creds.to_json())\n",
    "\n",
    "    try:\n",
    "        service = build('sheets', 'v4', credentials=creds)\n",
    "\n",
    "        # Call the Sheets API\n",
    "        sheet = service.spreadsheets()\n",
    "        result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                  range=SAMPLE_RANGE_NAME).execute()\n",
    "        \n",
    "        #Lê os dados da planilha do google sheets\n",
    "        valores = result.get('values', [])\n",
    "        \n",
    "              \n",
    "        #Criando a janela do Tkinter\n",
    "        root = Tk()\n",
    "        root.configure(bg='white') #Cor do fundo\n",
    "        root.title(\"Sistema Google Sheets\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        estado_label = Label(root, text=\"Estado:\", font=\"Arial 14\", bg='white')\n",
    "        estado_label.grid(row=0, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna A a partir da segunda linha\n",
    "        estados = sorted(list(set(value[0] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        estado_combobox = ttk.Combobox(root, values=estados, font=\"Arial 14\")\n",
    "        estado_combobox.grid(row=1, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        cidade_label = Label(root, text=\"Cidade:\", font=\"Arial 14\", bg='white')\n",
    "        cidade_label.grid(row=0, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna B a partir da segunda linha\n",
    "        cidades = sorted(list(set(value[1] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        cidade_combobox = ttk.Combobox(root, values=cidades, font=\"Arial 14\")\n",
    "        cidade_combobox.grid(row=1, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        vendedor_label = Label(root, text=\"Vendedor:\", font=\"Arial 14\", bg='white')\n",
    "        vendedor_label.grid(row=0, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna C a partir da segunda linha\n",
    "        vendedores = sorted(list(set(value[2] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        vendedor_combobox = ttk.Combobox(root, values=vendedores, font=\"Arial 14\")\n",
    "        vendedor_combobox.grid(row=1, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        produto_label = Label(root, text=\"Produto:\", font=\"Arial 14\", bg='white')\n",
    "        produto_label.grid(row=0, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna D a partir da segunda linha\n",
    "        produtos = sorted(list(set(value[3] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        produtos_combobox = ttk.Combobox(root, values=produtos, font=\"Arial 14\")\n",
    "        produtos_combobox.grid(row=1, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Cria uma treeview para exibir os dados da planilha\n",
    "        tree = ttk.Treeview(root)\n",
    "                \n",
    "        #Define as colunas da Treeview com base nos valores da linha 1 da planilha\n",
    "        colunas = valores[0]\n",
    "        tree[\"columns\"] = colunas\n",
    "        \n",
    "        #for - para\n",
    "        #Define o cabeçalho da Treeview\n",
    "        for linha in colunas:\n",
    "            tree.heading(linha, text=linha)\n",
    "        \n",
    "        #Adiciona os valores da planilha à Treeview\n",
    "        for row in valores[1:]:\n",
    "            tree.insert(\"\", \"end\", values=row)\n",
    "            \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena parte como se fosse uma planilha\n",
    "        tree.grid(row=3, column=0, columnspan=6, padx=5, pady=5, stick=\"NSEW\")\n",
    "        \n",
    "        style = ttk.Style()\n",
    "        style.theme_use(\"clam\") #Definindo o tema para a treeview\n",
    "        style.configure(\"Treeview\", background=\"#FFFFE0\", foreground=\"black\",\n",
    "                       font=(\"Arial 12\"), rowheight=25, fiedlbackground=\"#FFFFE0\",\n",
    "                            bordercolor=\"#808080\", borderwidth=1) #Define as cores, fundo, cor do texto, altura da linha, cor do campo, cor e larrgura da borda\n",
    "        style.map(\"Treeview\", background=[('selected', \"#347083\")], foreground=[('selected', 'white')]) #Define a cor de fundo e texto quando uma linha é selecionada\n",
    "        \n",
    "        #Oculta a primeira coluna deixando a largura como 0\n",
    "        tree.column(\"#0\", width=0, stretch=False)\n",
    "        \n",
    "        \n",
    "        #Função que filtra os dados\n",
    "        def filtro():\n",
    "            \n",
    "            #Lê as informações da planilha\n",
    "            sheet = service.spreadsheets()\n",
    "            result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                      range=SAMPLE_RANGE_NAME).execute()\n",
    "\n",
    "            #Lê os dados da planilha do google sheets\n",
    "            valores = result['values']\n",
    "            \n",
    "            #Opçoes filtro pega o texto das combobox\n",
    "            estado = estado_combobox.get()\n",
    "            cidade = cidade_combobox.get()\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            produto = produtos_combobox.get()\n",
    "            \n",
    "            dados_filtrados = [valores[0]] #Inclui a linha do cabeçalho\n",
    "            for row in valores[1:]:\n",
    "                \n",
    "                if(not estado or row[0] == estado) and \\\n",
    "                    (not cidade or row[1] == cidade) and \\\n",
    "                    (not vendedor or row[2] == vendedor) and \\\n",
    "                    (not produto or row[3] == produto) and \\\n",
    "                    (not estado or row[0] == estado) :\n",
    "                    dados_filtrados.append(row)\n",
    "            \n",
    "            #Limpa os dados\n",
    "            for row in tree.get_children():\n",
    "                tree.delete(row)\n",
    "                \n",
    "            #Atualiza os dados da treeview\n",
    "            for row in dados_filtrados[1:]:\n",
    "                tree.insert(\"\", \"end\", values=row) \n",
    "                \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "                \n",
    "        #Cria botão Filtro\n",
    "        botao_filtrar = Button(root, text=\"Filtrar\", font=\"Arial 14\", command=filtro)\n",
    "        botao_filtrar.grid(row=4, column=1, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        def atualiza_cidades(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            estado = estado_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna B a partir da segunda linha\n",
    "            cidades = sorted(list(set([value[1] for value in valores[1:] if value[0] == estado])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            cidade_combobox['values'] = cidades\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        estado_combobox.bind(\"<<ComboboxSelected>>\", atualiza_cidades)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_vendedores(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            cidade = cidade_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna C a partir da segunda linha\n",
    "            vendedores = sorted(list(set([value[2] for value in valores[1:] if value[1] == cidade])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            vendedor_combobox['values'] = vendedores\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        cidade_combobox.bind(\"<<ComboboxSelected>>\", atualiza_vendedores)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_produtos(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna D a partir da segunda linha\n",
    "            produtos = sorted(list(set([value[3] for value in valores[1:] if value[2] == vendedor])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            produtos_combobox['values'] = produtos\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        vendedor_combobox.bind(\"<<ComboboxSelected>>\", atualiza_produtos)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def chama_filtro_a_cada_mudanca(event):\n",
    "            \n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Filtro as informações quando selecionar algo no campo de produtos\n",
    "        produtos_combobox.bind(\"<<ComboboxSelected>>\", chama_filtro_a_cada_mudanca)\n",
    "            \n",
    "        def novo_registro():\n",
    "            \n",
    "            #Cria uma janela secundária para cadastrar os dados\n",
    "            janela_cadastro = Toplevel(root)\n",
    "            janela_cadastro.title(\"Cadastrar Produto\")\n",
    "            \n",
    "            Label(janela_cadastro, text=\"Estado:\", font=\"Arial 16\").grid(row=0, column=0, padx=2, pady=2) \n",
    "            estado_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            estado_cadastro.grid(row=0, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Cidade:\", font=\"Arial 16\").grid(row=1, column=0, padx=2, pady=2) \n",
    "            cidade_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            cidade_cadastro.grid(row=1, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Vendedor:\", font=\"Arial 16\").grid(row=2, column=0, padx=2, pady=2) \n",
    "            vendedor_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            vendedor_cadastro.grid(row=2, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Produto:\", font=\"Arial 16\").grid(row=3, column=0, padx=2, pady=2) \n",
    "            produto_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            produto_cadastro.grid(row=3, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Preço:\", font=\"Arial 16\").grid(row=4, column=0, padx=2, pady=2) \n",
    "            preco_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            preco_cadastro.grid(row=4, column=1, padx=2, pady=2) \n",
    "            \n",
    "            def salvar_dados_google_sheets():\n",
    "                \n",
    "                #Obtem os valores dos campos de entrada de dados\n",
    "                estado = estado_cadastro.get()\n",
    "                cidade = cidade_cadastro.get()\n",
    "                vendedor = vendedor_cadastro.get()\n",
    "                produto = produto_cadastro.get()\n",
    "                preco = preco_cadastro.get()\n",
    "                \n",
    "                creds = None\n",
    "                if os.path.exists(CREDENTIALS_FILE): #Verifica se o arquivo de credenciais exsite\n",
    "                    creds = Credentials.from_authorized_user_file(CREDENTIALS_FILE, SCOPES) #Carrega as credenciais a partir do arquuivo\n",
    "                    \n",
    "                if not creds or not creds.valid: #Verifica se as credenciais são inválidas ou inexistes\n",
    "                    if creds and creds.expired and creds.reflesh_token: #Verifica se as credenciais expiraram e existe um token de atualização\n",
    "                        creds.refresh(Request()) #Atualiza as credenciais com o token de atualização\n",
    "                    else:\n",
    "                        \n",
    "                        #Se não houver credenciais ou elas forem inválidas abre o fluxo de autenticação do Google Sheets\n",
    "                        flow = InstalledAppFlow.from_client_secrets_file(                        \n",
    "                            'credentials.json', SCOPES)\n",
    "                        creds = flow.run_local_server(port=0) #Executa o fluxo de autenticação\n",
    "                        \n",
    "                    with open(CREDENTIALS_FILE, 'w') as token: #Abre o arquivo de credenciais para escrita\n",
    "                        token.write(creds.to_json()) #Escreve as credenciais no arquivo\n",
    "                        \n",
    "                #Cria uma instancia da API da planilha do Google\n",
    "                service = build('sheets', 'v4', credentials=creds)\n",
    "                \n",
    "                values = [[estado, cidade, vendedor, produto, preco]] #Cria uma lista com os valores obtidos dos campos de entrada\n",
    "                \n",
    "                body = {'values': values} #Cria um dicionário com a lista de valores\n",
    "\n",
    "                # Call the Sheets API\n",
    "                result = service.spreadsheets().values().append(\n",
    "                                spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=SAMPLE_RANGE_NAME,\n",
    "                                valueInputOption='USER_ENTERED', insertDataOption='INSERT_ROWS', body=body).execute()\n",
    "                                #Executa o método append para adicionar uma nova linha à planilha do Google Sheets\n",
    "            \n",
    "                tree.delete(*tree.get_children()) #Remove todas as linhas da Treeview\n",
    "                result = service.spreadsheets().values().get(\n",
    "                            spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=SAMPLE_RANGE_NAME).execute() #Executa o método get() para obter os dados da planilha\n",
    "                \n",
    "                valores = result['values'] #Obtem os valores da planilha em formato de lista\n",
    "                for row in valores[1:]:\n",
    "                    tree.insert(\"\", \"end\", values=row)\n",
    "                    \n",
    "                #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "                soma_precos()\n",
    "                \n",
    "            #Cria botão Filtro\n",
    "            botao_salvar_novo_registro = Button(janela_cadastro, text=\"Cadastrar\", font=\"Arial 16\", command=salvar_dados_google_sheets)\n",
    "            botao_salvar_novo_registro.grid(row=6, column=0, columnspan=2, padx=2, pady=2, stick=\"NSEW\")\n",
    "            \n",
    "        #Cria botão Filtro\n",
    "        botao_novo = Button(root, text=\"Novo\", font=\"Arial 14\", command=novo_registro)\n",
    "        botao_novo.grid(row=4, column=0, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        def excluir_item():\n",
    "            \n",
    "            #Obtem o indice da linha selecionada na Treeview\n",
    "            item_selecionado = tree.focus()\n",
    "            index = tree.index(item_selecionado)\n",
    "            \n",
    "            #Obtem o ID da planilha e o intervalo da linha que deseja excluir\n",
    "            spreadsheet_id = SAMPLE_SPREADSHEET_ID\n",
    "            #range_ = f'Dados!A{index+2}:E{index+2}'\n",
    "            \n",
    "            #Cria uma solicitação para remover a linha\n",
    "            request = {\n",
    "                \"deleteRange\":{\n",
    "                    \"range\": {\n",
    "                        \"sheetId\": 0, #O id da planilha\n",
    "                        \"startRowIndex\": index + 1,\n",
    "                        \"endRowIndex\": index + 2,\n",
    "                        \"startColumnIndex\": 0,\n",
    "                        \"endColumnIndex\" : 5\n",
    "                    },\n",
    "                    \"shiftDimension\": \"ROWS\" #Indica que as célula abaixo devem ser movidas para cima\n",
    "                    \n",
    "                }\n",
    "            }\n",
    "            \n",
    "            #Executa a solicitação para remover a linha\n",
    "            service = build('sheets', 'v4', credentials=creds)\n",
    "            response = service.spreadsheets().batchUpdate(spreadsheetId = spreadsheet_id, body={\n",
    "                \"requests\":[request]\n",
    "            }).execute()\n",
    "            \n",
    "            #Remove o item selecionado da treview\n",
    "            tree.delete(item_selecionado)\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "                \n",
    "        \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena partes como se fosse uma planilha\n",
    "        #Cria botão Deletar\n",
    "        botao_deletar = Button(root, text=\"Deletar\", font=\"Arial 14\", command=excluir_item)\n",
    "        botao_deletar.grid(row=4, column=2, padx=2, pady=2, stick=\"NSEW\") \n",
    "\n",
    "        \n",
    "        #Cria o Label que exibe o total da coluna de preço e quantidade de itens na tela\n",
    "        total_label = Label(root, text=\"Total: R$ 0\", font=\"Arial 16\")\n",
    "        total_label.grid(row=5, column=0, columnspan=5, padx=2, pady=2, stick=\"W\") \n",
    "        \n",
    "        #Função que soma os preços dos produtos e conta a quantidade de linhas da treeview\n",
    "        def soma_precos():\n",
    "            \n",
    "            #Obtém os indices de todas as linhas\n",
    "            dados = tree.get_children()\n",
    "            \n",
    "            total = 0.0\n",
    "            qtd_linhas = 0.0\n",
    "            \n",
    "            for linha in dados:\n",
    "                \n",
    "                valores_linha = tree.item(linha)['values']\n",
    "                precos = []\n",
    "                \n",
    "                for v in valores_linha[4:]:\n",
    "                    if isinstance(v, str):\n",
    "                        preco = float(v.replace(',', '.'))\n",
    "                        precos.append(preco)\n",
    "                    else:\n",
    "                        precos.append(v)\n",
    "                        \n",
    "                total += sum(precos)\n",
    "                qtd_linhas += 1\n",
    "                \n",
    "            total_label.configure(text=\"Total: {:,.2f} - Linhas: {:,.0f}\". format(total, qtd_linhas))\n",
    "        \n",
    "        #Chama a função para exibir o total de preços e quantidade de linha da Treeview\n",
    "        soma_precos()\n",
    "        \n",
    "        #Exibo a tela\n",
    "        root.mainloop()\n",
    "\n",
    "        \n",
    "    except HttpError as err:\n",
    "        print(err)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24deeb6e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fe11f8a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "from tkinter import ttk\n",
    "import os.path\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "import os.path\n",
    "\n",
    "from google.auth.transport.requests import Request\n",
    "from google.oauth2.credentials import Credentials\n",
    "from google_auth_oauthlib.flow import InstalledAppFlow\n",
    "from googleapiclient.discovery import build\n",
    "from googleapiclient.errors import HttpError\n",
    "\n",
    "# If modifying these scopes, delete the file token.json.\n",
    "SCOPES = ['https://www.googleapis.com/auth/spreadsheets']\n",
    "\n",
    "# The ID and range of a sample spreadsheet.\n",
    "SAMPLE_SPREADSHEET_ID = '1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM'\n",
    "SAMPLE_RANGE_NAME = 'Dados!A1:E'\n",
    "\n",
    "CREDENTIALS_FILE = 'token.json'\n",
    "\n",
    "#https://docs.google.com/spreadsheets/d/1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM/edit?usp=sharing\n",
    "\n",
    "def main():\n",
    "    \"\"\"Shows basic usage of the Sheets API.\n",
    "    Prints values from a sample spreadsheet.\n",
    "    \"\"\"\n",
    "    creds = None\n",
    "    # The file token.json stores the user's access and refresh tokens, and is\n",
    "    # created automatically when the authorization flow completes for the first\n",
    "    # time.\n",
    "    if os.path.exists('token.json'):\n",
    "        creds = Credentials.from_authorized_user_file('token.json', SCOPES)\n",
    "    # If there are no (valid) credentials available, let the user log in.\n",
    "    if not creds or not creds.valid:\n",
    "        if creds and creds.expired and creds.refresh_token:\n",
    "            creds.refresh(Request())\n",
    "        else:\n",
    "            flow = InstalledAppFlow.from_client_secrets_file(\n",
    "                'credentials.json', SCOPES)\n",
    "            creds = flow.run_local_server(port=0)\n",
    "        # Save the credentials for the next run\n",
    "        with open('token.json', 'w') as token:\n",
    "            token.write(creds.to_json())\n",
    "\n",
    "    try:\n",
    "        service = build('sheets', 'v4', credentials=creds)\n",
    "\n",
    "        # Call the Sheets API\n",
    "        sheet = service.spreadsheets()\n",
    "        result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                  range=SAMPLE_RANGE_NAME).execute()\n",
    "        \n",
    "        #Lê os dados da planilha do google sheets\n",
    "        valores = result.get('values', [])\n",
    "        \n",
    "              \n",
    "        #Criando a janela do Tkinter\n",
    "        root = Tk()\n",
    "        root.configure(bg='white') #Cor do fundo\n",
    "        root.title(\"Sistema Google Sheets\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        estado_label = Label(root, text=\"Estado:\", font=\"Arial 14\", bg='white')\n",
    "        estado_label.grid(row=0, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna A a partir da segunda linha\n",
    "        estados = sorted(list(set(value[0] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        estado_combobox = ttk.Combobox(root, values=estados, font=\"Arial 14\")\n",
    "        estado_combobox.grid(row=1, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        cidade_label = Label(root, text=\"Cidade:\", font=\"Arial 14\", bg='white')\n",
    "        cidade_label.grid(row=0, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna B a partir da segunda linha\n",
    "        cidades = sorted(list(set(value[1] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        cidade_combobox = ttk.Combobox(root, values=cidades, font=\"Arial 14\")\n",
    "        cidade_combobox.grid(row=1, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        vendedor_label = Label(root, text=\"Vendedor:\", font=\"Arial 14\", bg='white')\n",
    "        vendedor_label.grid(row=0, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna C a partir da segunda linha\n",
    "        vendedores = sorted(list(set(value[2] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        vendedor_combobox = ttk.Combobox(root, values=vendedores, font=\"Arial 14\")\n",
    "        vendedor_combobox.grid(row=1, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        produto_label = Label(root, text=\"Produto:\", font=\"Arial 14\", bg='white')\n",
    "        produto_label.grid(row=0, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna D a partir da segunda linha\n",
    "        produtos = sorted(list(set(value[3] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        produtos_combobox = ttk.Combobox(root, values=produtos, font=\"Arial 14\")\n",
    "        produtos_combobox.grid(row=1, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Cria uma treeview para exibir os dados da planilha\n",
    "        tree = ttk.Treeview(root)\n",
    "                \n",
    "        #Define as colunas da Treeview com base nos valores da linha 1 da planilha\n",
    "        colunas = valores[0]\n",
    "        tree[\"columns\"] = colunas\n",
    "        \n",
    "        #for - para\n",
    "        #Define o cabeçalho da Treeview\n",
    "        for linha in colunas:\n",
    "            tree.heading(linha, text=linha)\n",
    "        \n",
    "        #Adiciona os valores da planilha à Treeview\n",
    "        for row in valores[1:]:\n",
    "            tree.insert(\"\", \"end\", values=row)\n",
    "            \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena parte como se fosse uma planilha\n",
    "        tree.grid(row=3, column=0, columnspan=6, padx=5, pady=5, stick=\"NSEW\")\n",
    "        \n",
    "        style = ttk.Style()\n",
    "        style.theme_use(\"clam\") #Definindo o tema para a treeview\n",
    "        style.configure(\"Treeview\", background=\"#FFFFE0\", foreground=\"black\",\n",
    "                       font=(\"Arial 12\"), rowheight=25, fiedlbackground=\"#FFFFE0\",\n",
    "                            bordercolor=\"#808080\", borderwidth=1) #Define as cores, fundo, cor do texto, altura da linha, cor do campo, cor e larrgura da borda\n",
    "        style.map(\"Treeview\", background=[('selected', \"#347083\")], foreground=[('selected', 'white')]) #Define a cor de fundo e texto quando uma linha é selecionada\n",
    "        \n",
    "        #Oculta a primeira coluna deixando a largura como 0\n",
    "        tree.column(\"#0\", width=0, stretch=False)\n",
    "        \n",
    "        \n",
    "        #Função que filtra os dados\n",
    "        def filtro():\n",
    "            \n",
    "            #Lê as informações da planilha\n",
    "            sheet = service.spreadsheets()\n",
    "            result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                      range=SAMPLE_RANGE_NAME).execute()\n",
    "\n",
    "            #Lê os dados da planilha do google sheets\n",
    "            valores = result['values']\n",
    "            \n",
    "            #Opçoes filtro pega o texto das combobox\n",
    "            estado = estado_combobox.get()\n",
    "            cidade = cidade_combobox.get()\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            produto = produtos_combobox.get()\n",
    "            \n",
    "            dados_filtrados = [valores[0]] #Inclui a linha do cabeçalho\n",
    "            for row in valores[1:]:\n",
    "                \n",
    "                if(not estado or row[0] == estado) and \\\n",
    "                    (not cidade or row[1] == cidade) and \\\n",
    "                    (not vendedor or row[2] == vendedor) and \\\n",
    "                    (not produto or row[3] == produto) and \\\n",
    "                    (not estado or row[0] == estado) :\n",
    "                    dados_filtrados.append(row)\n",
    "            \n",
    "            #Limpa os dados\n",
    "            for row in tree.get_children():\n",
    "                tree.delete(row)\n",
    "                \n",
    "            #Atualiza os dados da treeview\n",
    "            for row in dados_filtrados[1:]:\n",
    "                tree.insert(\"\", \"end\", values=row) \n",
    "                \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "                \n",
    "        #Cria botão Filtro\n",
    "        botao_filtrar = Button(root, text=\"Filtrar\", font=\"Arial 14\", command=filtro)\n",
    "        botao_filtrar.grid(row=4, column=1, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        def atualiza_cidades(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            estado = estado_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna B a partir da segunda linha\n",
    "            cidades = sorted(list(set([value[1] for value in valores[1:] if value[0] == estado])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            cidade_combobox['values'] = cidades\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        estado_combobox.bind(\"<<ComboboxSelected>>\", atualiza_cidades)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_vendedores(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            cidade = cidade_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna C a partir da segunda linha\n",
    "            vendedores = sorted(list(set([value[2] for value in valores[1:] if value[1] == cidade])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            vendedor_combobox['values'] = vendedores\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        cidade_combobox.bind(\"<<ComboboxSelected>>\", atualiza_vendedores)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_produtos(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna D a partir da segunda linha\n",
    "            produtos = sorted(list(set([value[3] for value in valores[1:] if value[2] == vendedor])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            produtos_combobox['values'] = produtos\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        vendedor_combobox.bind(\"<<ComboboxSelected>>\", atualiza_produtos)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def chama_filtro_a_cada_mudanca(event):\n",
    "            \n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Filtro as informações quando selecionar algo no campo de produtos\n",
    "        produtos_combobox.bind(\"<<ComboboxSelected>>\", chama_filtro_a_cada_mudanca)\n",
    "            \n",
    "        def novo_registro():\n",
    "            \n",
    "            #Cria uma janela secundária para cadastrar os dados\n",
    "            janela_cadastro = Toplevel(root)\n",
    "            janela_cadastro.title(\"Cadastrar Produto\")\n",
    "            \n",
    "            Label(janela_cadastro, text=\"Estado:\", font=\"Arial 16\").grid(row=0, column=0, padx=2, pady=2) \n",
    "            estado_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            estado_cadastro.grid(row=0, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Cidade:\", font=\"Arial 16\").grid(row=1, column=0, padx=2, pady=2) \n",
    "            cidade_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            cidade_cadastro.grid(row=1, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Vendedor:\", font=\"Arial 16\").grid(row=2, column=0, padx=2, pady=2) \n",
    "            vendedor_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            vendedor_cadastro.grid(row=2, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Produto:\", font=\"Arial 16\").grid(row=3, column=0, padx=2, pady=2) \n",
    "            produto_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            produto_cadastro.grid(row=3, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Preço:\", font=\"Arial 16\").grid(row=4, column=0, padx=2, pady=2) \n",
    "            preco_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            preco_cadastro.grid(row=4, column=1, padx=2, pady=2) \n",
    "            \n",
    "            def salvar_dados_google_sheets():\n",
    "                \n",
    "                #Obtem os valores dos campos de entrada de dados\n",
    "                estado = estado_cadastro.get()\n",
    "                cidade = cidade_cadastro.get()\n",
    "                vendedor = vendedor_cadastro.get()\n",
    "                produto = produto_cadastro.get()\n",
    "                preco = preco_cadastro.get()\n",
    "                \n",
    "                creds = None\n",
    "                if os.path.exists(CREDENTIALS_FILE): #Verifica se o arquivo de credenciais exsite\n",
    "                    creds = Credentials.from_authorized_user_file(CREDENTIALS_FILE, SCOPES) #Carrega as credenciais a partir do arquuivo\n",
    "                    \n",
    "                if not creds or not creds.valid: #Verifica se as credenciais são inválidas ou inexistes\n",
    "                    if creds and creds.expired and creds.reflesh_token: #Verifica se as credenciais expiraram e existe um token de atualização\n",
    "                        creds.refresh(Request()) #Atualiza as credenciais com o token de atualização\n",
    "                    else:\n",
    "                        \n",
    "                        #Se não houver credenciais ou elas forem inválidas abre o fluxo de autenticação do Google Sheets\n",
    "                        flow = InstalledAppFlow.from_client_secrets_file(                        \n",
    "                            'credentials.json', SCOPES)\n",
    "                        creds = flow.run_local_server(port=0) #Executa o fluxo de autenticação\n",
    "                        \n",
    "                    with open(CREDENTIALS_FILE, 'w') as token: #Abre o arquivo de credenciais para escrita\n",
    "                        token.write(creds.to_json()) #Escreve as credenciais no arquivo\n",
    "                        \n",
    "                #Cria uma instancia da API da planilha do Google\n",
    "                service = build('sheets', 'v4', credentials=creds)\n",
    "                \n",
    "                values = [[estado, cidade, vendedor, produto, preco]] #Cria uma lista com os valores obtidos dos campos de entrada\n",
    "                \n",
    "                body = {'values': values} #Cria um dicionário com a lista de valores\n",
    "\n",
    "                # Call the Sheets API\n",
    "                result = service.spreadsheets().values().append(\n",
    "                                spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=SAMPLE_RANGE_NAME,\n",
    "                                valueInputOption='USER_ENTERED', insertDataOption='INSERT_ROWS', body=body).execute()\n",
    "                                #Executa o método append para adicionar uma nova linha à planilha do Google Sheets\n",
    "            \n",
    "                tree.delete(*tree.get_children()) #Remove todas as linhas da Treeview\n",
    "                result = service.spreadsheets().values().get(\n",
    "                            spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=SAMPLE_RANGE_NAME).execute() #Executa o método get() para obter os dados da planilha\n",
    "                \n",
    "                valores = result['values'] #Obtem os valores da planilha em formato de lista\n",
    "                for row in valores[1:]:\n",
    "                    tree.insert(\"\", \"end\", values=row)\n",
    "                    \n",
    "                #Fecha a janela de cadastro\n",
    "                janela_cadastro.destroy()\n",
    "                    \n",
    "                #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "                soma_precos()\n",
    "                \n",
    "            #Cria botão Filtro\n",
    "            botao_salvar_novo_registro = Button(janela_cadastro, text=\"Cadastrar\", font=\"Arial 16\", command=salvar_dados_google_sheets)\n",
    "            botao_salvar_novo_registro.grid(row=6, column=0, columnspan=2, padx=2, pady=2, stick=\"NSEW\")\n",
    "            \n",
    "        #Cria botão Filtro\n",
    "        botao_novo = Button(root, text=\"Novo\", font=\"Arial 14\", command=novo_registro)\n",
    "        botao_novo.grid(row=4, column=0, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        #------------------------------------------------------------------------------\n",
    "        \n",
    "        def janela_editar(event):\n",
    "            \n",
    "            #Obtem o item selecionado da treeview\n",
    "            item_selecionado = tree.selection()[0]\n",
    "            \n",
    "            #Obtem os valores do item selecionado\n",
    "            valores_selecionados = tree.item(item_selecionado)['values']\n",
    "            \n",
    "            #Cria uma janela secundária para cadastrar os dados\n",
    "            janela_edicao = Toplevel(root)\n",
    "            janela_edicao.title(\"Editar Produto\")\n",
    "            \n",
    "            Label(janela_edicao, text=\"Estado:\", font=\"Arial 16\").grid(row=0, column=0, padx=2, pady=2) \n",
    "            estado_edicao = Entry(janela_edicao, font=\"Arial 16\", textvariable=StringVar(value=valores_selecionados[0])) #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            estado_edicao.grid(row=0, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_edicao, text=\"Cidade:\", font=\"Arial 16\").grid(row=1, column=0, padx=2, pady=2) \n",
    "            cidade_edicao = Entry(janela_edicao, font=\"Arial 16\", textvariable=StringVar(value=valores_selecionados[1])) #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            cidade_edicao.grid(row=1, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_edicao, text=\"Vendedor:\", font=\"Arial 16\").grid(row=2, column=0, padx=2, pady=2) \n",
    "            vendedor_edicao = Entry(janela_edicao, font=\"Arial 16\", textvariable=StringVar(value=valores_selecionados[2])) #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            vendedor_edicao.grid(row=2, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_edicao, text=\"Produto:\", font=\"Arial 16\").grid(row=3, column=0, padx=2, pady=2) \n",
    "            produto_edicao = Entry(janela_edicao, font=\"Arial 16\", textvariable=StringVar(value=valores_selecionados[3])) #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            produto_edicao.grid(row=3, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_edicao, text=\"Preço:\", font=\"Arial 16\").grid(row=4, column=0, padx=2, pady=2) \n",
    "            preco_edicao = Entry(janela_edicao, font=\"Arial 16\", textvariable=StringVar(value=valores_selecionados[4])) #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            preco_edicao.grid(row=4, column=1, padx=2, pady=2) \n",
    "            \n",
    "            def alterar_dados_google_sheets():\n",
    "                \n",
    "                #Obtem os valores dos campos de entrada de dados\n",
    "                estado = estado_edicao.get()\n",
    "                cidade = cidade_edicao.get()\n",
    "                vendedor = vendedor_edicao.get()\n",
    "                produto = produto_edicao.get()\n",
    "                preco = preco_edicao.get()\n",
    "                \n",
    "                #Lê as credenciais do usuário ou pede autorização para acessar a planilha do Google Sheets\n",
    "                creds = None\n",
    "                if os.path.exists('token.json'): #Verifica se o arquivo de credenciais exsite\n",
    "                    creds = Credentials.from_authorized_user_file('token.json', SCOPES) #Carrega as credenciais a partir do arquuivo\n",
    "                    \n",
    "                if not creds or not creds.valid: #Verifica se as credenciais são inválidas ou inexistes\n",
    "                    if creds and creds.expired and creds.reflesh_token: #Verifica se as credenciais expiraram e existe um token de atualização\n",
    "                        creds.refresh(Request()) #Atualiza as credenciais com o token de atualização\n",
    "                    else:\n",
    "                        \n",
    "                        #Se não houver credenciais ou elas forem inválidas abre o fluxo de autenticação do Google Sheets\n",
    "                        flow = InstalledAppFlow.from_client_secrets_file(                        \n",
    "                            'credentials.json', SCOPES)\n",
    "                        creds = flow.run_local_server(port=0) #Executa o fluxo de autenticação\n",
    "                        \n",
    "                    with open('token.json', 'w') as token: #Abre o arquivo de credenciais para escrita\n",
    "                        token.write(creds.to_json()) #Escreve as credenciais no arquivo\n",
    "                        \n",
    "                #Cria uma instancia da API da planilha do Google\n",
    "                service = build('sheets', 'v4', credentials=creds)\n",
    "                \n",
    "                #Quando colo o RAW significa que os dados serão salvos como eles estão\n",
    "                value_input_option = 'RAW'\n",
    "                \n",
    "                values = [\n",
    "                    [\n",
    "                        estado,\n",
    "                        cidade,\n",
    "                        vendedor,\n",
    "                        produto,\n",
    "                        preco\n",
    "                    ]\n",
    "                ]\n",
    "                \n",
    "                #Converte o indice da linha em uma string / texto\n",
    "                linha = str(tree.index(item_selecionado) + 2)\n",
    "                \n",
    "                #Usa a string format para criar a range que vamos alterar os dados\n",
    "                range_ = f'Dados!A{linha}:E{linha}'\n",
    "                \n",
    "                body = {\n",
    "                    \n",
    "                    'values' : values\n",
    "                    \n",
    "                }\n",
    "\n",
    "                # Call the Sheets API\n",
    "                result = sheet.values().update(\n",
    "                                spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=range_,\n",
    "                                valueInputOption=value_input_option, body=body).execute()\n",
    "                                #Executa o método append para adicionar uma nova linha à planilha do Google Sheets\n",
    "            \n",
    "                #Atualiza a exibição da Treeview com os novos valores\n",
    "                tree.item(item_selecionado, values=values[0])\n",
    "                \n",
    "                \n",
    "                #Fecha a janela de edição\n",
    "                janela_edicao.destroy()\n",
    "                \n",
    "                #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "                soma_precos()\n",
    "            \n",
    "                \n",
    "            #Cria botão Filtro\n",
    "            botao_alterar_dados = Button(janela_edicao, text=\"Salvar Alterações\", font=\"Arial 16\", command=alterar_dados_google_sheets)\n",
    "            botao_alterar_dados.grid(row=6, column=0, columnspan=2, padx=2, pady=2, stick=\"NSEW\")\n",
    "          \n",
    "        #Evendo de duplo clique na Treeview\n",
    "        tree.bind(\"<Double-1>\", janela_editar)\n",
    "           \n",
    "        def excluir_item():\n",
    "            \n",
    "            #Obtem o indice da linha selecionada na Treeview\n",
    "            item_selecionado = tree.focus()\n",
    "            index = tree.index(item_selecionado)\n",
    "            \n",
    "            #Obtem o ID da planilha e o intervalo da linha que deseja excluir\n",
    "            spreadsheet_id = SAMPLE_SPREADSHEET_ID\n",
    "            #range_ = f'Dados!A{index+2}:E{index+2}'\n",
    "            \n",
    "            #Cria uma solicitação para remover a linha\n",
    "            request = {\n",
    "                \"deleteRange\":{\n",
    "                    \"range\": {\n",
    "                        \"sheetId\": 0, #O id da planilha\n",
    "                        \"startRowIndex\": index + 1,\n",
    "                        \"endRowIndex\": index + 2,\n",
    "                        \"startColumnIndex\": 0,\n",
    "                        \"endColumnIndex\" : 5\n",
    "                    },\n",
    "                    \"shiftDimension\": \"ROWS\" #Indica que as célula abaixo devem ser movidas para cima\n",
    "                    \n",
    "                }\n",
    "            }\n",
    "            \n",
    "            #Executa a solicitação para remover a linha\n",
    "            service = build('sheets', 'v4', credentials=creds)\n",
    "            response = service.spreadsheets().batchUpdate(spreadsheetId = spreadsheet_id, body={\n",
    "                \"requests\":[request]\n",
    "            }).execute()\n",
    "            \n",
    "            #Remove o item selecionado da treview\n",
    "            tree.delete(item_selecionado)\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "                \n",
    "        \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena partes como se fosse uma planilha\n",
    "        #Cria botão Deletar\n",
    "        botao_deletar = Button(root, text=\"Deletar\", font=\"Arial 14\", command=excluir_item)\n",
    "        botao_deletar.grid(row=4, column=2, padx=2, pady=2, stick=\"NSEW\") \n",
    "\n",
    "        \n",
    "        #Cria o Label que exibe o total da coluna de preço e quantidade de itens na tela\n",
    "        total_label = Label(root, text=\"Total: R$ 0\", font=\"Arial 16\")\n",
    "        total_label.grid(row=5, column=0, columnspan=5, padx=2, pady=2, stick=\"W\") \n",
    "        \n",
    "        #Função que soma os preços dos produtos e conta a quantidade de linhas da treeview\n",
    "        def soma_precos():\n",
    "            \n",
    "            #Obtém os indices de todas as linhas\n",
    "            dados = tree.get_children()\n",
    "            \n",
    "            total = 0.0\n",
    "            qtd_linhas = 0.0\n",
    "            \n",
    "            for linha in dados:\n",
    "                \n",
    "                valores_linha = tree.item(linha)['values']\n",
    "                precos = []\n",
    "                \n",
    "                for v in valores_linha[4:]:\n",
    "                    if isinstance(v, str):\n",
    "                        preco = float(v.replace(',', '.'))\n",
    "                        precos.append(preco)\n",
    "                    else:\n",
    "                        precos.append(v)\n",
    "                        \n",
    "                total += sum(precos)\n",
    "                qtd_linhas += 1\n",
    "                \n",
    "            total_label.configure(text=\"Total: {:,.2f} - Linhas: {:,.0f}\". format(total, qtd_linhas))\n",
    "        \n",
    "        #Chama a função para exibir o total de preços e quantidade de linha da Treeview\n",
    "        soma_precos()\n",
    "        \n",
    "        #Exibo a tela\n",
    "        root.mainloop()\n",
    "\n",
    "        \n",
    "    except HttpError as err:\n",
    "        print(err)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "986c3e92",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5932fc4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "from tkinter import ttk\n",
    "import os.path\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "import os.path\n",
    "\n",
    "from google.auth.transport.requests import Request\n",
    "from google.oauth2.credentials import Credentials\n",
    "from google_auth_oauthlib.flow import InstalledAppFlow\n",
    "from googleapiclient.discovery import build\n",
    "from googleapiclient.errors import HttpError\n",
    "\n",
    "# If modifying these scopes, delete the file token.json.\n",
    "SCOPES = ['https://www.googleapis.com/auth/spreadsheets']\n",
    "\n",
    "# The ID and range of a sample spreadsheet.\n",
    "SAMPLE_SPREADSHEET_ID = '1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM'\n",
    "SAMPLE_RANGE_NAME = 'Dados!A1:E'\n",
    "\n",
    "CREDENTIALS_FILE = 'token.json'\n",
    "\n",
    "#https://docs.google.com/spreadsheets/d/1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM/edit?usp=sharing\n",
    "\n",
    "def main():\n",
    "    \"\"\"Shows basic usage of the Sheets API.\n",
    "    Prints values from a sample spreadsheet.\n",
    "    \"\"\"\n",
    "    creds = None\n",
    "    # The file token.json stores the user's access and refresh tokens, and is\n",
    "    # created automatically when the authorization flow completes for the first\n",
    "    # time.\n",
    "    if os.path.exists('token.json'):\n",
    "        creds = Credentials.from_authorized_user_file('token.json', SCOPES)\n",
    "    # If there are no (valid) credentials available, let the user log in.\n",
    "    if not creds or not creds.valid:\n",
    "        if creds and creds.expired and creds.refresh_token:\n",
    "            creds.refresh(Request())\n",
    "        else:\n",
    "            flow = InstalledAppFlow.from_client_secrets_file(\n",
    "                'credentials.json', SCOPES)\n",
    "            creds = flow.run_local_server(port=0)\n",
    "        # Save the credentials for the next run\n",
    "        with open('token.json', 'w') as token:\n",
    "            token.write(creds.to_json())\n",
    "\n",
    "    try:\n",
    "        service = build('sheets', 'v4', credentials=creds)\n",
    "\n",
    "        # Call the Sheets API\n",
    "        sheet = service.spreadsheets()\n",
    "        result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                  range=SAMPLE_RANGE_NAME).execute()\n",
    "        \n",
    "        #Lê os dados da planilha do google sheets\n",
    "        valores = result.get('values', [])\n",
    "        \n",
    "              \n",
    "        #Criando a janela do Tkinter\n",
    "        root = Tk()\n",
    "        root.configure(bg='white') #Cor do fundo\n",
    "        root.title(\"Sistema Google Sheets\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        estado_label = Label(root, text=\"Estado:\", font=\"Arial 14\", bg='white')\n",
    "        estado_label.grid(row=0, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna A a partir da segunda linha\n",
    "        estados = sorted(list(set(value[0] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        estado_combobox = ttk.Combobox(root, values=estados, font=\"Arial 14\")\n",
    "        estado_combobox.grid(row=1, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        cidade_label = Label(root, text=\"Cidade:\", font=\"Arial 14\", bg='white')\n",
    "        cidade_label.grid(row=0, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna B a partir da segunda linha\n",
    "        cidades = sorted(list(set(value[1] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        cidade_combobox = ttk.Combobox(root, values=cidades, font=\"Arial 14\")\n",
    "        cidade_combobox.grid(row=1, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        vendedor_label = Label(root, text=\"Vendedor:\", font=\"Arial 14\", bg='white')\n",
    "        vendedor_label.grid(row=0, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna C a partir da segunda linha\n",
    "        vendedores = sorted(list(set(value[2] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        vendedor_combobox = ttk.Combobox(root, values=vendedores, font=\"Arial 14\")\n",
    "        vendedor_combobox.grid(row=1, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        produto_label = Label(root, text=\"Produto:\", font=\"Arial 14\", bg='white')\n",
    "        produto_label.grid(row=0, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna D a partir da segunda linha\n",
    "        produtos = sorted(list(set(value[3] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        produtos_combobox = ttk.Combobox(root, values=produtos, font=\"Arial 14\")\n",
    "        produtos_combobox.grid(row=1, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Cria uma treeview para exibir os dados da planilha\n",
    "        tree = ttk.Treeview(root)\n",
    "                \n",
    "        #Define as colunas da Treeview com base nos valores da linha 1 da planilha\n",
    "        colunas = valores[0]\n",
    "        tree[\"columns\"] = colunas\n",
    "        \n",
    "        #for - para\n",
    "        #Define o cabeçalho da Treeview\n",
    "        for linha in colunas:\n",
    "            tree.heading(linha, text=linha)\n",
    "        \n",
    "        #Adiciona os valores da planilha à Treeview\n",
    "        for row in valores[1:]:\n",
    "            tree.insert(\"\", \"end\", values=row)\n",
    "            \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena parte como se fosse uma planilha\n",
    "        tree.grid(row=3, column=0, columnspan=6, padx=5, pady=5, stick=\"NSEW\")\n",
    "        \n",
    "        style = ttk.Style()\n",
    "        style.theme_use(\"clam\") #Definindo o tema para a treeview\n",
    "        style.configure(\"Treeview\", background=\"#FFFFE0\", foreground=\"black\",\n",
    "                       font=(\"Arial 12\"), rowheight=25, fiedlbackground=\"#FFFFE0\",\n",
    "                            bordercolor=\"#808080\", borderwidth=1) #Define as cores, fundo, cor do texto, altura da linha, cor do campo, cor e larrgura da borda\n",
    "        style.map(\"Treeview\", background=[('selected', \"#347083\")], foreground=[('selected', 'white')]) #Define a cor de fundo e texto quando uma linha é selecionada\n",
    "        \n",
    "        #Oculta a primeira coluna deixando a largura como 0\n",
    "        tree.column(\"#0\", width=0, stretch=False)\n",
    "        \n",
    "        \n",
    "        #Função que filtra os dados\n",
    "        def filtro():\n",
    "            \n",
    "            #Lê as informações da planilha\n",
    "            sheet = service.spreadsheets()\n",
    "            result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                      range=SAMPLE_RANGE_NAME).execute()\n",
    "\n",
    "            #Lê os dados da planilha do google sheets\n",
    "            valores = result['values']\n",
    "            \n",
    "            #Opçoes filtro pega o texto das combobox\n",
    "            estado = estado_combobox.get()\n",
    "            cidade = cidade_combobox.get()\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            produto = produtos_combobox.get()\n",
    "            \n",
    "            dados_filtrados = [valores[0]] #Inclui a linha do cabeçalho\n",
    "            for row in valores[1:]:\n",
    "                \n",
    "                if(not estado or row[0] == estado) and \\\n",
    "                    (not cidade or row[1] == cidade) and \\\n",
    "                    (not vendedor or row[2] == vendedor) and \\\n",
    "                    (not produto or row[3] == produto) and \\\n",
    "                    (not estado or row[0] == estado) :\n",
    "                    dados_filtrados.append(row)\n",
    "            \n",
    "            #Limpa os dados\n",
    "            for row in tree.get_children():\n",
    "                tree.delete(row)\n",
    "                \n",
    "            #Atualiza os dados da treeview\n",
    "            for row in dados_filtrados[1:]:\n",
    "                tree.insert(\"\", \"end\", values=row) \n",
    "                \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "                \n",
    "        #Cria botão Filtro\n",
    "        botao_filtrar = Button(root, text=\"Filtrar\", font=\"Arial 14\", command=filtro)\n",
    "        botao_filtrar.grid(row=4, column=1, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        def atualiza_cidades(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            estado = estado_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna B a partir da segunda linha\n",
    "            cidades = sorted(list(set([value[1] for value in valores[1:] if value[0] == estado])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            cidade_combobox['values'] = cidades\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        estado_combobox.bind(\"<<ComboboxSelected>>\", atualiza_cidades)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_vendedores(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            cidade = cidade_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna C a partir da segunda linha\n",
    "            vendedores = sorted(list(set([value[2] for value in valores[1:] if value[1] == cidade])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            vendedor_combobox['values'] = vendedores\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        cidade_combobox.bind(\"<<ComboboxSelected>>\", atualiza_vendedores)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_produtos(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna D a partir da segunda linha\n",
    "            produtos = sorted(list(set([value[3] for value in valores[1:] if value[2] == vendedor])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            produtos_combobox['values'] = produtos\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        vendedor_combobox.bind(\"<<ComboboxSelected>>\", atualiza_produtos)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def chama_filtro_a_cada_mudanca(event):\n",
    "            \n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Filtro as informações quando selecionar algo no campo de produtos\n",
    "        produtos_combobox.bind(\"<<ComboboxSelected>>\", chama_filtro_a_cada_mudanca)\n",
    "            \n",
    "        def novo_registro():\n",
    "            \n",
    "            #Cria uma janela secundária para cadastrar os dados\n",
    "            janela_cadastro = Toplevel(root)\n",
    "            janela_cadastro.title(\"Cadastrar Produto\")\n",
    "            \n",
    "            Label(janela_cadastro, text=\"Estado:\", font=\"Arial 16\").grid(row=0, column=0, padx=2, pady=2) \n",
    "            estado_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            estado_cadastro.grid(row=0, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Cidade:\", font=\"Arial 16\").grid(row=1, column=0, padx=2, pady=2) \n",
    "            cidade_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            cidade_cadastro.grid(row=1, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Vendedor:\", font=\"Arial 16\").grid(row=2, column=0, padx=2, pady=2) \n",
    "            vendedor_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            vendedor_cadastro.grid(row=2, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Produto:\", font=\"Arial 16\").grid(row=3, column=0, padx=2, pady=2) \n",
    "            produto_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            produto_cadastro.grid(row=3, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Preço:\", font=\"Arial 16\").grid(row=4, column=0, padx=2, pady=2) \n",
    "            preco_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            preco_cadastro.grid(row=4, column=1, padx=2, pady=2) \n",
    "            \n",
    "            def salvar_dados_google_sheets():\n",
    "                \n",
    "                #Obtem os valores dos campos de entrada de dados\n",
    "                estado = estado_cadastro.get()\n",
    "                cidade = cidade_cadastro.get()\n",
    "                vendedor = vendedor_cadastro.get()\n",
    "                produto = produto_cadastro.get()\n",
    "                preco = preco_cadastro.get()\n",
    "                \n",
    "                creds = None\n",
    "                if os.path.exists(CREDENTIALS_FILE): #Verifica se o arquivo de credenciais exsite\n",
    "                    creds = Credentials.from_authorized_user_file(CREDENTIALS_FILE, SCOPES) #Carrega as credenciais a partir do arquuivo\n",
    "                    \n",
    "                if not creds or not creds.valid: #Verifica se as credenciais são inválidas ou inexistes\n",
    "                    if creds and creds.expired and creds.reflesh_token: #Verifica se as credenciais expiraram e existe um token de atualização\n",
    "                        creds.refresh(Request()) #Atualiza as credenciais com o token de atualização\n",
    "                    else:\n",
    "                        \n",
    "                        #Se não houver credenciais ou elas forem inválidas abre o fluxo de autenticação do Google Sheets\n",
    "                        flow = InstalledAppFlow.from_client_secrets_file(                        \n",
    "                            'credentials.json', SCOPES)\n",
    "                        creds = flow.run_local_server(port=0) #Executa o fluxo de autenticação\n",
    "                        \n",
    "                    with open(CREDENTIALS_FILE, 'w') as token: #Abre o arquivo de credenciais para escrita\n",
    "                        token.write(creds.to_json()) #Escreve as credenciais no arquivo\n",
    "                        \n",
    "                #Cria uma instancia da API da planilha do Google\n",
    "                service = build('sheets', 'v4', credentials=creds)\n",
    "                \n",
    "                values = [[estado, cidade, vendedor, produto, preco]] #Cria uma lista com os valores obtidos dos campos de entrada\n",
    "                \n",
    "                body = {'values': values} #Cria um dicionário com a lista de valores\n",
    "\n",
    "                # Call the Sheets API\n",
    "                result = service.spreadsheets().values().append(\n",
    "                                spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=SAMPLE_RANGE_NAME,\n",
    "                                valueInputOption='USER_ENTERED', insertDataOption='INSERT_ROWS', body=body).execute()\n",
    "                                #Executa o método append para adicionar uma nova linha à planilha do Google Sheets\n",
    "            \n",
    "                tree.delete(*tree.get_children()) #Remove todas as linhas da Treeview\n",
    "                result = service.spreadsheets().values().get(\n",
    "                            spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=SAMPLE_RANGE_NAME).execute() #Executa o método get() para obter os dados da planilha\n",
    "                \n",
    "                valores = result['values'] #Obtem os valores da planilha em formato de lista\n",
    "                for row in valores[1:]:\n",
    "                    tree.insert(\"\", \"end\", values=row)\n",
    "                    \n",
    "                #Fecha a janela de cadastro\n",
    "                janela_cadastro.destroy()\n",
    "                    \n",
    "                #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "                soma_precos()\n",
    "                \n",
    "            #Cria botão Filtro\n",
    "            botao_salvar_novo_registro = Button(janela_cadastro, text=\"Cadastrar\", font=\"Arial 16\", command=salvar_dados_google_sheets)\n",
    "            botao_salvar_novo_registro.grid(row=6, column=0, columnspan=2, padx=2, pady=2, stick=\"NSEW\")\n",
    "            \n",
    "        #Cria botão Filtro\n",
    "        botao_novo = Button(root, text=\"Novo\", font=\"Arial 14\", command=novo_registro)\n",
    "        botao_novo.grid(row=4, column=0, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        #------------------------------------------------------------------------------\n",
    "        \n",
    "        def janela_editar(event):\n",
    "            \n",
    "            #Obtem o item selecionado da treeview\n",
    "            item_selecionado = tree.selection()[0]\n",
    "            \n",
    "            #Obtem os valores do item selecionado\n",
    "            valores_selecionados = tree.item(item_selecionado)['values']\n",
    "            \n",
    "            #Cria uma janela secundária para cadastrar os dados\n",
    "            janela_edicao = Toplevel(root)\n",
    "            janela_edicao.title(\"Editar Produto\")\n",
    "            \n",
    "            Label(janela_edicao, text=\"Estado:\", font=\"Arial 16\").grid(row=0, column=0, padx=2, pady=2) \n",
    "            estado_edicao = Entry(janela_edicao, font=\"Arial 16\", textvariable=StringVar(value=valores_selecionados[0])) #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            estado_edicao.grid(row=0, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_edicao, text=\"Cidade:\", font=\"Arial 16\").grid(row=1, column=0, padx=2, pady=2) \n",
    "            cidade_edicao = Entry(janela_edicao, font=\"Arial 16\", textvariable=StringVar(value=valores_selecionados[1])) #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            cidade_edicao.grid(row=1, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_edicao, text=\"Vendedor:\", font=\"Arial 16\").grid(row=2, column=0, padx=2, pady=2) \n",
    "            vendedor_edicao = Entry(janela_edicao, font=\"Arial 16\", textvariable=StringVar(value=valores_selecionados[2])) #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            vendedor_edicao.grid(row=2, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_edicao, text=\"Produto:\", font=\"Arial 16\").grid(row=3, column=0, padx=2, pady=2) \n",
    "            produto_edicao = Entry(janela_edicao, font=\"Arial 16\", textvariable=StringVar(value=valores_selecionados[3])) #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            produto_edicao.grid(row=3, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_edicao, text=\"Preço:\", font=\"Arial 16\").grid(row=4, column=0, padx=2, pady=2) \n",
    "            preco_edicao = Entry(janela_edicao, font=\"Arial 16\", textvariable=StringVar(value=valores_selecionados[4])) #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            preco_edicao.grid(row=4, column=1, padx=2, pady=2) \n",
    "            \n",
    "            def alterar_dados_google_sheets():\n",
    "                \n",
    "                #Obtem os valores dos campos de entrada de dados\n",
    "                estado = estado_edicao.get()\n",
    "                cidade = cidade_edicao.get()\n",
    "                vendedor = vendedor_edicao.get()\n",
    "                produto = produto_edicao.get()\n",
    "                preco = preco_edicao.get()\n",
    "                \n",
    "                #Lê as credenciais do usuário ou pede autorização para acessar a planilha do Google Sheets\n",
    "                creds = None\n",
    "                if os.path.exists('token.json'): #Verifica se o arquivo de credenciais exsite\n",
    "                    creds = Credentials.from_authorized_user_file('token.json', SCOPES) #Carrega as credenciais a partir do arquuivo\n",
    "                    \n",
    "                if not creds or not creds.valid: #Verifica se as credenciais são inválidas ou inexistes\n",
    "                    if creds and creds.expired and creds.reflesh_token: #Verifica se as credenciais expiraram e existe um token de atualização\n",
    "                        creds.refresh(Request()) #Atualiza as credenciais com o token de atualização\n",
    "                    else:\n",
    "                        \n",
    "                        #Se não houver credenciais ou elas forem inválidas abre o fluxo de autenticação do Google Sheets\n",
    "                        flow = InstalledAppFlow.from_client_secrets_file(                        \n",
    "                            'credentials.json', SCOPES)\n",
    "                        creds = flow.run_local_server(port=0) #Executa o fluxo de autenticação\n",
    "                        \n",
    "                    with open('token.json', 'w') as token: #Abre o arquivo de credenciais para escrita\n",
    "                        token.write(creds.to_json()) #Escreve as credenciais no arquivo\n",
    "                        \n",
    "                #Cria uma instancia da API da planilha do Google\n",
    "                service = build('sheets', 'v4', credentials=creds)\n",
    "                \n",
    "                #Quando colo o RAW significa que os dados serão salvos como eles estão\n",
    "                value_input_option = 'RAW'\n",
    "                \n",
    "                values = [\n",
    "                    [\n",
    "                        estado,\n",
    "                        cidade,\n",
    "                        vendedor,\n",
    "                        produto,\n",
    "                        preco\n",
    "                    ]\n",
    "                ]\n",
    "                \n",
    "                #Converte o indice da linha em uma string / texto\n",
    "                linha = str(tree.index(item_selecionado) + 2)\n",
    "                \n",
    "                #Usa a string format para criar a range que vamos alterar os dados\n",
    "                range_ = f'Dados!A{linha}:E{linha}'\n",
    "                \n",
    "                body = {\n",
    "                    \n",
    "                    'values' : values\n",
    "                    \n",
    "                }\n",
    "\n",
    "                # Call the Sheets API\n",
    "                result = sheet.values().update(\n",
    "                                spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=range_,\n",
    "                                valueInputOption=value_input_option, body=body).execute()\n",
    "                                #Executa o método append para adicionar uma nova linha à planilha do Google Sheets\n",
    "            \n",
    "                #Atualiza a exibição da Treeview com os novos valores\n",
    "                tree.item(item_selecionado, values=values[0])\n",
    "                \n",
    "                \n",
    "                #Fecha a janela de edição\n",
    "                janela_edicao.destroy()\n",
    "                \n",
    "                #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "                soma_precos()\n",
    "            \n",
    "                \n",
    "            #Cria botão Filtro\n",
    "            botao_alterar_dados = Button(janela_edicao, text=\"Salvar Alterações\", font=\"Arial 16\", command=alterar_dados_google_sheets)\n",
    "            botao_alterar_dados.grid(row=6, column=0, columnspan=2, padx=2, pady=2, stick=\"NSEW\")\n",
    "          \n",
    "        #Evendo de duplo clique na Treeview\n",
    "        tree.bind(\"<Double-1>\", janela_editar)\n",
    "           \n",
    "        def excluir_item():\n",
    "            \n",
    "            #Obtem o indice da linha selecionada na Treeview\n",
    "            item_selecionado = tree.focus()\n",
    "            index = tree.index(item_selecionado)\n",
    "            \n",
    "            #Obtem o ID da planilha e o intervalo da linha que deseja excluir\n",
    "            spreadsheet_id = SAMPLE_SPREADSHEET_ID\n",
    "            #range_ = f'Dados!A{index+2}:E{index+2}'\n",
    "            \n",
    "            #Cria uma solicitação para remover a linha\n",
    "            request = {\n",
    "                \"deleteRange\":{\n",
    "                    \"range\": {\n",
    "                        \"sheetId\": 0, #O id da planilha\n",
    "                        \"startRowIndex\": index + 1,\n",
    "                        \"endRowIndex\": index + 2,\n",
    "                        \"startColumnIndex\": 0,\n",
    "                        \"endColumnIndex\" : 5\n",
    "                    },\n",
    "                    \"shiftDimension\": \"ROWS\" #Indica que as célula abaixo devem ser movidas para cima\n",
    "                    \n",
    "                }\n",
    "            }\n",
    "            \n",
    "            #Executa a solicitação para remover a linha\n",
    "            service = build('sheets', 'v4', credentials=creds)\n",
    "            response = service.spreadsheets().batchUpdate(spreadsheetId = spreadsheet_id, body={\n",
    "                \"requests\":[request]\n",
    "            }).execute()\n",
    "            \n",
    "            #Remove o item selecionado da treview\n",
    "            tree.delete(item_selecionado)\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "                \n",
    "        \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena partes como se fosse uma planilha\n",
    "        #Cria botão Deletar\n",
    "        botao_deletar = Button(root, text=\"Deletar\", font=\"Arial 14\", command=excluir_item)\n",
    "        botao_deletar.grid(row=4, column=2, padx=2, pady=2, stick=\"NSEW\") \n",
    "\n",
    "        \n",
    "        #Cria o Label que exibe o total da coluna de preço e quantidade de itens na tela\n",
    "        total_label = Label(root, text=\"Total: R$ 0\", font=\"Arial 16\")\n",
    "        total_label.grid(row=5, column=0, columnspan=5, padx=2, pady=2, stick=\"W\") \n",
    "        \n",
    "        #Função que soma os preços dos produtos e conta a quantidade de linhas da treeview\n",
    "        def soma_precos():\n",
    "            \n",
    "            #Obtém os indices de todas as linhas\n",
    "            dados = tree.get_children()\n",
    "            \n",
    "            total = 0.0\n",
    "            qtd_linhas = 0.0\n",
    "            \n",
    "            for linha in dados:\n",
    "                \n",
    "                valores_linha = tree.item(linha)['values']\n",
    "                precos = []\n",
    "                \n",
    "                for v in valores_linha[4:]:\n",
    "                    if isinstance(v, str):\n",
    "                        preco = float(v.replace(',', '.'))\n",
    "                        precos.append(preco)\n",
    "                    else:\n",
    "                        precos.append(v)\n",
    "                        \n",
    "                total += sum(precos)\n",
    "                qtd_linhas += 1\n",
    "                \n",
    "            total_label.configure(text=\"Total: {:,.2f} - Linhas: {:,.0f}\". format(total, qtd_linhas))\n",
    "        \n",
    "        #Chama a função para exibir o total de preços e quantidade de linha da Treeview\n",
    "        soma_precos()\n",
    "        \n",
    "        import openpyxl\n",
    "        \n",
    "        def exportar_para_excel():\n",
    "            \n",
    "            #Cria um arquivo de Excel\n",
    "            pasta_trabalho = openpyxl.Workbook()\n",
    "            planilha = pasta_trabalho.active\n",
    "            \n",
    "            #Escreve os cabeçalhos das colunas\n",
    "            colunas = [tree.heading(col)[\"text\"] for col in tree[\"columns\"]]\n",
    "            planilha.append(colunas)\n",
    "            \n",
    "            #Escreve os dados das linhas na planilha\n",
    "            for linha in tree.get_children():\n",
    "                \n",
    "                valores = [tree.item(linha)[\"values\"][i] for i in range(len(colunas))]\n",
    "                planilha.append(valores)\n",
    "              \n",
    "            #Salva o arquivo de excel\n",
    "            pasta_trabalho.save(\"dados.xlsx\")\n",
    "        \n",
    "        \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena partes como se fosse uma planilha\n",
    "        #Cria botão Deletar\n",
    "        botao_exportar = Button(root, text=\"Exportar\", font=\"Arial 14\", command=exportar_para_excel)\n",
    "        botao_exportar.grid(row=4, column=3, padx=2, pady=2, stick=\"NSEW\")\n",
    "        \n",
    "        #Exibo a tela\n",
    "        root.mainloop()\n",
    "\n",
    "        \n",
    "    except HttpError as err:\n",
    "        print(err)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9997f327",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "412b865c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "from tkinter import ttk\n",
    "import os.path\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "import os.path\n",
    "\n",
    "from google.auth.transport.requests import Request\n",
    "from google.oauth2.credentials import Credentials\n",
    "from google_auth_oauthlib.flow import InstalledAppFlow\n",
    "from googleapiclient.discovery import build\n",
    "from googleapiclient.errors import HttpError\n",
    "\n",
    "# If modifying these scopes, delete the file token.json.\n",
    "SCOPES = ['https://www.googleapis.com/auth/spreadsheets']\n",
    "\n",
    "# The ID and range of a sample spreadsheet.\n",
    "SAMPLE_SPREADSHEET_ID = '1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM'\n",
    "SAMPLE_RANGE_NAME = 'Dados!A1:E'\n",
    "\n",
    "CREDENTIALS_FILE = 'token.json'\n",
    "\n",
    "#https://docs.google.com/spreadsheets/d/1UJdjzs3GUhbjmi54NUcVDkJ1zig6gqj2h42oOmc7NyM/edit?usp=sharing\n",
    "\n",
    "def main():\n",
    "    \"\"\"Shows basic usage of the Sheets API.\n",
    "    Prints values from a sample spreadsheet.\n",
    "    \"\"\"\n",
    "    creds = None\n",
    "    # The file token.json stores the user's access and refresh tokens, and is\n",
    "    # created automatically when the authorization flow completes for the first\n",
    "    # time.\n",
    "    if os.path.exists('token.json'):\n",
    "        creds = Credentials.from_authorized_user_file('token.json', SCOPES)\n",
    "    # If there are no (valid) credentials available, let the user log in.\n",
    "    if not creds or not creds.valid:\n",
    "        if creds and creds.expired and creds.refresh_token:\n",
    "            creds.refresh(Request())\n",
    "        else:\n",
    "            flow = InstalledAppFlow.from_client_secrets_file(\n",
    "                'credentials.json', SCOPES)\n",
    "            creds = flow.run_local_server(port=0)\n",
    "        # Save the credentials for the next run\n",
    "        with open('token.json', 'w') as token:\n",
    "            token.write(creds.to_json())\n",
    "\n",
    "    try:\n",
    "        service = build('sheets', 'v4', credentials=creds)\n",
    "\n",
    "        # Call the Sheets API\n",
    "        sheet = service.spreadsheets()\n",
    "        result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                  range=SAMPLE_RANGE_NAME).execute()\n",
    "        \n",
    "        #Lê os dados da planilha do google sheets\n",
    "        valores = result.get('values', [])\n",
    "        \n",
    "              \n",
    "        #Criando a janela do Tkinter\n",
    "        root = Tk()\n",
    "        root.configure(bg='white') #Cor do fundo\n",
    "        root.title(\"Sistema Google Sheets\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        estado_label = Label(root, text=\"Estado:\", font=\"Arial 14\", bg='white')\n",
    "        estado_label.grid(row=0, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna A a partir da segunda linha\n",
    "        estados = sorted(list(set(value[0] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        estado_combobox = ttk.Combobox(root, values=estados, font=\"Arial 14\")\n",
    "        estado_combobox.grid(row=1, column=0, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        cidade_label = Label(root, text=\"Cidade:\", font=\"Arial 14\", bg='white')\n",
    "        cidade_label.grid(row=0, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna B a partir da segunda linha\n",
    "        cidades = sorted(list(set(value[1] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        cidade_combobox = ttk.Combobox(root, values=cidades, font=\"Arial 14\")\n",
    "        cidade_combobox.grid(row=1, column=1, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        vendedor_label = Label(root, text=\"Vendedor:\", font=\"Arial 14\", bg='white')\n",
    "        vendedor_label.grid(row=0, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna C a partir da segunda linha\n",
    "        vendedores = sorted(list(set(value[2] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        vendedor_combobox = ttk.Combobox(root, values=vendedores, font=\"Arial 14\")\n",
    "        vendedor_combobox.grid(row=1, column=2, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #----------------------------------\n",
    "        #Cria o rótulo para exibir na tela\n",
    "        produto_label = Label(root, text=\"Produto:\", font=\"Arial 14\", bg='white')\n",
    "        produto_label.grid(row=0, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Pega as informações da coluna D a partir da segunda linha\n",
    "        produtos = sorted(list(set(value[3] for value in valores[1:] )))\n",
    "        \n",
    "        #Cria a combobox\n",
    "        produtos_combobox = ttk.Combobox(root, values=produtos, font=\"Arial 14\")\n",
    "        produtos_combobox.grid(row=1, column=3, padx=2, pady=2, stick=\"W\")\n",
    "        \n",
    "        #Cria uma treeview para exibir os dados da planilha\n",
    "        tree = ttk.Treeview(root)\n",
    "                \n",
    "        #Define as colunas da Treeview com base nos valores da linha 1 da planilha\n",
    "        colunas = valores[0]\n",
    "        tree[\"columns\"] = colunas\n",
    "        \n",
    "        #for - para\n",
    "        #Define o cabeçalho da Treeview\n",
    "        for linha in colunas:\n",
    "            tree.heading(linha, text=linha)\n",
    "        \n",
    "        #Adiciona os valores da planilha à Treeview\n",
    "        for row in valores[1:]:\n",
    "            tree.insert(\"\", \"end\", values=row)\n",
    "            \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena parte como se fosse uma planilha\n",
    "        tree.grid(row=3, column=0, columnspan=6, padx=5, pady=5, stick=\"NSEW\")\n",
    "        \n",
    "        style = ttk.Style()\n",
    "        style.theme_use(\"clam\") #Definindo o tema para a treeview\n",
    "        style.configure(\"Treeview\", background=\"#FFFFE0\", foreground=\"black\",\n",
    "                       font=(\"Arial 12\"), rowheight=25, fiedlbackground=\"#FFFFE0\",\n",
    "                            bordercolor=\"#808080\", borderwidth=1) #Define as cores, fundo, cor do texto, altura da linha, cor do campo, cor e larrgura da borda\n",
    "        style.map(\"Treeview\", background=[('selected', \"#347083\")], foreground=[('selected', 'white')]) #Define a cor de fundo e texto quando uma linha é selecionada\n",
    "        \n",
    "        #Oculta a primeira coluna deixando a largura como 0\n",
    "        tree.column(\"#0\", width=0, stretch=False)\n",
    "        \n",
    "        \n",
    "        #Função que filtra os dados\n",
    "        def filtro():\n",
    "            \n",
    "            #Lê as informações da planilha\n",
    "            sheet = service.spreadsheets()\n",
    "            result = sheet.values().get(spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                      range=SAMPLE_RANGE_NAME).execute()\n",
    "\n",
    "            #Lê os dados da planilha do google sheets\n",
    "            valores = result['values']\n",
    "            \n",
    "            #Opçoes filtro pega o texto das combobox\n",
    "            estado = estado_combobox.get()\n",
    "            cidade = cidade_combobox.get()\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            produto = produtos_combobox.get()\n",
    "            \n",
    "            dados_filtrados = [valores[0]] #Inclui a linha do cabeçalho\n",
    "            for row in valores[1:]:\n",
    "                \n",
    "                if(not estado or row[0] == estado) and \\\n",
    "                    (not cidade or row[1] == cidade) and \\\n",
    "                    (not vendedor or row[2] == vendedor) and \\\n",
    "                    (not produto or row[3] == produto) and \\\n",
    "                    (not estado or row[0] == estado) :\n",
    "                    dados_filtrados.append(row)\n",
    "            \n",
    "            #Limpa os dados\n",
    "            for row in tree.get_children():\n",
    "                tree.delete(row)\n",
    "                \n",
    "            #Atualiza os dados da treeview\n",
    "            for row in dados_filtrados[1:]:\n",
    "                tree.insert(\"\", \"end\", values=row) \n",
    "                \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "                \n",
    "        #Cria botão Filtro\n",
    "        botao_filtrar = Button(root, text=\"Filtrar\", font=\"Arial 14\", command=filtro)\n",
    "        botao_filtrar.grid(row=4, column=1, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        def atualiza_cidades(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            estado = estado_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna B a partir da segunda linha\n",
    "            cidades = sorted(list(set([value[1] for value in valores[1:] if value[0] == estado])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            cidade_combobox['values'] = cidades\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        estado_combobox.bind(\"<<ComboboxSelected>>\", atualiza_cidades)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_vendedores(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            cidade = cidade_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna C a partir da segunda linha\n",
    "            vendedores = sorted(list(set([value[2] for value in valores[1:] if value[1] == cidade])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            vendedor_combobox['values'] = vendedores\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        cidade_combobox.bind(\"<<ComboboxSelected>>\", atualiza_vendedores)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def atualiza_produtos(event):\n",
    "        \n",
    "            #Obtem o estado selecionado\n",
    "            vendedor = vendedor_combobox.get()\n",
    "            \n",
    "            #Pega as informações da coluna D a partir da segunda linha\n",
    "            produtos = sorted(list(set([value[3] for value in valores[1:] if value[2] == vendedor])))\n",
    "            \n",
    "            #Popula a combobox com os valores correspondentes\n",
    "            produtos_combobox['values'] = produtos\n",
    "            \n",
    "            #Chamo a função para filtrar os dados\n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Adiciona o evento a bombobox\n",
    "        vendedor_combobox.bind(\"<<ComboboxSelected>>\", atualiza_produtos)  \n",
    "        \n",
    "        #-----------------------------------------------\n",
    "        \n",
    "        def chama_filtro_a_cada_mudanca(event):\n",
    "            \n",
    "            filtro()\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "        \n",
    "        #Filtro as informações quando selecionar algo no campo de produtos\n",
    "        produtos_combobox.bind(\"<<ComboboxSelected>>\", chama_filtro_a_cada_mudanca)\n",
    "            \n",
    "        def novo_registro():\n",
    "            \n",
    "            #Cria uma janela secundária para cadastrar os dados\n",
    "            janela_cadastro = Toplevel(root)\n",
    "            janela_cadastro.title(\"Cadastrar Produto\")\n",
    "            \n",
    "            Label(janela_cadastro, text=\"Estado:\", font=\"Arial 16\").grid(row=0, column=0, padx=2, pady=2) \n",
    "            estado_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            estado_cadastro.grid(row=0, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Cidade:\", font=\"Arial 16\").grid(row=1, column=0, padx=2, pady=2) \n",
    "            cidade_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            cidade_cadastro.grid(row=1, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Vendedor:\", font=\"Arial 16\").grid(row=2, column=0, padx=2, pady=2) \n",
    "            vendedor_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            vendedor_cadastro.grid(row=2, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Produto:\", font=\"Arial 16\").grid(row=3, column=0, padx=2, pady=2) \n",
    "            produto_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            produto_cadastro.grid(row=3, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_cadastro, text=\"Preço:\", font=\"Arial 16\").grid(row=4, column=0, padx=2, pady=2) \n",
    "            preco_cadastro = Entry(janela_cadastro, font=\"Arial 16\") #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            preco_cadastro.grid(row=4, column=1, padx=2, pady=2) \n",
    "            \n",
    "            def salvar_dados_google_sheets():\n",
    "                \n",
    "                #Obtem os valores dos campos de entrada de dados\n",
    "                estado = estado_cadastro.get()\n",
    "                cidade = cidade_cadastro.get()\n",
    "                vendedor = vendedor_cadastro.get()\n",
    "                produto = produto_cadastro.get()\n",
    "                preco = preco_cadastro.get()\n",
    "                \n",
    "                creds = None\n",
    "                if os.path.exists(CREDENTIALS_FILE): #Verifica se o arquivo de credenciais exsite\n",
    "                    creds = Credentials.from_authorized_user_file(CREDENTIALS_FILE, SCOPES) #Carrega as credenciais a partir do arquuivo\n",
    "                    \n",
    "                if not creds or not creds.valid: #Verifica se as credenciais são inválidas ou inexistes\n",
    "                    if creds and creds.expired and creds.reflesh_token: #Verifica se as credenciais expiraram e existe um token de atualização\n",
    "                        creds.refresh(Request()) #Atualiza as credenciais com o token de atualização\n",
    "                    else:\n",
    "                        \n",
    "                        #Se não houver credenciais ou elas forem inválidas abre o fluxo de autenticação do Google Sheets\n",
    "                        flow = InstalledAppFlow.from_client_secrets_file(                        \n",
    "                            'credentials.json', SCOPES)\n",
    "                        creds = flow.run_local_server(port=0) #Executa o fluxo de autenticação\n",
    "                        \n",
    "                    with open(CREDENTIALS_FILE, 'w') as token: #Abre o arquivo de credenciais para escrita\n",
    "                        token.write(creds.to_json()) #Escreve as credenciais no arquivo\n",
    "                        \n",
    "                #Cria uma instancia da API da planilha do Google\n",
    "                service = build('sheets', 'v4', credentials=creds)\n",
    "                \n",
    "                values = [[estado, cidade, vendedor, produto, preco]] #Cria uma lista com os valores obtidos dos campos de entrada\n",
    "                \n",
    "                body = {'values': values} #Cria um dicionário com a lista de valores\n",
    "\n",
    "                # Call the Sheets API\n",
    "                result = service.spreadsheets().values().append(\n",
    "                                spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=SAMPLE_RANGE_NAME,\n",
    "                                valueInputOption='USER_ENTERED', insertDataOption='INSERT_ROWS', body=body).execute()\n",
    "                                #Executa o método append para adicionar uma nova linha à planilha do Google Sheets\n",
    "            \n",
    "                tree.delete(*tree.get_children()) #Remove todas as linhas da Treeview\n",
    "                result = service.spreadsheets().values().get(\n",
    "                            spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=SAMPLE_RANGE_NAME).execute() #Executa o método get() para obter os dados da planilha\n",
    "                \n",
    "                valores = result['values'] #Obtem os valores da planilha em formato de lista\n",
    "                for row in valores[1:]:\n",
    "                    tree.insert(\"\", \"end\", values=row)\n",
    "                    \n",
    "                #Fecha a janela de cadastro\n",
    "                janela_cadastro.destroy()\n",
    "                    \n",
    "                #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "                soma_precos()\n",
    "                \n",
    "            #Cria botão Filtro\n",
    "            botao_salvar_novo_registro = Button(janela_cadastro, text=\"Cadastrar\", font=\"Arial 16\", command=salvar_dados_google_sheets)\n",
    "            botao_salvar_novo_registro.grid(row=6, column=0, columnspan=2, padx=2, pady=2, stick=\"NSEW\")\n",
    "            \n",
    "        #Cria botão Filtro\n",
    "        botao_novo = Button(root, text=\"Novo\", font=\"Arial 14\", command=novo_registro)\n",
    "        botao_novo.grid(row=4, column=0, padx=2, pady=2, stick=\"NSEW\") \n",
    "        \n",
    "        #------------------------------------------------------------------------------\n",
    "        \n",
    "        def janela_editar(event):\n",
    "            \n",
    "            #Obtem o item selecionado da treeview\n",
    "            item_selecionado = tree.selection()[0]\n",
    "            \n",
    "            #Obtem os valores do item selecionado\n",
    "            valores_selecionados = tree.item(item_selecionado)['values']\n",
    "            \n",
    "            #Cria uma janela secundária para cadastrar os dados\n",
    "            janela_edicao = Toplevel(root)\n",
    "            janela_edicao.title(\"Editar Produto\")\n",
    "            \n",
    "            Label(janela_edicao, text=\"Estado:\", font=\"Arial 16\").grid(row=0, column=0, padx=2, pady=2) \n",
    "            estado_edicao = Entry(janela_edicao, font=\"Arial 16\", textvariable=StringVar(value=valores_selecionados[0])) #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            estado_edicao.grid(row=0, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_edicao, text=\"Cidade:\", font=\"Arial 16\").grid(row=1, column=0, padx=2, pady=2) \n",
    "            cidade_edicao = Entry(janela_edicao, font=\"Arial 16\", textvariable=StringVar(value=valores_selecionados[1])) #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            cidade_edicao.grid(row=1, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_edicao, text=\"Vendedor:\", font=\"Arial 16\").grid(row=2, column=0, padx=2, pady=2) \n",
    "            vendedor_edicao = Entry(janela_edicao, font=\"Arial 16\", textvariable=StringVar(value=valores_selecionados[2])) #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            vendedor_edicao.grid(row=2, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_edicao, text=\"Produto:\", font=\"Arial 16\").grid(row=3, column=0, padx=2, pady=2) \n",
    "            produto_edicao = Entry(janela_edicao, font=\"Arial 16\", textvariable=StringVar(value=valores_selecionados[3])) #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            produto_edicao.grid(row=3, column=1, padx=2, pady=2) \n",
    "            \n",
    "            Label(janela_edicao, text=\"Preço:\", font=\"Arial 16\").grid(row=4, column=0, padx=2, pady=2) \n",
    "            preco_edicao = Entry(janela_edicao, font=\"Arial 16\", textvariable=StringVar(value=valores_selecionados[4])) #Campo de entrada de dados que pega o que o usuário digitar\n",
    "            preco_edicao.grid(row=4, column=1, padx=2, pady=2) \n",
    "            \n",
    "            def alterar_dados_google_sheets():\n",
    "                \n",
    "                #Obtem os valores dos campos de entrada de dados\n",
    "                estado = estado_edicao.get()\n",
    "                cidade = cidade_edicao.get()\n",
    "                vendedor = vendedor_edicao.get()\n",
    "                produto = produto_edicao.get()\n",
    "                preco = preco_edicao.get()\n",
    "                \n",
    "                #Lê as credenciais do usuário ou pede autorização para acessar a planilha do Google Sheets\n",
    "                creds = None\n",
    "                if os.path.exists('token.json'): #Verifica se o arquivo de credenciais exsite\n",
    "                    creds = Credentials.from_authorized_user_file('token.json', SCOPES) #Carrega as credenciais a partir do arquuivo\n",
    "                    \n",
    "                if not creds or not creds.valid: #Verifica se as credenciais são inválidas ou inexistes\n",
    "                    if creds and creds.expired and creds.reflesh_token: #Verifica se as credenciais expiraram e existe um token de atualização\n",
    "                        creds.refresh(Request()) #Atualiza as credenciais com o token de atualização\n",
    "                    else:\n",
    "                        \n",
    "                        #Se não houver credenciais ou elas forem inválidas abre o fluxo de autenticação do Google Sheets\n",
    "                        flow = InstalledAppFlow.from_client_secrets_file(                        \n",
    "                            'credentials.json', SCOPES)\n",
    "                        creds = flow.run_local_server(port=0) #Executa o fluxo de autenticação\n",
    "                        \n",
    "                    with open('token.json', 'w') as token: #Abre o arquivo de credenciais para escrita\n",
    "                        token.write(creds.to_json()) #Escreve as credenciais no arquivo\n",
    "                        \n",
    "                #Cria uma instancia da API da planilha do Google\n",
    "                service = build('sheets', 'v4', credentials=creds)\n",
    "                \n",
    "                #Quando colo o RAW significa que os dados serão salvos como eles estão\n",
    "                value_input_option = 'RAW'\n",
    "                \n",
    "                values = [\n",
    "                    [\n",
    "                        estado,\n",
    "                        cidade,\n",
    "                        vendedor,\n",
    "                        produto,\n",
    "                        preco\n",
    "                    ]\n",
    "                ]\n",
    "                \n",
    "                #Converte o indice da linha em uma string / texto\n",
    "                linha = str(tree.index(item_selecionado) + 2)\n",
    "                \n",
    "                #Usa a string format para criar a range que vamos alterar os dados\n",
    "                range_ = f'Dados!A{linha}:E{linha}'\n",
    "                \n",
    "                body = {\n",
    "                    \n",
    "                    'values' : values\n",
    "                    \n",
    "                }\n",
    "\n",
    "                # Call the Sheets API\n",
    "                result = sheet.values().update(\n",
    "                                spreadsheetId=SAMPLE_SPREADSHEET_ID,\n",
    "                                range=range_,\n",
    "                                valueInputOption=value_input_option, body=body).execute()\n",
    "                                #Executa o método append para adicionar uma nova linha à planilha do Google Sheets\n",
    "            \n",
    "                #Atualiza a exibição da Treeview com os novos valores\n",
    "                tree.item(item_selecionado, values=values[0])\n",
    "                \n",
    "                \n",
    "                #Fecha a janela de edição\n",
    "                janela_edicao.destroy()\n",
    "                \n",
    "                #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "                soma_precos()\n",
    "            \n",
    "                \n",
    "            #Cria botão Filtro\n",
    "            botao_alterar_dados = Button(janela_edicao, text=\"Salvar Alterações\", font=\"Arial 16\", command=alterar_dados_google_sheets)\n",
    "            botao_alterar_dados.grid(row=6, column=0, columnspan=2, padx=2, pady=2, stick=\"NSEW\")\n",
    "          \n",
    "        #Evendo de duplo clique na Treeview\n",
    "        tree.bind(\"<Double-1>\", janela_editar)\n",
    "           \n",
    "        def excluir_item():\n",
    "            \n",
    "            #Obtem o indice da linha selecionada na Treeview\n",
    "            item_selecionado = tree.focus()\n",
    "            index = tree.index(item_selecionado)\n",
    "            \n",
    "            #Obtem o ID da planilha e o intervalo da linha que deseja excluir\n",
    "            spreadsheet_id = SAMPLE_SPREADSHEET_ID\n",
    "            #range_ = f'Dados!A{index+2}:E{index+2}'\n",
    "            \n",
    "            #Cria uma solicitação para remover a linha\n",
    "            request = {\n",
    "                \"deleteRange\":{\n",
    "                    \"range\": {\n",
    "                        \"sheetId\": 0, #O id da planilha\n",
    "                        \"startRowIndex\": index + 1,\n",
    "                        \"endRowIndex\": index + 2,\n",
    "                        \"startColumnIndex\": 0,\n",
    "                        \"endColumnIndex\" : 5\n",
    "                    },\n",
    "                    \"shiftDimension\": \"ROWS\" #Indica que as célula abaixo devem ser movidas para cima\n",
    "                    \n",
    "                }\n",
    "            }\n",
    "            \n",
    "            #Executa a solicitação para remover a linha\n",
    "            service = build('sheets', 'v4', credentials=creds)\n",
    "            response = service.spreadsheets().batchUpdate(spreadsheetId = spreadsheet_id, body={\n",
    "                \"requests\":[request]\n",
    "            }).execute()\n",
    "            \n",
    "            #Remove o item selecionado da treview\n",
    "            tree.delete(item_selecionado)\n",
    "            \n",
    "            #Chama a função que lê os dados da treeview e soma os preço e qtd de linhas\n",
    "            soma_precos()\n",
    "                \n",
    "        \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena partes como se fosse uma planilha\n",
    "        #Cria botão Deletar\n",
    "        botao_deletar = Button(root, text=\"Deletar\", font=\"Arial 14\", command=excluir_item)\n",
    "        botao_deletar.grid(row=4, column=2, padx=2, pady=2, stick=\"NSEW\") \n",
    "\n",
    "        \n",
    "        #Cria o Label que exibe o total da coluna de preço e quantidade de itens na tela\n",
    "        total_label = Label(root, text=\"Total: R$ 0\", font=\"Arial 16\")\n",
    "        total_label.grid(row=5, column=0, columnspan=5, padx=2, pady=2, stick=\"W\") \n",
    "        \n",
    "        #Função que soma os preços dos produtos e conta a quantidade de linhas da treeview\n",
    "        def soma_precos():\n",
    "            \n",
    "            #Obtém os indices de todas as linhas\n",
    "            dados = tree.get_children()\n",
    "            \n",
    "            total = 0.0\n",
    "            qtd_linhas = 0.0\n",
    "            \n",
    "            for linha in dados:\n",
    "                \n",
    "                valores_linha = tree.item(linha)['values']\n",
    "                precos = []\n",
    "                \n",
    "                for v in valores_linha[4:]:\n",
    "                    if isinstance(v, str):\n",
    "                        preco = float(v.replace(',', '.'))\n",
    "                        precos.append(preco)\n",
    "                    else:\n",
    "                        precos.append(v)\n",
    "                        \n",
    "                total += sum(precos)\n",
    "                qtd_linhas += 1\n",
    "                \n",
    "            total_label.configure(text=\"Total: {:,.2f} - Linhas: {:,.0f}\". format(total, qtd_linhas))\n",
    "        \n",
    "        #Chama a função para exibir o total de preços e quantidade de linha da Treeview\n",
    "        soma_precos()\n",
    "        \n",
    "        import openpyxl\n",
    "        \n",
    "        def exportar_para_excel():\n",
    "            \n",
    "            #Cria um arquivo de Excel\n",
    "            pasta_trabalho = openpyxl.Workbook()\n",
    "            planilha = pasta_trabalho.active\n",
    "            \n",
    "            #Escreve os cabeçalhos das colunas\n",
    "            colunas = [tree.heading(col)[\"text\"] for col in tree[\"columns\"]]\n",
    "            planilha.append(colunas)\n",
    "            \n",
    "            #Escreve os dados das linhas na planilha\n",
    "            for linha in tree.get_children():\n",
    "                \n",
    "                valores = [tree.item(linha)[\"values\"][i] for i in range(len(colunas))]\n",
    "                planilha.append(valores)\n",
    "              \n",
    "            #Salva o arquivo de excel\n",
    "            pasta_trabalho.save(\"dados.xlsx\")\n",
    "        \n",
    "        \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena partes como se fosse uma planilha\n",
    "        #Cria botão Deletar\n",
    "        botao_exportar = Button(root, text=\"Exportar\", font=\"Arial 14\", command=exportar_para_excel)\n",
    "        botao_exportar.grid(row=4, column=3, padx=2, pady=2, stick=\"NSEW\")\n",
    "        \n",
    "        def exportar_e_separar():\n",
    "            \n",
    "            #Cria um dicionário para armazenas as planilhas\n",
    "            planilhas = {}\n",
    "            \n",
    "            #for - para\n",
    "            #Percorre as linhas da Treeview e adiciona cada linha a planilha correspondente\n",
    "            for linha in tree.get_children():\n",
    "                \n",
    "                #Obtem o valor da coluna A para usar como nome  da planilha\n",
    "                valor_coluna_a = tree.item(linha)[\"values\"][0]\n",
    "                \n",
    "                #Verifica se a planilha já existe no dicionário, senão criar\n",
    "                if valor_coluna_a not in planilhas:\n",
    "                    \n",
    "                    planilhas[valor_coluna_a] = []\n",
    "                    \n",
    "                #Adiciona a linha à planilha correspondente\n",
    "                planilhas[valor_coluna_a].append([str(valor) for valor in tree.item(linha)[\"values\"]])\n",
    "                \n",
    "            #Salva cada planilha do dicionario em um arquivo de Excel Separado\n",
    "            for nome_planilha, linhas in planilhas.items():\n",
    "              \n",
    "                #Cria um arquivo de Excel\n",
    "                pasta_trabalho = openpyxl.Workbook()\n",
    "                planilha = pasta_trabalho.active\n",
    "                planilha.title = nome_planilha\n",
    "\n",
    "                #Escreve os cabeçalhos das colunas\n",
    "                colunas = [tree.heading(col)[\"text\"] for col in tree[\"columns\"]]\n",
    "                planilha.append(colunas)\n",
    "\n",
    "                #Escreve os dados das linhas na planilha\n",
    "                for linha in linhas:\n",
    "\n",
    "                    planilha.append(linha)\n",
    "\n",
    "                #Salva o arquivo de excel\n",
    "                pasta_trabalho.save(f\"{nome_planilha}.xlsx\")\n",
    "        \n",
    "        \n",
    "        #row - linha\n",
    "        #column - coluna\n",
    "        #columnspan - Quantas colunas da tela vai oculpar\n",
    "        #padx - Espaço entre as laterais da linha\n",
    "        #pady - Espaço em cima e embaixo\n",
    "        #stick - Remove os espaços em branco - NSEW (Norte, Sul, Leste e Oeste)\n",
    "        #Exibe a Treeview\n",
    "        #grid - A tela dividida em pequena partes como se fosse uma planilha\n",
    "        #Cria botão Deletar\n",
    "        botao_exportar_separar = Button(root, text=\"Exportar Separar\", font=\"Arial 14\", command=exportar_e_separar)\n",
    "        botao_exportar_separar.grid(row=4, column=4, padx=2, pady=2, stick=\"NSEW\")\n",
    "        \n",
    "        #Exibo a tela\n",
    "        root.mainloop()\n",
    "\n",
    "        \n",
    "    except HttpError as err:\n",
    "        print(err)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d78be9ad",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e1cb9fa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5fe7261",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e30c20fa",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}