def _do_partial_comparison(self, left_side_table, right_side_table):
'''
Loops on the fields,
For each field (record) compare just the traits (columns) I need to.
I need to do it that way to have a detailed report as to what is not matching
Columns in records come in this order: Field,Type,Nul,Key,Default,Extra
'''
if len(left_side_table) != len(right_side_table):
self.has_errors = True
self.dynamic_error_str += "number of fields do not match between both tables\n"
for field_name in left_side_table.keys():
L.info("checking field {}".format(field_name))
try:
for compare_type in self.params:
if left_side_table[field_name][Same.comapre[
compare_type]] != right_side_table[field_name][
Same.comapre[compare_type]]:
self.has_errors = True
self.dynamic_error_str += "field [{}] is not same for comparison param [{}]".format(
field_name, compare_type) + "\n"
except IndexError:
self.has_errors = True
self.dynamic_error_str += "Field [{}] does not exists in right side table".format(
field_name) + "\n"
except KeyError:
self.has_errors = True
self.dynamic_error_str += "Field [{}] does not exists in table [{}.{}]".format(
field_name, self.right_side_db,
self.right_side_table) + "\n"
def start(processID, parallelMode, useGUI):
""" main entry point into the application """
Config.processID = processID
Config.parallelMode = parallelMode
Config.sumoUseGUI = useGUI
# Check if sumo is installed and available
SUMODependency.checkDeps()
info('# SUMO-Dependency check OK!', Fore.GREEN)
# Load the sumo map we are using into Python
Network.loadNetwork()
info(Fore.GREEN + "# Map loading OK! " + Fore.RESET)
info(Fore.CYAN + "# Nodes: " + str(Network.nodesCount()) + " / Edges: " +
str(Network.edgesCount()) + Fore.RESET)
# Start sumo in the background
SUMOConnector.start()
info("\n# SUMO-Application started OK!", Fore.GREEN)
# Start the simulation
Simulation.start()
# Simulation ended, so we shutdown
info(Fore.RED + '# Shutdown' + Fore.RESET)
traci.close()
sys.stdout.flush()
return None
def _do_full_comparison(self, left_side_table, right_side_table):
'''
I check number of fields match (I removed ignored fields in previous steps)
I check structure is exact same
'''
if len(left_side_table) != len(right_side_table):
self.has_errors = True
self.dynamic_error_str = "number of fields does not match between both tables"
return
for field_name in left_side_table.keys():
L.info("checking field {}".format(field_name))
try:
if left_side_table[field_name] != right_side_table[
field_name]: #full array comparison
self.has_errors = True
self.dynamic_error_str = "schema for field {} is not same".format(
field_name)
return
except IndexError:
self.has_errors = True
self.dynamic_error_str = "Field {} does not exists in right side table".format(
field_name)
return
def start(cls):
""" start the simulation """
info("# Start adding initial cars to the simulation", Fore.MAGENTA)
# apply the configuration from the json file
cls.applyFileConfig()
CarRegistry.applyCarCounter()
cls.loop()
def sms():
_from = request.values.get('from',None) #from means the person from whom the text is coming from.
text = request.values.get('text',None) #this gets the text in the message sent by user
split_text = text.split('*')
name = split_text[0].capitalize()
age = split_text[1]
gender = split_text[2].lower()
count = Contacts.query.filter_by(phoneNumber = _from).count()
if not count > 0:
#no idea what api key is, what it does. Also, the use of the username is a mystery.
#username is your Africa'sTalking username and api key is obtained from website
gateway = AfricasTalkingGateway(os.environ.get('username'), os.environ.get('apikey'))
gateway.sendMessage (_from, "Thank you for registering for this service. To get inspiration messages, call 20880. Calls charged at 10 bob per minute. Have a blessed day.")
#here the details are added to db table contacts
contacts = Contacts (name=name, age = age, phoneNumber = _from)
db.session.add(contacts)
db.session.commit()
logging.info("user added{}".format(contacts))
else:
logging.info("User already registered.")
resp = make_response ("OK", 200)
return resp
def action(self):
'''
@return should_i_stop boolean
the result of the previous action. If it is true
execution should stop, but I will alert the user this arg was activated, he/she might have done a mistake
return True will break the command string from fully executing.
This type of command is a blocking command i.e. nothing happens later if
this flag was supplied
'''
if self.do_test:
if self.validate_input():
if self.handle_x_files != None and int(self.handle_x_files) >0:
limit_of_files_processed = int(self.handle_x_files)
limit_info = self.handle_x_files
else: #if I do not provide the --all flag, I still run JUST the tests on all the files.
limit_of_files_processed = 0 #Inverse loop, 0 means all
limit_info = 'all'
L.info('RUNNING TEST upgrade on {}:{}@{}'.format(upgrade_config['test_user'],upgrade_config['test_password'],upgrade_config['test_host']))
L.info("WILL TEST upgrade with {} files".format(limit_info))
files_where_processed = app.upgrade.actions.test(limit_of_files_processed)
if not files_where_processed:
return True
return False
def action(self):
'''
@return should_i_stop boolean
the result of the previous action. If it is true
execution should stop, but I will alert the user this arg was activated, he/she might have done a mistake
return True will break the command string from fully executing.
This type of command is a blocking command i.e. nothing happens later if
this flag was supplied
'''
if self.do_test:
if self.validate_input():
if self.handle_x_files != None and int(
self.handle_x_files) > 0:
limit_of_files_processed = int(self.handle_x_files)
limit_info = self.handle_x_files
else: #if I do not provide the --all flag, I still run JUST the tests on all the files.
limit_of_files_processed = 0 #Inverse loop, 0 means all
limit_info = 'all'
L.info('RUNNING TEST upgrade on {}:{}@{}'.format(
upgrade_config['test_user'],
upgrade_config['test_password'],
upgrade_config['test_host']))
L.info("WILL TEST upgrade with {} files".format(limit_info))
files_where_processed = app.upgrade.actions.test(
limit_of_files_processed)
if not files_where_processed:
return True
return False
async def register_chat(message: types.Message):
chat_id = message.from_user.id
admins = await message.chat.get_administrators()
for admin in admins:
if chat_id == admin.user.id:
await message.reply(_("🏡 Добро пожаловать Домой!\n"
"🏛 Перейдите пожалуйста в ЛС и укажите Ваше расположение\n"))
exists = add_chat(message.chat.id)
if exists:
text = _("🏛 Ваше расположение уже было зарегистрировано. "
"Создайте новое расположение Вашего 🏡чата/канала\n"
"Для этого выберите язык чата из списка")
else:
text = _("🏛 Поздравляем! Ваш 🏡чат/канал ⚡️связан с ☀️Атлантидой. "
"Создайте расположение Вашего 🏡чата/канала\n"
"Для этого выберите язык чата из списка")
language_keyboard = ListOfButtons(
text=["English", "Русский", "Українська"],
callback=[language_callback.new(code="en"),
language_callback.new(code="ru"),
language_callback.new(code="uk")]
).inline_keyboard
await bot.send_message(chat_id, text,
reply_markup=language_keyboard)
await dp.current_state(chat=chat_id, user=chat_id).set_state(Registration.Language)
await dp.current_state(chat=chat_id, user=chat_id).update_data(chat_id=message.chat.id)
break
else:
await message.answer(_("🏛 Приносим извинения за временные неудобства. \n"
"В данный момент принимаются только администраторы чатов/каналов"))
logging.info("User is not an admin")
def process(self,db,file_content,filename):
'''
Read the file and extract from the CREATE stmt the type and name
'''
command = ""
db_object_search = re.search("CREATE\W*(\w*)\W*(\w*)\W*(\w*)\W*(\w*)",file_content,re.I)
try:
db_obj_type = db_object_search.group(1)
db_obj_name = db_object_search.group(2)
if(db_obj_type == "ALGORITHM"):
db_obj_type = db_object_search.group(3)
db_obj_name = db_object_search.group(4)
command = "DROP {type} {name} ".format(type=db_obj_type,name=db_obj_name)
L.info(command)
except IndexError:
L.fatal("Error parsing file contents [{}]".format(file_content))
raise Exception("Error parsing file contents")
try:
self.cursor.execute(command)
except MyExcp as err:
if (
err.errno == MyErrCode.ER_SP_DOES_NOT_EXIST or
err.errno == MyErrCode.ER_TRG_DOES_NOT_EXIST
):
pass
def __init__(self, args):
'''
Stores a dictionary of what to clean
'''
# Process arguments
self.args = args
# Loads the database names rcom is tracking. This will be used in case of --all, this will also be used in case a specific db
# is targeted to make sure i is a tracked DB.
sp_dbs = meta.tracked_dbs(meta.STORED_PROCEDURES,self.args.assets_path)
trigger_dbs = meta.tracked_dbs(meta.TRIGGERS,self.args.assets_path)
function_dbs = meta.tracked_dbs(meta.FUNCTIONS,self.args.assets_path)
views_dbs = meta.tracked_dbs(meta.VIEWS,self.args.assets_path)
# decide which DBs I am going to clean. --all means EVERYTHING,
# -s,-w,-t,-f means every thing for each of those types
# -s db name, -f db name -w db name -tdb name means JUST THAT db name
# for the specified object type, u can have several object types
if self.args.handle_all:
self.what_to_handle = {'s':sp_dbs,'w':views_dbs, 't':trigger_dbs, 'f':function_dbs}
else:
self.what_to_handle = {'s': sp_dbs if self.args.stored_proc == 'All' else ([self.args.stored_proc] if self.args.stored_proc in sp_dbs else []),
'w': views_dbs if self.args.views == 'All' else ([self.args.views] if self.args.views in views_dbs else []),
't': trigger_dbs if self.args.triggers == 'All' else ([self.args.triggers] if self.args.triggers in trigger_dbs else []),
'f': function_dbs if self.args.functions == 'All' else ([self.args.functions] if self.args.functions in function_dbs else [])}
L.info("cleaning the following:")
L.info(self.what_to_handle)
# More config values for later
self.dry_run = self.args.dry_run
self.ignore_dbs = [('information_schema',),('performance_schema',),('sys',)]
self.ignore_dbs_str = "'information_schema','performance_schema','sys'"
self.connect()
def process(self, db, file_content, filename):
'''
Read the file and extract from the CREATE stmt the type and name
'''
command = ""
db_object_search = re.search("CREATE\W*(\w*)\W*(\w*)\W*(\w*)\W*(\w*)",
file_content, re.I)
try:
db_obj_type = db_object_search.group(1)
db_obj_name = db_object_search.group(2)
if (db_obj_type == "ALGORITHM"):
db_obj_type = db_object_search.group(3)
db_obj_name = db_object_search.group(4)
command = "DROP {type} {name} ".format(type=db_obj_type,
name=db_obj_name)
L.info(command)
except IndexError:
L.fatal("Error parsing file contents [{}]".format(file_content))
raise Exception("Error parsing file contents")
try:
self.cursor.execute(command)
except MyExcp as err:
if (err.errno == MyErrCode.ER_SP_DOES_NOT_EXIST
or err.errno == MyErrCode.ER_TRG_DOES_NOT_EXIST):
pass
def refresh(self):
response = requests.post(constants.OAUTH_TOKEN,
headers={
'Authorization':
'basic {}'.format(self.fortnite_token)
},
data={
'grant_type':
'refresh_token',
'refresh_token':
'{}'.format(self.refresh_token),
'includePerms':
True
}).json()
access_token = response.get('access_token')
self.session.headers.update(
{'Authorization': 'bearer {}'.format(access_token)})
self.refresh_token = response.get('refresh_token')
self.expires_at = utils.convert_iso_time(response.get('expires_at'))
logging.info(
"Токен доступа для использования Fortnite API перегенерирован.")
logging.debug(
"Access Token: {0}; Refresh Token: {1}; Expires At: {2}.".format(
access_token, self.refresh_token, self.expires_at))
def action(self):
'''
@return should_i_stop boolean
the result of the previous action. If it is true
execution should stop, but I will alert the user this arg was activated, he/she might have done a mistake
return True will break the command string from fully executing.
This type of command is a blocking command i.e. nothing happens later if
this flag was supplied
'''
if self.validate_input():
if self.handle_x_files != None and int(self.handle_x_files) > 0:
limit_of_files_processed = -1 * int(self.handle_x_files)
limit_info = self.handle_x_files
else: #if I do not provide the --all flag, I still run JUST the tests on all the files.
limit_of_files_processed = 0 #Invers loop, 0 means all, negative numbers I use to represent how many files more to run
limit_info = 'all'
L.info('RUNNING UPGRADE ON ACTUAL SERVER')
L.info("WILL UPGRADE with {} files".format(limit_info))
files_where_processed = app.upgrade.actions.upgrade(
limit_of_files_processed)
if not files_where_processed:
return True
return False
def __init__(self, db):
'''
Constructor
'''
self.current_db = db
self.tables_list = {}
self.right_side_db = ''
L.info("Initiating TableList for db [{}]".format(db))
def get_companies_guid_by_keyword(keyword, **kwargs):
logging.info(
f'Получение guid компаний с сервера по ключевому слову -> {keyword}')
companies_guid = parser.get_companies_guid_by_keyword(keyword, **kwargs)
logging.info(
f'Найдено {len(companies_guid)} компаний по ключевому слову -> {keyword}'
)
return companies_guid
def __init__(self,db):
'''
Constructor
'''
self.current_db = db
self.tables_list = {}
self.right_side_db = ''
L.info("Initiating TableList for db [{}]".format(db))
def check_token():
Timer(20.0, check_token).start()
now = datetime.utcnow()
if self.expires_at < (now - timedelta(seconds=60)):
logging.info(
"Время действия токена доступа для Fortnite API истекло, генерируется новый."
)
self.refresh()
def close_db():
# Close connection to database
global conn
conn.close()
# Stop the tunnel
global tunnel
tunnel.stop()
logging.info("Closed connections successfully.")
def get_connection():
global _connection
if not _connection:
user = config.mysql['username']
password = config.mysql['password']
host = config.mysql['host']
L.info("Trying to connect to {}:{}@{}".format(config.mysql['username'],config.mysql['password'],config.mysql['host']))
_connection = My.connect(user=user, password=password,host=host,buffered=True)
return _connection
def __init__(self, args):
'''
Stores a dictionary of what to clean
'''
# Process arguments
self.args = args
# Loads the database names rcom is tracking. This will be used in case of --all, this will also be used in case a specific db
# is targeted to make sure i is a tracked DB.
sp_dbs = meta.tracked_dbs(meta.STORED_PROCEDURES,
self.args.assets_path)
trigger_dbs = meta.tracked_dbs(meta.TRIGGERS, self.args.assets_path)
function_dbs = meta.tracked_dbs(meta.FUNCTIONS, self.args.assets_path)
views_dbs = meta.tracked_dbs(meta.VIEWS, self.args.assets_path)
# decide which DBs I am going to clean. --all means EVERYTHING,
# -s,-w,-t,-f means every thing for each of those types
# -s db name, -f db name -w db name -tdb name means JUST THAT db name
# for the specified object type, u can have several object types
if self.args.handle_all:
self.what_to_handle = {
's': sp_dbs,
'w': views_dbs,
't': trigger_dbs,
'f': function_dbs
}
else:
self.what_to_handle = {
's':
sp_dbs if self.args.stored_proc == 'All' else
([self.args.stored_proc]
if self.args.stored_proc in sp_dbs else []),
'w':
views_dbs if self.args.views == 'All' else
([self.args.views] if self.args.views in views_dbs else []),
't':
trigger_dbs if self.args.triggers == 'All' else
([self.args.triggers]
if self.args.triggers in trigger_dbs else []),
'f':
function_dbs if self.args.functions == 'All' else
([self.args.functions]
if self.args.functions in function_dbs else [])
}
L.info("cleaning the following:")
L.info(self.what_to_handle)
# More config values for later
self.dry_run = self.args.dry_run
self.ignore_dbs = [('information_schema', ), ('performance_schema', ),
('sys', )]
self.ignore_dbs_str = "'information_schema','performance_schema','sys'"
self.connect()
def action(self):
'''
@return should_i_stop boolean
the result of the previous action. If it is true
execution should stop, but I will alert the user this arg was activated, he/she might have done a mistake
return True will break the command string from fully executing.
This type of command is a blocking command i.e. nothing happens later if
this flag was supplied
'''
L.info("Validating system files and db entries")
app.upgrade.actions.validate_system()
return False
def action(self):
'''
@return should_i_stop boolean
the result of the previous action. If it is true
execution should stop, but I will alert the user this arg was activated, he/she might have done a mistake
return True will break the command string from fully executing.
This type of command is a blocking command i.e. nothing happens later if
this flag was supplied
'''
L.info("Validating system files and db entries")
app.upgrade.actions.validate_system()
return False
def iterate(self):
'''
Main iteration processor bala bala
'''
print(self.folders)
print('------------------')
for sub_folder in self.folders:
# If this is actually just a sql file, do it directly. Otherwise do loop next
if self.file_postfix in sub_folder:
db = meta.extract_db_name(sub_folder)
# TOBEDELETED once verified not used self._current_file = sub_folder
self._current_path = sub_folder # NOT SURE IT IS USED!
L.info(
"handler is [{}] doing root [{}] file [{}] in database [{}]\n"
.format(self.__class__.__name__, sub_folder, sub_folder,
db))
f = open(sub_folder, 'r')
file_content = f.read()
f.close()
self.changeDB(db, file_content)
self.process(db, file_content, sub_folder)
continue
else:
# Loop on files and run sql
for root, dirnames, filenames in os.walk(sub_folder):
# This is where I apply the filter of the ignored file list.
if any(ignored_partial_string in root
for ignored_partial_string in
config.ignore_files_dirs_with):
continue
for filename in fnmatch.filter(filenames,
'*' + self.file_postfix):
# print(filenames)
# print(dirnames)
# print("----------------------------------")
# print(root)
db = meta.extract_db_name(root)
# print(db+"\n")
# print(config.ignore_files_dirs_with)
self._current_path = root
L.info(
"handler is [{}] doing root [{}] file [{}] in database [{}]\n"
.format(self.__class__.__name__, root, filename,
db))
f = open(root + '/' + filename, 'r')
file_content = f.read()
f.close()
self.changeDB(db, file_content)
self.process(db, file_content, filename)
def messages(company_guid):
regex_filter = request.args.get('regex_filter') or r'банкрот'
messages_info = []
messages = ds.get_company_messages(company_guid, **request.args)
for message in messages:
if re.search(regex_filter, message.get('text').lower() or ' '):
messages_info.append(message)
logging.info(
f'Найдено {len(messages_info)} релевантных сообщений компании ({company_guid}) (текст-фильтр: "{regex_filter}")'
)
return {'count': len(messages_info), 'messages': messages_info}
def load_data():
db = create_database()
logging.info('-------------------')
logging.info('Created Database..')
logging.info('Loading Trucks data to Database')
db.insert_multiple(TRUCKS)
logging.info('Loading is done')
def action(self):
'''
@return should_i_stop boolean
the result of the previous action. If it is true
execution should stop, but I will alert the user this arg was activated, he/she might have done a mistake
return True will break the command string from fully executing.
This type of command is a blocking command i.e. nothing happens later if
this flag was supplied
'''
if self.file_name_to_mark_complete != None:
L.info("Marking {} as COMPLETE in upgrade tracking table {}.rcom_sql_upgrades".format(self.file_name_to_mark_complete,upgrade_config['upgrade_tracking_database']))
app.upgrade.actions.mark_complete(self.file_name_to_mark_complete)
return True
return False
def voice_callback():
isActive = request.values.get('isActive', None)
sessionId = request.values.get('sessionId', None)
callerNumber = request.values.get('callerNumber', None)
if isActive == '1':
callerNumber = request.values.get('callerNumber', None)
logging.info("caller is {}".format(callerNumber))
response = '<Response>'
response += '<Say maxDuration="60" playBeep="false"> Hi, '
response += 'Welcome to the Moringa school dating challenge.'
member = Member.query.get(callerNumber)
if member.gender.lower() == 'female':
# find a man
count = Member.query.filter_by(gender = 'male').count()
man = random.choice(Member.query.filter_by(gender = 'male', status='Active').all())
logging.info("{} calling -- {}".format(member.name, man))
if count > 0:
response += "I'll connect you in a second </Say>"
response += '<Dial phoneNumbers="{}" ringBackTone="{}"/>'.format(man.phoneNumber, os.environ.get('sauti'))
else:
response += "No love for you today, for now. </Say>"
else:
# find a woman
count = Member.query.filter_by(gender='female').count()
woman = random.choice(Member.query.filter_by(gender='female', status='Active').all())
logging.info("{} caller - {}".format(member.name, woman))
if count > 0:
response += "I'll connect you in a second</Say>"
response += '<Dial phoneNumbers="{}" ringBackTone="{}"/>'.format(woman.phoneNumber, os.environ.get('sauti'))
else:
response += "No love for you today, for now. </Say>"
response += '</Response>'
voice = Voice(sessionId=sessionId, url='')
db.session.add(voice)
db.session.commit()
else:
voice = Voice.query.filter_by(sessionId = sessionId).first()
voice.callCost = request.values.get('amount', None)
db.session.add(voice)
db.session.commit()
logging.info(request.values)
response = ""
resp = make_response(response, 200)
resp.headers['Content-Type'] = "application/xml"
return resp
async def connection():
try:
psql_connection = await asyncpg.connect(host=config.databaseHost,
database=config.databaseName,
user=config.databaseUsername,
port=config.databasePort)
logging.info("Соединение с Базой Данных PostgreSQL может быть установлено успешно.")
logging.debug("Returned response: " + str(psql_connection))
await psql_connection.close()
return "OK"
except Exception as e:
logging.error("Произошла ошибка при попытке подключения к Базе Данных PostgreSQL.", exc_info=True)
return e
async def connection():
try:
response = await Redis.execute("ping")
logging.info(
"The connection to Redis Server can be established successfully."
)
logging.debug("Returned response: " + str(response))
return "OK"
except Exception as e:
logging.error(
"Exception has been occurred while trying to establish connection with "
"Redis.",
exc_info=True)
return e
def action(self):
'''
Runs the schma checker on the test server
@return should_i_stop boolean
the result of the previous action. If it is true
execution should stop, but I will alert the user this arg was activated, he/she might have done a mistake
return True will break the command string from fully executing.
This type of command is a blocking command i.e. nothing happens later if
this flag was supplied
'''
if self.do_on_test_server and self.do_schema_test:
L.info("Running schema checker on test server {}@{}".format(upgrade_config['test_user'],upgrade_config['test_host']))
app.upgrade.actions.test_with_schema()
return False
def _internal_test_rule(self):
'''
Remember! the results of describe [table_name] are:
Field,Type,Nul,Key,Default,Extra
'''
cursor = self._get_cursor()
cursor.execute(self.sql)
fields = [all_fields[0] for all_fields in cursor]
for check_field in self.params:
L.info("checking field [{}] exists in".format(check_field))
L.debug(str(fields))
if check_field not in fields:
self.has_errors = True
self.dynamic_error_str += " [" + check_field + "]"
return self
def _move_file_if_completed(file_name):
'''
used in archive, moves the file if is completed
'''
cnx = app.db.get_connection()
cursor = cnx.cursor()
sql = "SELECT COUNT(*) FROM {}.rcom_sql_upgrades WHERE file_name=%s AND execution_status = 'completed' ".format(
upgrade_config['upgrade_tracking_database'])
cursor.execute(sql, (file_name, ))
res = cursor.fetchall()
if res[0][0] == 1:
L.info("About to ARCHIVE [{}]".format(file_name))
subprocess.check_call([
'mv', config.assets_folder + "/upgrades/current/" + file_name,
config.assets_folder + "/upgrades/archive/."
])
def action(self):
'''
Runs the schma checker on the test server
@return should_i_stop boolean
the result of the previous action. If it is true
execution should stop, but I will alert the user this arg was activated, he/she might have done a mistake
return True will break the command string from fully executing.
This type of command is a blocking command i.e. nothing happens later if
this flag was supplied
'''
if self.do_on_test_server and self.do_schema_test:
L.info("Running schema checker on test server {}@{}".format(
upgrade_config['test_user'], upgrade_config['test_host']))
app.upgrade.actions.test_with_schema()
return False
async def post_async(client):
item_store_channel = (await redis_hgetall("fortnite:store:channel"))
item_store_file, item_store_hash = await parse_item_store()
item_store_caption = "🛒 Магазин предметов в Фортнайте был обновлен. #магазин"
item_store_caption_edited = f"{item_store_caption}\n\n__Магазин предметов после оригинальной публикации " \
"сообщения был обновлен в {} по московскому времени.__"
if not item_store_channel or item_store_channel[
'hash'] != item_store_hash or config.DEVELOPER_MODE:
logging.info(
"Магазин предметов в Фортнайте был обновлен. Публикуется его изображение в канал, "
"указанный в конфигурационном файле.")
try:
assert item_store_channel['chat_id']
assert item_store_channel['message_id']
assert item_store_channel['time']
if int(time()) - int(item_store_channel['time']) < 3600:
logging.info(
"Последний пост с магазином предметов был опубликован в канал меньше, "
"чем час назад, поэтому сообщение было отредактировано обновленным магазином."
)
message = client.edit_message_media(
int(item_store_channel['chat_id']),
int(item_store_channel['message_id']),
media=InputMediaPhoto(
item_store_file,
caption=item_store_caption_edited.format(
convert_to_moscow(
datetime.utcnow()).strftime("%H:%M:%S"))))
else:
raise AssertionError
except (AssertionError, TypeError, KeyError):
message = client.send_photo(config.CHANNEL_ID,
item_store_file,
caption=item_store_caption)
await Redis.execute("HSET", "fortnite:store:channel", "hash",
item_store_hash, "chat_id", message['chat']['id'],
"message_id", message['message_id'], "time",
int(time()))
await Redis.execute("EXPIRE", "fortnite:store:channel", 86400)
"""
def action(self):
'''
@return should_i_stop boolean
the result of the previous action. If it is true
execution should stop, but I will alert the user this arg was activated, he/she might have done a mistake
return True will break the command string from fully executing.
This type of command is a blocking command i.e. nothing happens later if
this flag was supplied
'''
if self.file_name_to_mark_complete != None:
L.info(
"Marking {} as COMPLETE in upgrade tracking table {}.rcom_sql_upgrades"
.format(self.file_name_to_mark_complete,
upgrade_config['upgrade_tracking_database']))
app.upgrade.actions.mark_complete(self.file_name_to_mark_complete)
return True
return False
def register_url():
logging.info('Processing shorten request')
url = request.json.get('url')
current_user = User.get_by_email(get_jwt_identity())
if not current_user:
abort(HTTPStatus.BAD_REQUEST, INVALID_ACCOUNT)
# create short url
new_short_url = Url(user=current_user,
long_url=url,
short_id=Url.create_id())
new_short_url.save()
response = create_response({'short_url': new_short_url.get_short_url()},
SHORT_URL_CREATED, HTTPStatus.CREATED)
return response
def _internal_test_rule(self):
'''
Remember! the results of describe [table_name] are:
Field,Type,Nul,Key,Default,Extra
'''
sql = self.sql.split(';')
cursor = self._get_cursor()
cursor.execute(sql[0])
left_side_table = {
all_fields[0]: all_fields
for all_fields in cursor if all_fields[0] not in self.ignore_params
}
del cursor
cursor = self._get_cursor()
try:
cursor.execute(sql[1])
except MyExcp as err:
if err.errno == MyErrCode.ER_NO_SUCH_TABLE:
print(
"The following query failed for missing table:\n {}\n\n folder [{}] file [{}]\nFIx Schema file before running again!"
.format(sql[1], self.left_side_db, self.right_side_db))
exit(1)
else:
raise err
right_side_table = {
all_fields[0]: all_fields
for all_fields in cursor if all_fields[0] not in self.ignore_params
}
del cursor
# print(left_side_table)
# print(right_side_table)
# exit()
if (self.params[0] in ['*', 'All', 'all']
or sorted(['type', 'defaults', 'incr', 'keys']) == sorted(
self.params)): # Do a full comparison
L.info('doing full comparison')
self._do_full_comparison(left_side_table, right_side_table)
else:
L.info('doing ' + str(self.params))
self._do_partial_comparison(left_side_table, right_side_table)
return self
def perform_adaptation(tick):
info("*******************************", Fore.CYAN)
info("Starting adaptation at tick " + str(tick), Fore.CYAN)
info("*******************************", Fore.CYAN)
strategy = get_adaptation_stategy(tick)
info("Invoking strategy: " + str(strategy.__class__.__name__), Fore.CYAN)
monitor_data = strategy.monitor()
if monitor_data:
analysis_data = strategy.analyze(monitor_data)
if analysis_data:
plan_data = strategy.plan(analysis_data)
if plan_data:
strategy.execute(plan_data)
info("*******************************", Fore.CYAN)
def run_commands(commands):
'''
actually running the commands
@var should_i_stop is boolean, the result of the previous action. If it is true
execution should stop, but I will alert the user this arg was activated, he/she might have done a mistake
return True will break the command string from fully executing.
This type of command is a blocking command i.e. nothing happens later if
this flag was supplied
'''
should_i_stop = False
while commands:
if should_i_stop:
L.info("Either no files to work with where found, OR You have used a solo command like --unblock, --mark_complete or --archive.\nNo further actions will take place.\nBye Bye!")
return
command = commands.pop()
should_i_stop = command.action()
def processProblem():
logging.info("The request is: {} and {}".format(request.form['question'], request.form['answer']))
logging.info("Time elapsed: {}".format(request.form['time']))
logging.info("Problem type is: {}".format(request.form['ptype']))
if 'user' in session:
logging.info("The user is: {}".format(session['user']))
user = User.query.filter_by(nickname=session['user']).first()
post = Problem(question=request.form['question'], answer=request.form['answer'], problem_type=request.form['ptype'], time_to_complete=request.form['time'], author=user)
db.session.add(post)
db.session.commit()
return "Correct!"
def calculate_stat(ptype, query_type):
user = User.query.filter_by(nickname=session['user']).first()
logging.info("we got this far with {}".format(user))
problems = Problem.query.filter_by(author=user).all()
logging.info("now we got the problems {}".format(problems))
prob_map = {
'Addition': [int(n.time_to_complete) for n in problems if n.problem_type == 'Addition'],
'Subtraction': [int(n.time_to_complete) for n in problems if n.problem_type == 'Subtraction'],
'Multiplication': [int(n.time_to_complete) for n in problems if n.problem_type == 'Multiplication'],
'Division': [int(n.time_to_complete) for n in problems if n.problem_type == 'Division'],
'Hexadecimal': [int(n.time_to_complete) for n in problems if n.problem_type == 'Hexadecimal']
}
def statify(x): return {'Average': sum(x)/len(x), 'Quickest': min(x)}
stats = {prob_type: statify(prob_map[prob_type]) for prob_type in prob_map}
return stats[ptype][query_type]
def iterate(self):
'''
Main iteration processor bala bala
'''
print(self.folders)
print('------------------')
for sub_folder in self.folders:
# If this is actually just a sql file, do it directly. Otherwise do loop next
if self.file_postfix in sub_folder:
db = meta.extract_db_name(sub_folder)
# TOBEDELETED once verified not used self._current_file = sub_folder
self._current_path = sub_folder # NOT SURE IT IS USED!
L.info("handler is [{}] doing root [{}] file [{}] in database [{}]\n".format(self.__class__.__name__,sub_folder,sub_folder,db))
f = open(sub_folder,'r')
file_content = f.read()
f.close()
self.changeDB(db,file_content)
self.process(db,file_content,sub_folder)
continue
else:
# Loop on files and run sql
for root, dirnames, filenames in os.walk(sub_folder):
# This is where I apply the filter of the ignored file list.
if any(ignored_partial_string in root for ignored_partial_string in config.ignore_files_dirs_with):
continue
for filename in fnmatch.filter(filenames, '*'+self.file_postfix):
# print(filenames)
# print(dirnames)
# print("----------------------------------")
# print(root)
db = meta.extract_db_name(root)
# print(db+"\n")
# print(config.ignore_files_dirs_with)
self._current_path = root
L.info("handler is [{}] doing root [{}] file [{}] in database [{}]\n".format(self.__class__.__name__,root,filename,db))
f = open(root + '/' + filename,'r')
file_content = f.read()
f.close()
self.changeDB(db,file_content)
self.process(db,file_content,filename)
def process(self,db,file_content,filename):
'''
Loops on each folder, Each PROCESS call handles one rule file (*.rchk | .schk),
Calls the following actions:
- Parses each rule and run the checks.
- Each file found, a new table list object is instantiated for that file to be
processed.
- Run the tests in the TableList object
@param db is the current database name, the left side db name: string
'''
L.info("\n\nOpening db [{}] file [{}].\n".format(db,filename))
# INITIALIZE THE LIST OF TABLES OBJECT, load tbls, set the DB name with which current DB is checked.
DBTableList = (TableList(db)).loadTables()
RuleParser = (ChkFileParser(all_tables_names=DBTableList.getTablesNames(),
left_side_db=db,
right_side_db=self.getRightSideDB(filename,db),
file_content=file_content)).parseRules()
DBTableList.bindRulesToTables(RuleParser.getRuleList())
self.store_table_lists.append(DBTableList)
def do_login():
if request.method == 'GET':
return render_template('login.html')
else:
username, password, email = request.form['username'], request.form['password'], request.form['email']
does_user_exist = User.query.filter_by(nickname=username).first()
if not does_user_exist:
new_user = User(nickname=username, password=password, email=email)
db.session.add(new_user)
db.session.commit()
session['user'] = username
return render_template('main_page.html', welcome='Welcome, {}'.format(session['user']))
else:
user_pw = User.query.filter_by(nickname=username).first().password
if user_pw == password:
session['user'] = username
logging.info("setting session user")
logging.info("user is {}".format(session['user']))
return redirect(url_for('math_teasers.main_page'))
else:
return render_template('login.html', message="Invalid password, please try again")
def run_tests(table_name,table_rules):
if len(table_rules) == 0:
return EmptyErrorContainer()
# initiating an error report container
MyErrorContainer = ErrorContainer(right_side_table_name=table_name)
L.info("Checking rules for table [{table_name}]".format(table_name=table_name))
for rule in table_rules:
table_name = rule.test_rule(table_name) # Do notice, a rule might change the table name, like prefix[baba_] will add baba_ to the right side
# table name for the rest of the rules.
# same with postfix[_gaga] which would add _gaga to the end of the right side table name.
# Both rules can appear in any combination (both, or just one, in any order, in the BEGINNING)
if rule.hasErrors() == True:
MyErrorContainer.append(error_msg=rule.get_error_msg())
if rule.dontContinue() == True:
#step away from the rest of the tests
break
return MyErrorContainer
def sms():
_from = request.values.get('from', None)
text = request.values.get('text', None)
split_text = text.split('*')
name = split_text[0].capitalize()
gender = split_text[1].lower()
age = split_text[2]
preference = split_text[3].lower()
count = Member.query.filter_by(phoneNumber = _from).count()
if not count > 0:
gateway = AfricasTalkingGateway(os.environ.get('username'), os.environ.get('apikey'))
gateway.sendMessage(_from, "You have been registered for the Moringa dating session")
if gender.lower() == 'male':
member = Member(name=name, age=age, preference=preference, status='active', phoneNumber=_from, gender='Male')
db.session.add(member)
db.session.commit()
logging.info("user added {}".format(member))
elif gender.lower() == 'female':
member = Member(name=name, age=age, preference=preference, status='active', phoneNumber=_from, gender='Female')
db.session.add(member)
db.session.commit()
logging.info("user added {}".format(member))
else:
logging.info("member already exists")
resp = make_response("OK", 200 )
return resp
def action(self):
'''
@return should_i_stop boolean
the result of the previous action. If it is true
execution should stop, but I will alert the user this arg was activated, he/she might have done a mistake
return True will break the command string from fully executing.
This type of command is a blocking command i.e. nothing happens later if
this flag was supplied
'''
if self.validate_input():
if self.handle_x_files != None and int(self.handle_x_files) >0:
limit_of_files_processed = -1 * int(self.handle_x_files)
limit_info = self.handle_x_files
else: #if I do not provide the --all flag, I still run JUST the tests on all the files.
limit_of_files_processed = 0 #Invers loop, 0 means all, negative numbers I use to represent how many files more to run
limit_info = 'all'
L.info('RUNNING UPGRADE ON ACTUAL SERVER')
L.info("WILL UPGRADE with {} files".format(limit_info))
files_where_processed = app.upgrade.actions.upgrade(limit_of_files_processed)
if not files_where_processed:
return True
return False
def cleanMain(self):
'''
Just call each specific cleaner -> very procedural and simple
'''
if(len(self.what_to_handle['s']) > 0):
L.info("Start dropping Stored Procedures")
self._cleanSP()
if(len(self.what_to_handle['f']) > 0):
L.info("Start dropping Functions")
self._cleanFunctions()
if(len(self.what_to_handle['t']) > 0):
L.info("Start dropping Triggers")
self._cleanTriggers()
if(len(self.what_to_handle['w']) > 0):
L.info("Start dropping Views")
self._cleanViews()
def get_stats():
if request.method == 'GET':
logging.info("Doing a GET")
if 'user' not in session:
return redirect(url_for('do_login'))
else:
return render_template('stats.html')
elif request.method == 'POST':
if 'user' not in session:
logging.info("No user!")
return redirect(url_for('do_login'))
logging.info("Getting stats for {}".format(session['user']))
try:
user = User.query.filter_by(nickname=session['user']).first()
logging.info("we got this far with {}".format(user))
problems = Problem.query.filter_by(author=user).all()
logging.info("now we got the problems {}".format(problems))
session['num_of_problems'] = len(problems)
additions = [n for n in problems if n.problem_type == 'Addition']
times = [int(n.time_to_complete) for n in additions]
average = sum(times)/len(times)
logging.info("Your average was {} milliseconds".format(average))
return "Your {} for {} was {}".format("average time", "Addition", average)
except Exception as e:
logging.error("There is a problem finding the stats: {}".format(e))
return "We have a problem"
