def __init__(self):
connection = database.create_connection()
with connection:
active_users = database.fetch_result(
connection, Statements['SELECT_ALL_ACTIVITY_WITH_USERNAMES'])
logger.debug(f'Active users fetched.')
if self.active_users_cache is not None:
return
self.active_users_cache = {}
if active_users is None:
return
if isinstance(active_users[0], str):
active_users = {active_users}
for active_user in active_users:
user_id = active_user[0]
chat_id = active_user[1]
activity_timestamp = active_user[2]
if chat_id not in self.active_users_cache:
self.active_users_cache.update(
{chat_id: {
user_id: activity_timestamp
}})
else:
self.active_users_cache[chat_id].update(
{user_id: activity_timestamp})
logger.info('Active users cache loaded.')
def connect_to_db():
"""
Method creates a connection to database
:return: Connection object
"""
database_path = os.path.expanduser(
"~/Documents/LNUReader/ReaderDatabase.db")
return db.create_connection(database_path)
def connect_to_db():
"""
Method creates a connection to database
:return: Connection object
"""
path_to_db = os.path.expanduser("~/Documents/LNUReader")
if not os.path.exists(path_to_db):
os.makedirs(path_to_db)
return db.create_connection(path_to_db + r'\ReaderDatabase.db')
def __init__(self, book):
super().__init__()
self.resize(250, 530)
self.setWindowIcon(QIcon('../images/removeBook.ico'))
self.setMinimumSize(250, 530)
self.setMaximumSize(250, 530)
self.book_key = book
self.db_conn = db.create_connection(
os.path.expanduser("~/Documents/LNUReader/ReaderDatabase.db"))
self.setWindowFlags(Qt.Window | Qt.CustomizeWindowHint
| Qt.WindowTitleHint | Qt.WindowCloseButtonHint
| Qt.WindowStaysOnTopHint)
# Main Widget
self.mainQVBoxLayout = QVBoxLayout()
self.mainQVBoxLayout.setContentsMargins(0, 10, 0, 0)
# Categories
self.categoriesQWidget = QWidget()
self.categoriesQVBoxLayout = QVBoxLayout()
self.categoriesQVBoxLayout.setContentsMargins(0, 20, 0, 0)
self.categoriesQVBoxLayout.setSpacing(0)
# Categories buttons
self.categories = []
self.favouritesQButton = QPushButton()
# Buttons Menu
self.buttonsMenu = QWidget()
self.buttonsMenu.setObjectName('ButtonMenu')
self.buttonsMenuQHBoxLayout = QHBoxLayout()
self.buttonsMenuQHBoxLayout.setSpacing(0)
self.buttonsMenuQHBoxLayout.setContentsMargins(0, 0, 0, 0)
# Confirm and Decline Buttons
self.acceptButton = QPushButton()
self.acceptButton.setObjectName('FooterButton')
self.acceptButton.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Fixed)
self.acceptButton.clicked.connect(self.accept_additing)
self.declineButton = QPushButton()
self.declineButton.setObjectName('FooterButton')
self.declineButton.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Fixed)
self.declineButton.clicked.connect(self.decline_additing)
self.currentActiveButton = None
self.isAdded = False
ColorsRegulator().set_colors(
self, styles.Styles.set_add_to_ctg_dialog_style,
night_styles.NightStyles.set_add_to_ctg_dialog_style)
self.init_window()
def move_to_main( coin_properties: CoinProperties, user, wallet_balance ):
if wallet_balance <= 0:
return
if clientcommandprocessor.run_client_command( coin_properties.rpc_configuration, 'move', None, user, '', wallet_balance ):
connection = database.create_connection()
with connection:
database.execute_query( connection, Statements[ 'INSERT_USER' ], (user,) )
database.execute_query( connection, Statements[ 'UPDATE_USER_BALANCE' ], (user, coin_properties.ticker, str( wallet_balance ),) )
else:
raise Exception( f'Failed to move {user} balance {wallet_balance} to main account.' )
def rain(update, coin_properties: CoinProperties):
ticker = coin_properties.ticker
arguments = update.message.text.split(' ')
user = commonhelper.get_username(update)
if len(arguments) < 2:
raise BotUserError(messages.rain_error(ticker.lower()))
amount_to_rain = arguments[1]
total_balance, wallet_balance = commonhelper.get_user_balance(
user, coin_properties)
amount_to_rain = commonhelper.get_validated_amount(amount_to_rain, user,
total_balance)
eligible_users = ActivityTracker().get_current_active_users(update, user)
commonhelper.move_to_main(coin_properties, user, wallet_balance)
if len(eligible_users) == 0:
raise BotUserError('Found no active users except You... :\'(')
eligible_users.append(
Configuration.TELEGRAM_BOT_NAME) # Give some to the bot
amount_per_user = amount_to_rain / len(eligible_users)
amount_per_user = round_down(amount_per_user, 8)
amount_remainder = round_down(
amount_to_rain - amount_per_user * len(eligible_users) +
amount_per_user, 8)
at_users = '|'
users_balance_changes = []
connection = database.create_connection()
with connection:
users_balance_changes.append((user, ticker, str(-amount_to_rain)))
for eligible_user in eligible_users:
if eligible_user is Configuration.TELEGRAM_BOT_NAME:
users_balance_changes.append(
(eligible_user, ticker, str(amount_remainder)))
else:
users_balance_changes.append(
(eligible_user, ticker, str(amount_per_user)))
at_users = at_users.__add__(' @' + eligible_user + ' |')
database.execute_many(connection, Statements['UPDATE_USER_BALANCE'],
users_balance_changes)
logger.info(
f'rain amount ´{amount_to_rain}´ split between {len( eligible_users )} users.'
)
return f'@{user} has rained {amount_to_rain} {ticker} to ' \
f'{len( eligible_users )} active users: {at_users}\n{amount_per_user} ' \
f'{ticker} received per user.',
def main():
bot_configuration = BotConfiguration(Configuration)
connection = database.create_connection()
with connection:
database.init_database(connection)
database.execute_query(connection, Statements['INSERT_USER'],
(bot_configuration.telegram_bot_name, ))
for coin in bot_configuration.coins:
database.execute_query(connection, Statements['INSERT_COIN'], (
coin.name,
coin.ticker,
))
activity_tracker = ActivityTracker()
updater = Updater(token=bot_configuration.telegram_bot_token,
request_kwargs=None)
dispatcher = updater.dispatcher
for coin in bot_configuration.coins:
dispatcher.add_handler(
MessageHandler(~Filters.command, activity_tracker.track_activity))
dispatcher.add_handler(
CommandHandler(f'{coin.ticker}commands'.lower(),
Command(commands.commands, coin)))
dispatcher.add_handler(
CommandHandler(f'{coin.ticker}start'.lower(),
Command(commands.help, coin)))
dispatcher.add_handler(
CommandHandler(f'{coin.ticker}help'.lower(),
Command(commands.help, coin)))
dispatcher.add_handler(
CommandHandler(f'{coin.ticker}balance'.lower(),
Command(commands.balance, coin)))
dispatcher.add_handler(
CommandHandler(f'{coin.ticker}deposit'.lower(),
Command(commands.deposit, coin)))
dispatcher.add_handler(
CommandHandler(f'{coin.ticker}withdraw'.lower(),
Command(commands.withdraw, coin)))
dispatcher.add_handler(
CommandHandler(f'{coin.ticker}market'.lower(),
Command(commands.market, coin, activity_tracker)))
dispatcher.add_handler(
CommandHandler(f'{coin.ticker}tip'.lower(),
Command(commands.tip, coin, activity_tracker)))
dispatcher.add_handler(
CommandHandler(f'{coin.ticker}rain'.lower(),
Command(commands.rain, coin, activity_tracker)))
updater.start_polling()
logger.info('Bot started.')
def init_session():
conn = create_connection(DATABASE)
if conn is not None:
drop_table('users')
drop_table('astronauts')
create_table(conn, sql_create_users_table)
create_table(conn, sql_create_astronauts_table)
add_astronauts_bulk(ASTRONAUTS)
else:
message = "Cannot create database connection!"
LOG.error(message)
raise Exception(message)
conn.close()
def get_user_balance( user, coin_properties: CoinProperties ):
try:
user_balance = clientcommandprocessor.run_client_command( coin_properties.rpc_configuration, 'getbalance', None, user )
connection = database.create_connection()
with connection:
user_off_chain_balance = database.fetch_result( connection, Statements[ 'SELECT_USER_OFF_CHAIN_BALANCE' ], (user, coin_properties.ticker) )
if user_off_chain_balance is None:
user_off_chain_balance = 0
user_off_chain_balance = round_down( user_off_chain_balance, 8 )
total_balance = user_balance + user_off_chain_balance
return total_balance, user_balance
except BotUserError:
raise BotUserError
def track_activity(self, bot, update):
try:
chat_id = update.message.chat_id
now = datetime.now()
current_time = datetime.timestamp(now)
user = commonhelper.get_username(update)
connection = database.create_connection()
with connection:
user_id = database.fetch_result(
connection,
Statements['SELECT_USER_ID_BY_TELEGRAM_USERNAME'],
(user, ))
if user_id is None:
user_id = database.execute_query(connection,
Statements['INSERT_USER'],
(user, ))
database.execute_query(connection,
Statements['UPDATE_USER_ACTIVITY'], (
user_id,
chat_id,
current_time,
))
if chat_id not in self.active_users_cache:
self.active_users_cache.update({chat_id: {user: current_time}})
else:
if user not in self.active_users_cache[chat_id]:
self.active_users_cache[chat_id].update(
{user: current_time})
else:
self.active_users_cache[chat_id][user] = current_time
logger.info(
f'@{user} spoke @{chat_id} at {self.active_users_cache[ chat_id ][ user ]}.'
)
except BotUserError as e:
logger.info(e)
def tip(update, coin_properties: CoinProperties):
ticker = coin_properties.ticker
arguments = update.message.text.split(' ')
if len(arguments) < 3:
raise BotUserError(messages.tip_error(ticker.lower()))
user = commonhelper.get_username(update)
target_user = arguments[1]
amount = arguments[2]
if '@' not in target_user:
raise BotUserError(f'That user ´{target_user}´ is not applicable.')
target_user = target_user[1:]
user_balance, wallet_balance = commonhelper.get_user_balance(
user, coin_properties)
amount = commonhelper.get_validated_amount(amount, user, user_balance)
commonhelper.move_to_main(coin_properties, user, wallet_balance)
if target_user == user:
raise BotUserError('You can not tip Yourself.')
users_balance_changes = [(user, ticker, str(-amount)),
(target_user, ticker, str(amount))]
connection = database.create_connection()
with connection:
database.execute_query(connection, Statements['INSERT_USER'],
(target_user, ))
database.execute_many(connection, Statements['UPDATE_USER_BALANCE'],
users_balance_changes)
return f'@{user} tipped @{target_user} of {amount} {ticker}',
def __init__(self, book):
super().__init__()
self.setMinimumSize(700, 400)
self.resize(1000, 600)
self.book = book
self.db_connection = db.create_connection(
os.path.expanduser("~/Documents/LNUReader/ReaderDatabase.db"))
self.mainLayout = QVBoxLayout()
self.bookmarksTable = QTableWidget()
self.notesTable = QTableWidget()
self.tabWidget = QTabWidget()
self.tabWidget.addTab(self.bookmarksTable, '')
self.tabWidget.addTab(self.notesTable, '')
# Back Button
self.backQButton = QPushButton()
ColorsRegulator().set_icon_color(self.backQButton,
'design/images/back.png',
'design/images/night/night_back.png')
ColorsRegulator().set_colors(
self.backQButton, styles.Styles.set_back_button_styles,
night_styles.NightStyles.set_back_button_styles)
self.backQButton.setIconSize(QSize(32, 32))
self.backQButton.setFocusPolicy(Qt.NoFocus)
self.backQButton.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.contextMenu = QMenu()
self.openAct = self.contextMenu.addAction("")
self.deleteAct = self.contextMenu.addAction("")
ColorsRegulator().set_icon_color(
self.openAct, 'design/images/pencil.png',
'design/images/night/night_pencil.png')
ColorsRegulator().set_icon_color(
self.deleteAct, 'design/images/removeBook.png',
'design/images/night/night_removeBook.png')
ColorsRegulator().set_colors(
self.contextMenu, styles.Styles.set_context_menu_styles,
night_styles.NightStyles.set_context_menu_styles)
self.openAct.triggered.connect(self.edit_obj)
self.deleteAct.triggered.connect(self.delete_obj)
QShortcut("Del", self).activated.connect(self.delete_obj)
self.editNoteQDialog = QTwoFieldDialog()
self.editNoteQDialog.setWindowIcon(QIcon('design/images/icon.ico'))
self.editNoteQDialog.resize(600, 480)
self.editBookmarkQDialog = QInputDialog()
self.editBookmarkQDialog.setInputMode(QInputDialog.TextInput)
self.editBookmarkQDialog.setWindowIcon(QIcon('design/images/icon.ico'))
self.editBookmarkQDialog.resize(600, 480)
ColorsRegulator().set_colors(
self.editBookmarkQDialog, styles.Styles.set_dialog_styles,
night_styles.NightStyles.set_dialog_styles)
ColorsRegulator().set_colors(
self, styles.Styles.set_content_window_style,
night_styles.NightStyles.set_content_window_style)
localize.set_content_localization(self)
self.notesTable.itemDoubleClicked.connect(self.edit_note)
# Bookmark / note delete confirmation dialog
self.deleteDialog = ConfirmDialog()
self.deleteDialog.setWindowIcon(QIcon('design/images/icon.ico'))
self.main_init()
def withdraw(update, coin_properties: CoinProperties):
ticker = coin_properties.ticker
arguments = update.message.text.split(' ')
user = commonhelper.get_username(update)
if len(arguments) < 3:
raise BotUserError(messages.withdraw_error(ticker.lower()))
address = arguments[1]
address = commonhelper.get_validated_address(address, coin_properties)
amount = arguments[2]
total_balance, wallet_balance = commonhelper.get_user_balance(
user, coin_properties)
amount = commonhelper.get_validated_amount(amount, user, total_balance)
configured_transaction_fee = round_down(coin_properties.withdrawal_fee, 8)
if amount < coin_properties.minimum_withdraw:
raise BotUserError(
f'Minimum allowed withdrawal amount is {configured_transaction_fee}{ticker}.'
)
if arguments[2].lower is 'all':
amount -= configured_transaction_fee
elif amount + configured_transaction_fee > total_balance:
raise BotUserError(
f'Unable to withdraw {amount}{ticker}. '
f'Amount combined with withdrawal fee {configured_transaction_fee}{ticker} exceeds the available balance: '
f'{round_down( amount + configured_transaction_fee, 8 )}{ticker} > {round_down( total_balance, 8 )}{ticker}.'
)
commonhelper.move_to_main(coin_properties, user, wallet_balance)
transaction_id = clientcommandprocessor.run_client_command(
coin_properties.rpc_configuration, 'sendtoaddress', None, address,
amount)
real_transaction_fee = commonhelper.get_transaction_fee(
coin_properties.rpc_configuration, transaction_id)
users_balance_changes = [
(user, ticker, str(-amount - configured_transaction_fee)),
(Configuration.TELEGRAM_BOT_NAME, ticker,
str(configured_transaction_fee + real_transaction_fee))
]
try:
connection = database.create_connection()
with connection:
database.execute_many(connection,
Statements['UPDATE_USER_BALANCE'],
users_balance_changes)
except Exception as e:
logger.error(e)
return messages.GENERIC_ERROR
blockchain_explorer: BlockchainExplorerConfiguration = coin_properties.blockchain_explorer
if blockchain_explorer is not None:
address = f'<a href="{blockchain_explorer.url}/{blockchain_explorer.address_prefix}/{address}">{address}</a>'
transaction_id = f'<a href="{blockchain_explorer.url}/{blockchain_explorer.tx_prefix}/{transaction_id}">{transaction_id}</a>'
return f'@{user} has successfully withdrawn {amount}{ticker} to address: {address}.<pre>\r\n</pre>TX: {transaction_id}. ' \
f'Withdrawal fee of {configured_transaction_fee}{ticker} was applied.', 'HTML'
def connect_to_db():
path_to_db = os.path.expanduser("~/Documents/LNUReader")
if not os.path.exists(path_to_db):
os.makedirs(path_to_db)
return db.create_connection(path_to_db + r'\ReaderDatabase.db')
