def add_expense(user_id: int, raw_message: str):
""" Add expense associated with category """
messages = _parse_input(raw_message)
for message in messages:
category = Categories().get_category(user_id, message.category_name)
if not category:
category = Categories().add_category(user_id,
message.category_name)
db.insert(
"expenses", {
"user_id": user_id,
"category_id": category.id,
"ammount": message.ammount,
"created": message.created
})
def __init__(self):
self.categories = Categories()
self.categories.load()
self.alphabet = Alphabet()
self.alphabet.load()
self.responses = []
self.nextRound()
def update(self):
self.info.clear()
if not conn.isOpen():
if not conn.open():
raise DatabaseError
query = QSqlQuery(conn)
query.prepare('SELECT name, price, count, category FROM outgones WHERE\
(day = {} and month = {} and year = {})'.format(
self.day, self.month, self.year
))
query.exec_()
if not query.isSelect():
raise DatabaseError
query.first()
while query.isValid():
name = query.value('name')
price = query.value('price')
count = query.value('count')
category = query.value('category')
if category not in self.categories:
parent = QTreeWidgetItem(self.tree)
parent.setText(0, Categories(category).name)
self.categories[category] = parent
parent = self.categories[category]
child = QTreeWidgetItem(parent)
child.setText(
0,
'{}: {}x{} = {}'.format(name, price, count, price * count)
)
self.info.addData(category, price * count)
query.next()
async def categories_list(message: types.Message):
"""Отправляет список категорий расходов"""
usr_id = int(message.from_user.id)
categories = Categories(user_id=usr_id).get_all_categories()
answer_message = "Категории(группы) трат:\n\n* " +\
("\n\n* ".join([c.name+' ('+", ".join(c.aliases)+')' for c in categories]))
await message.answer(answer_message)
def __init__(self):
self.kategorie = Categories()
# Tabela wydatków
zeros_exp = [0 for i in range(len(self.kategorie.exp_categories))]
dict_exp = {
'Planowane': zeros_exp,
'Rzeczywiste': zeros_exp,
'Różnica': zeros_exp,
'St. realizacji budżetu (%)': zeros_exp
}
self.df_exp = pd.DataFrame(dict_exp,
index=self.kategorie.exp_categories)
# Tabela przychodów
zeros_inc = [0 for j in range(len(self.kategorie.inc_categories))]
dict_inc = {
'Planowane': zeros_inc,
'Rzeczywiste': zeros_inc,
'Różnica': zeros_inc,
'St. realizacji budżetu (%)': zeros_inc
}
self.df_inc = pd.DataFrame(dict_inc,
index=self.kategorie.inc_categories)
# Dane szczegółowe wydatków
zeros_details = [0 for k in range(31)]
dict_details = {}
for i in range(len(self.kategorie.exp_categories)):
dict_details[self.kategorie.exp_categories[i]] = zeros_details
self.df_details = pd.DataFrame(dict_details,
index=[x for x in range(1, 32)])
def _create_categories():
categories = Categories()
categories.create_category(SAME_LEMMA)
categories.create_category(DIFF_LEMMA)
categories.create_category(NOT_IN_BIN)
return categories
def __init__(self, mainwindow):
super().__init__()
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.mainwindow = mainwindow
self.ui.expense_radioButton.setChecked(True)
self.ui.back_pushButton.clicked.connect(self.close)
self.ui.savecategory_pushButton.clicked.connect(self.save_category)
self.ui.income_radioButton.clicked.connect(self.refresh_categories)
self.ui.expense_radioButton.clicked.connect(self.refresh_categories)
self.category_manager = Categories()
self.refresh_categories()
####################################
# categories tab part
####################################
self.ui.t_expense_radioButton.setChecked(True)
self.ui.t_expense_radioButton.clicked.connect(
self.refresh_transaction_categories)
self.ui.t_income_radioButton.clicked.connect(
self.refresh_transaction_categories)
self.ui.t_dateEdit.setDate(
QDate(date.today().year,
date.today().month,
date.today().day))
self.ui.t_savebutton.clicked.connect(self.save_transaction)
self.transaction_manager = Transactions()
self.refresh_transaction_categories()
def get_categories() -> str:
"""Функция вывода списка категорий с их алиасами (псевдонимами)"""
categories = Categories().get_all_categories()
answer_message = "Категории трат:\n\n- " + \
("\n- ".join([c.name + ' (' + ", ".join(c.aliases) + ')\n' for c in categories]))
return answer_message
def generate_password_list(individual, words_to_list, plugins):
"""
Kick off the password list generation
"""
individuals_passwords = Categories(individual, words_to_list,
plugins).process_categories()
dict_to_yaml = ProcessOutputYaml()
dict_to_yaml.output_processor(individuals_passwords)
def treeItems():
categories = Categories().data
for key in categories:
parent = QTreeWidgetItem(tree)
parent.setText(0, key)
for item in categories[key]:
child = QTreeWidgetItem(parent)
child.setText(0, item)
def categories_list(update, context: CallbackContext):
reply_markup = categories_markup()
message = 'Виберіть категорію:'
query_edit_message(update, message=message, reply_markup=reply_markup)
user_data = context.user_data
user_data['categories'] = Categories().all_categories
context.user_data['categories'] = user_data['categories']
return 3
def crawl_categories():
try:
categories = Categories()
categories = categories.go(request.args.get('url'))
return jsonify(categories)
except Exception as e:
resp = jsonify({'errcode': 500, 'errmsg': '抓取分类列表异常: ' + str(e)})
resp.status_code = 500
return resp
def delete_category(update: Update, context: CallbackContext) -> int:
""" Finishes the exchange and deletes a category """
categories = Categories().get_all_categories()
text = update.message.text.lower()
for c in categories:
if text == c.name:
Categories().del_category(c)
expenses.delete_category(c)
update.message.reply_text(
"Category and associated expenses were successfully deleted\n")
return ConversationHandler.END
update.message.reply_text(
"Category you are trying to delete does not exist\n"
"Specify a different name\n")
return State.REPLYING_CATEGORY_NAME_DELETE
def create_category(update: Update, context: CallbackContext) -> int:
""" Finishes the exchange and creates a category """
raw_message = update.message.text
category = Categories().add_category(update.effective_user.id, raw_message)
if category:
update.message.reply_text("Success")
return ConversationHandler.END
update.message.reply_text("This category already exists")
return ConversationHandler.END
def __init__(self, parent=None):
super().__init__(parent)
self.youtube_class = YouTubeView
self.youtube = YouTubeView(self)
self.tv_class = TVView
self.tv = TVView(self)
self.onetv = OneTvView(self)
self.onetv_class = OneTvView
self.folder = FolderView(self)
self.folder_class = FolderView
self.views = ('youtube', 'tv', 'onetv', 'folder')
#self.container = MainWidget(self)
self.container = QScrollArea()
#self.container.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.container.setWidgetResizable(True)
self.container.setStyleSheet("""
QWidget {
background-color: rgb(50,50,50);
color: #fff;
margin: 0;
}
""")
#self.container.setWidget(MainWidget())
self.setCentralWidget(self.container)
#self.container.setAttribute(Qt.WA_DontCreateNativeAncestors)
#self.container.setAttribute(Qt.WA_NativeWindow)
self.categories = Categories(self.container)
self.addDockWidget(Qt.LeftDockWidgetArea, self.categories, Qt.Vertical)
self.categories.setFocus()
self.play_control = QDockWidget()
# self.play_control.setLayout(QVBoxLayout())
# self.play_control.layout().setContentsMargins(0, 0, 0, 0)
# self.play_control.layout().setSpacing(0)
# self.play_control.setFixedHeight(50)
# self.play_control.setAllowedAreas(Qt.BottomDockWidgetArea)
# self.play_control.setFeatures(self.play_control.NoDockWidgetFeatures)
self.addDockWidget(Qt.BottomDockWidgetArea, self.play_control)
self.player = Player(str(int(self.container.winId())), self.play_control)
#player = mpv.MPV(wid=str(int(self.container.winId())),
# vo='vdpau', # You may not need this
# log_handler=print)
#player.play(sys.argv[1])
self.timer = QTimer()
self.timer.timeout.connect(self._timer)
self.timer.start(1000)
self.overlay = Overlay(self.centralWidget())
self.overlay.resize(1920, 1080)
self.overlay.hide()
def __init__(self, entry: dict, mainwindow):
super().__init__()
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.show()
self.ui.back_pushButton.clicked.connect(self.close)
self.ui.back_pushButton_2.clicked.connect(self.edit)
self.entry = entry
self.mainwindow = mainwindow
self.categories = Categories().category_list[self.entry['type']]
self.transactions = Transactions()
self.load_entry()
def add_expense(raw_message: str) -> Expense:
parsed_message = _parse_message(raw_message)
category = Categories().get_category(parsed_message.category_text)
db.insert(
"expense", {
"amount": parsed_message.amount,
"created": _get_now_formatted(),
"category_name": category.name,
"raw_text": raw_message
})
return Expense(id=None,
amount=parsed_message.amount,
category_name=category.name)
async def list_categories(message: types.Message):
"""
Sends a list of categories to the user
"""
categories_list = Categories().get_all_categories()
categories_strs = [
text(
bold(f"\"{c.category_name.capitalize()}\"\n") +
f"Теги: {c.aliases}\n") for c in categories_list
]
answer_text = "\n".join(categories_strs)
await message.answer(text(bold("Список категорий\n\n") + answer_text),
parse_mode=ParseMode.MARKDOWN)
def add_expense(raw_message: str) -> Expense:
"""Adds a new message. Accepts a text message came in the boat."""
parsed_message = _parse_message(raw_message)
category = Categories().get_category(parsed_message.category_text)
inserted_row_id = db.insert(
"expense", {
"amount": parsed_message.amount,
"created": _get_now_formatted(),
"category_codename": category.codename,
"raw_text": raw_message
})
return Expense(id=None,
amount=parsed_message.amount,
category_name=category.name)
def add_expense(raw_message: str) -> Expense:
"""Добавляет новое сообщение.
Принимает на вход текст сообщения, пришедшего в бот."""
parsed_message = _parse_message(raw_message)
category = Categories().get_category(
parsed_message.category_text)
inserted_row_id = db.insert("expense", {
"amount": parsed_message.amount,
"created": _get_now_formatted(),
"category_codename": category.codename,
"raw_text": raw_message
})
return Expense(amount=parsed_message.amount,
category_name=category.name)
def update_table(self, item):
table = Categories().tables
stylesheet = "::section{Background-color:rgb(176,224,230);border-radius:2px;}"
self.setColumnCount(len(table[item][0]))
self.setRowCount(len(table[item]) - 1)
for i in range(len(table[item])):
for j in range(len(table[item][i])):
if i == 0:
self.setHorizontalHeaderItem(
j, QTableWidgetItem(table[item][i][j]))
continue
self.setItem(i - 1, j, QTableWidgetItem(table[item][i][j]))
self.horizontalHeader().setStyleSheet(stylesheet)
self.resizeColumnsToContents()
self.horizontalHeader().setMaximumHeight(200)
def __init__(self, transaction, mainwindow):
super().__init__()
self.ui = Ui_edit_transaction_dialog()
self.ui.setupUi(self)
self.mainwindow = mainwindow
self.transaction = transaction
self.mainwindow.setEnabled(False)
self.transaction_manager = Transactions()
self.categories = Categories().category_list[self.transaction['type']]
self.laod_transaction()
self.show()
self.ui.back_pushButton.clicked.connect(self.close)
self.ui.savebutton.clicked.connect(self.edit)
print(transaction)
def add_expense(raw_message: str) -> Expense:
"""Додає нове повідомлення.
Приймає на вхід текст повідомлення, що прийшов в бот."""
parsed_message = _parse_message(raw_message)
category = Categories().get_category(parsed_message.category_text)
inserted_row_id = db.insert(
"expense", {
"amount": parsed_message.amount,
"created": _get_now_formatted(),
"category_codename": category.codename,
"raw_text": raw_message
})
return Expense(id=None,
amount=parsed_message.amount,
category_name=category.name)
def _generate_rows(self) -> [[str]]:
rows = list()
for item in self._result.results:
authors = self._process_authors(item.authors)
topics = self._process_set(item.topics)
src_info = item.source.data
rows.append(
self._clean_list([
src_info.date, src_info.year, authors, item.title,
item.category,
Categories().instance.name_for_key(self._cat_id),
self._ref_type, topics,
self._journal_title(), src_info.volume, src_info.number,
src_info.page, src_info.doi, item.pdf
]))
return None if len(rows) < 1 else rows
def __init__(self):
super().__init__()
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.ui.expense_radioButton.setChecked(True)
self.categories_manager = Categories()
self.load_categories()
print(self.categories_manager)
self.show()
self.ui.add_pushButton.clicked.connect(self.add_button_click)
self.ui.rename_pushButton.clicked.connect(self.rename_button_click)
self.ui.delete_pushButton.clicked.connect(self.delete_button_click)
self.ui.back_pushButton.clicked.connect(self.close)
self.ui.expense_radioButton.toggled.connect(
self.expense_radiobtn_active)
self.ui.income_radioButton.toggled.connect(self.income_radiobtn_active)
def add_expense(message: str, user_id: int) -> Expense:
"""
Функция добавления расхода в БД
:param message: полученное сообщение
:param user_id: идентификатор пользователя в VK
:return: class Expense - структура расхода
"""
parsed_message = _parse_message(message)
category = Categories().get_category(parsed_message.category_text)
db.insert("expenses", {
"user_id": str(user_id),
"amount": parsed_message.amount,
"created": _get_now_formatted(),
"category_codename": category.codename,
"raw_text": message
})
return Expense(id=None, user_id=None, amount=parsed_message.amount, category_name=category.name)
def simulation(self):
kategorie = Categories()
trans = ['inc', 'exp']
p = [0.2, 0.8]
categories_exp = kategorie.show_exp_categories()
categories_inc = kategorie.show_inc_categories()
types = ['r', 'p']
days = [x for x in range(1, 32)]
for i in range(self.n):
tr = ''.join(random.choices(trans, p))
t = random.choice(types)
d = random.choice(days)
if tr == 'inc':
cat = random.choice(categories_inc)
if cat == 'Wynagrodzenie' or cat == 'Premia':
a = random.randint(1500, 8000)
self.budzet.add_income(cat, t, a, d)
else:
a = random.randint(10, 1000)
self.budzet.add_income(cat, t, a, d)
elif tr == 'exp':
cat = random.choice(categories_exp)
if cat == 'Mieszkanie':
a = random.randint(500, 2000)
self.budzet.add_expense(cat, t, a, d)
else:
a = random.randint(5, 500)
self.budzet.add_expense(cat, t, a, d)
print('\n')
print(self.budzet.show_transactions() + '\n')
print(self.budzet.real_budget() + '\n' + self.budzet.plan_budget())
print(self.budzet.show_df_exp())
print('\n')
print(self.budzet.show_df_inc())
print('\n')
print(self.budzet.show_df_details())
def __init__(self, mainwindow):
super().__init__()
self.ui = Ui_add_transaction_dialog()
self.ui.setupUi(self)
self.mainwindow = mainwindow
self.ui.expense_radioButton.setChecked(True)
self.category_manager = Categories()
self.transactions = Transactions()
self.load_categories()
self.ui.dateEdit.setDate(
QDate(date.today().year,
date.today().month,
date.today().day))
self.show()
self.ui.expense_radioButton.toggled.connect(
self.expense_radiobtn_active)
self.ui.income_radioButton.toggled.connect(self.income_radiobtn_active)
self.ui.savebutton.clicked.connect(self.save_category)
self.ui.back_pushButton.clicked.connect(self.close)
self.mainwindow.setEnabled(False)
def add_expense(raw_message: str,userr_id) -> Expense:
"""Добавляет новое сообщение.
Принимает на вход текст сообщения, пришедшего в бот."""
parsed_message = _parse_message(raw_message)
category = Categories(user_id=userr_id).get_category(
parsed_message.category_text)
als=parsed_message.category_text
inserted_row_id = db.insert("expense", {
"amount": parsed_message.amount,
"created": _get_now_formatted(),
"category_name": category.name,
"raw_text": raw_message,
"alias":als,
"user_id":userr_id
})
#ins=str(((userr_id,_get_now_formatted(), parsed_message.amount,category.name,als,raw_message),))[1:-1]
#cursor = db.get_cursor()
#cursor.execute(f"insert into expense (user_id,created, amount,category_name,alias,raw_text) values {ins}")
return Expense(id=None,
amount=parsed_message.amount,
category_name=category.name)
def add_expense(raw_message: str, user_id: int, budget_id: int) -> Expense:
"""
Takes the recieved message, parses it and adds an expense to the DB.
Parameters:
raw_message: str — the recieved message, raw, not parsed
user_id: int — User's id
budget_id: int — the id the User's budget for the expense
Returns:
an instance of the Expense class
"""
parsed_message = _parse_message(raw_message)
category = Categories().get_category(parsed_message.category_text)
db.insert("expenses", {
"user_id": user_id,
"budget_id": budget_id,
"amount": parsed_message.amount,
"created": get_timenow_formatted(),
"category_codename": category.category_codename,
"raw_message": raw_message
})
return Expense(id=None, username=None,
amount=parsed_message.amount,
category_name=category.category_name)
