def database_remove_callback(self, update: Update,
context: CallbackContext):
query = update.callback_query
chat_id = query.message.chat_id
callback = json.loads(query.data)
if callback['answer'] == "database:yes":
results = self.get_data(chat_id=chat_id,
searchtext=callback['data'])
for image in results:
try:
query.bot.delete_message(chat_id=chat_id,
message_id=image['message_id'])
except Exception as err:
self.log(
text="No danger! Image just not found for deletion",
logging_type=logging.INFO)
Database.instance().delete_from_media_by_command(
chat_id=chat_id, searchtext=callback['data'])
query.edit_message_text(
text="Ois glöscht Kollege wir san wieder sauber!")
else:
query.edit_message_text(text="Guad daun los mas!")
class MainApplication:
"""Class which builds and manages UI."""
def __init__(self, root) -> None:
self.db = Database()
self.frames = self.create_frames(root)
AppButton(root, self.create_expense)
def create_frames(self, root) -> dict[FieldNames, Component]:
frames: Dict[FieldNames, Component] = {}
input_fields: List[FieldInfo] = [
{
"name": FieldNames.NAME,
"label": "Expense Name: "
},
{
"name": FieldNames.COST,
"label": "Expense Cost: "
},
{
"name": FieldNames.DATE,
"label": "Expense Date: "
},
]
for field in input_fields:
frame = InputField(root, field["label"])
frames[field["name"]] = frame
frames[FieldNames.TAGS] = Checkboxes(root, )
return frames
def create_expense(self):
name = self.frames[FieldNames.NAME].get()
cost = self.frames[FieldNames.COST].get()
date = self.frames[FieldNames.DATE].get()
tags = self.frames[FieldNames.TAGS].get()
if not date:
date = datetime.date.today()
expense = Expense(0, date=date, name=name, cost=cost, tags=tags)
try:
self.db.add_expense(expense)
self.clear_fields()
self.refocus_cursor()
except:
print("error")
def clear_fields(self):
self.frames[FieldNames.NAME].reset()
self.frames[FieldNames.COST].reset()
self.frames[FieldNames.DATE].reset()
self.frames[FieldNames.TAGS].reset()
def refocus_cursor(self):
self.frames[FieldNames.NAME].field.focus_set()
def save_media(self, update: Update, message, command: str, query: str,
type: str):
Database.instance().insert_into_media(
chat_id=message.chat_id,
message_id=message.message_id,
command=command,
username=update.message.chat.username,
user_id=update.message.from_user.id,
type=type,
searchtext=query)
def main() -> None:
def cmd_line_arg_handler() -> dict:
PYTHON_VERSION = "Python version: 3.10"
opts = [opt for opt in sys.argv[1:] if opt.startswith("-")]
cmd_line_args = {"debug": False}
for opt in opts:
if opt == "-h" or opt == "--help":
print(
"Expenses Tracker by Jason Tarka\n"
"Accepted command line arguments:\n"
'"-v" or "--version": Display version information\n'
'"-d" or "--debug": Enter debugging mode'
)
sys.exit()
if opt == "-v" or opt == "--version":
print(
"Application version: 1.1.0\n" f"Python version: {PYTHON_VERSION}"
)
sys.exit()
if opt == "-d" or opt == "--debug":
cmd_line_args["debug"] = True
return cmd_line_args
debug = cmd_line_arg_handler().get("debug", False)
db = Database(debug=debug)
app = Application(db)
app.start()
def get_data(self, chat_id, searchtext: str):
return Database.instance().get_from_media_by_command(
chat_id=chat_id, searchtext=searchtext)
from flask import Blueprint, render_template, request, redirect, url_for
from flask import session, flash
from repository.sqlite import db_session
from repository.database import Database
from model.category import Category
from model.item import Item
from views.utils import login_required, ownership_required
import random
import string
import json
web = Blueprint('web', __name__)
db = Database(db_session)
@web.route('/')
@web.route('/categories/')
def show_catalog_latest_items():
"""Display a list with the most recent items"""
categories = db.get_all_categories()
items = db.get_latest_items()
return render_template(
'catalog.html',
title='Latest Items',
categories=categories,
items=items)
@web.route('/categories/<int:category_id>/items/')
# formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# handler.setFormatter(formatter)
# root.addHandler(handler)
# Runs schedules besides from the telegram bot
def run_schedules():
while True:
schedule.run_pending()
time.sleep(3)
def main():
enable_logging()
start_new_thread(run_schedules, ())
updater = Updater(read_key("telegram"), use_context=True)
dp = updater.dispatcher
load_modules(dp)
send_awake_to_subscriber(dp)
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
updater.start_polling()
if __name__ == '__main__':
Database.instance()
main()
def __init__(self, root) -> None:
self.db = Database()
self.frames = self.create_frames(root)
AppButton(root, self.create_expense)
from fastapi import FastAPI
from configuration.exceptions import ApiBaseException, generic_handler
from controller.conta_controller import conta_router
from controller.correntista_controller import correntista_router
from controller.lancamento_controller import lancamento_router
from repository.database import Database
def _init_app():
app = FastAPI()
configura_exception_handler(app)
configura_routers(app)
return app
def configura_exception_handler(app):
app.add_exception_handler(ApiBaseException, generic_handler)
def configura_routers(app):
app.include_router(**conta_router)
app.include_router(**correntista_router)
app.include_router(**lancamento_router)
if __name__ == '__main__':
app = _init_app()
Database.criar_db()
uvicorn.run(app, host='127.0.0.1', port=8000)