def record(tid, succ, fail, timeout, elapse=None, sname=None, create_time=None):
create_time = create_time or datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
if sname is None:
statistics = Statistics(tid=tid, succ=succ, fail=fail, timeout=timeout, elapse=elapse, create_time=create_time)
return Statistics.insert(statistics)
else:
log = Log(gsid=tid, sname=sname, succ=succ, fail=fail, timeout=timeout, create_time=create_time)
Log.insert(log)
def log(ssid=None):
user = request.user
if ssid is None:
tid = request.args.get('tid')
skip = int(request.args.get('skip', 0))
limit = int(request.args.get('limit', 10))
condition = {'tid':baseorm.IdField.verify(tid)}
total = Log.count(condition)
log = list(Log.queryAll(condition, sort=[('create_time', -1), ], skip=skip, limit=limit))
result = {"appname":g.appname, "user":user, "log":log, "total":total}
else:
snapshot = q.find_one({'_id':ssid}) or {'args':'', 'kwargs':''}
log = Log.queryOne({'_id':ssid}) or {'desc':''}
txt = snapshot['txt'].encode('utf-8')
txt = pickle.loads(txt)
args = str(txt['args'])
kwargs = json.dumps(txt['kwargs'], ensure_ascii=False, sort_keys=True, indent=4).encode('utf8')
result = {"appname":g.appname, "user":user, "log":{'args':args, 'kwargs':kwargs, 'exception':log['desc'], 'tid':snapshot['tid']}}
return json.dumps({'code':1, 'desc':'success', 'res':result}, ensure_ascii=False, sort_keys=True, indent=4).encode('utf8')
def __init__(self, payment, session=None, proxy={}):
self.session = session
self.proxy = proxy
self.config = Config()
self.log = Log()
self.username = payment.get_username()
self.password = payment.get_password()
sacombank = self.get_config()
self.email_transport = EmailTransport()
self.corp_url = sacombank['corp_url']
self.captcha = CaptchaResolver()
self.debug_mode = sacombank['debug_mode']
self.total_transactions = 0
self.history = History()
self.code = GenerateCode()
self.max_attempt_login = 20
self.login_failed = 0
self.session = session
self.proxy = proxy
self.payment = payment
def load_admins(self):
try:
with open("administrators.txt", 'r') as file:
self.admins = json.load(file)
except:
Log().write_log_exception(level="error",
message="An error occurred while loading the administrators database.",
show=True, log=True)
def __init__(self, name=None, session=None, proxy={}):
self.session = session
self.proxy = proxy
self.config = Config()
self.log = Log()
self.captcha = CaptchaResolver()
section_config = self.get_section_config(name)
self.email_transport = EmailTransport()
self.home_url = section_config['home_url']
self.login_url = section_config['login_url']
self.username = section_config['username']
self.password = section_config['password']
self.debug_mode = section_config['debug_mode']
self.total_transactions = 0
self.max_attempt_login = 10
self.max_validate_captcha = 10
self.login_failed = 0
self.captcha_failed = 0
self.history = History()
self.code = GenerateCode()
def adjust_scrollable_region(self, for_keyboard=False):
try:
region = sum([int(elem[0].cget("height")) // 4.3 for elem in self.canvas_dict.values()])
if for_keyboard:
region += self.gui.touch_keyboard.height
self.canvas.configure(scrollregion=(0, 0, 0, region))
except:
Log().write_log_exception()
def __init__(self, payment, session=None, proxy={}):
self.payment = payment
self.session = session
self.proxy = {}
self.captcha = CaptchaResolver()
self.config = Config()
self.log = Log()
self.history = History()
self.code = GenerateCode()
self.email_transport = EmailTransport()
section_config = self.get_msb_config()
self.username = payment.get_username()
self.password = payment.get_password()
self.home_url = section_config['home_url']
self.login_url = section_config['login_url']
self.account_list_url = section_config['account_list_url']
self.account_info_url = section_config['account_info_url']
self.debug_mode = section_config['debug_mode']
self.total_transactions = 0
self.max_attempt_login = 10
self.max_validate_captcha = 10
self.login_failed = 0
self.captcha_failed = 0
def load_database(self):
try:
with open("files/students.txt", 'r') as file:
self.database = json.load(file)
except:
Log().write_log_exception(
level="error",
message=
"An error occurred while loading the students database.",
show=True,
log=True)
def load_assets(self):
try:
self.background_image = ResizableImage(
path_to_image="assets/background.png")
self.global_background_image = self.background_image.resize_to_tk(
width=self.width, height=self.height)
self.cm_logo_image = ResizableImage(
path_to_image="assets/cm_logo.png")
self.global_cm_logo_image = self.cm_logo_image.resize_to_tk(
width=0.2 * self.width)
self.registration_button_image = ResizableImage(
path_to_image="assets/registration_button.png")
self.registration_button_on_click_image = ResizableImage(
path_to_image="assets/registration_button_on_click.png")
self.schedule_button_image = ResizableImage(
path_to_image="assets/schedule_button.png")
self.schedule_button_on_click_image = ResizableImage(
path_to_image="assets/schedule_button_on_click.png")
self.parameters_button = ResizableImage(
path_to_image="assets/parameters_button.png")
self.parameters_button_on_click = ResizableImage(
path_to_image="assets/parameters_button_on_click.png")
self.return_button_image = ResizableImage(
path_to_image="assets/return_button.png")
self.return_button_on_click_image = ResizableImage(
path_to_image="assets/return_button_on_click.png")
self.modify_text_button_image = ResizableImage(
path_to_image="assets/modify_text.png")
self.validate_modification_button_image = ResizableImage(
path_to_image="assets/validate_modification_button.png")
self.cancel_modification_button_image = ResizableImage(
path_to_image="assets/cancel_modification_button.png")
for language in self.text_resources.keys():
self.language_assets[language] = [
ResizableImage(
path_to_image=f"assets/{language}_button.png"),
ResizableImage(
path_to_image=f"assets/{language}_button_on_click.png")
]
except:
Log().write_log_exception(
level="error",
message=
"Une erreur est survenue lors du chargement des éléments "
"visuels.",
show=True,
log=True)
def validation_button_command(self):
encoded_username = sha256(self.gui.administrator_log_in.username_entry.get().encode("utf-8")).hexdigest()
encoded_password = sha256(self.gui.administrator_log_in.password_entry.get().encode("utf-8")).hexdigest()
if not self.gui.administrator_log_in.admin_registration:
if encoded_username in self.gui.admins.keys() and encoded_password == self.gui.admins[encoded_username]:
if self.gui.administrator_log_in.itemcget(self.gui.administrator_log_in.validation_error_message_id,
"state") \
== "normal":
self.gui.administrator_log_in.itemconfigure(
self.gui.administrator_log_in.validation_error_message_id,
state="hidden")
self.gui.administrator_log_in.hide()
self.gui.parameters_menu.display()
else:
self.gui.administrator_log_in.itemconfigure(self.gui.administrator_log_in.validation_error_message_id,
state="normal")
elif self.gui.administrator_log_in.admin_registration:
try:
self.gui.admins[f"{encoded_username}"] = encoded_password
self.gui.administrator_log_in.toggle_admin_registration()
self.gui.administrator_log_in.hide()
self.gui.parameters_menu.display()
except:
Log.write_log_exception()
else:
Log().write_log_info(message="Un compte administrateur pour l'utilisateur "
f"{self.gui.administrator_log_in.username_entry.get()} a été créé.")
def close_app(self):
try:
with open("students.txt", 'w') as file:
json.dump(self.database, file, sort_keys=True, indent=4)
with open("administrators.txt", 'w') as file:
json.dump(self.admins, file, sort_keys=True, indent=4)
except:
Log().write_log_exception(level="error", message="The application didn't close properly.",
show=False, log=True)
finally:
self.root.quit()
def save(data):
if data is not None:
entity = Log(
un=data['user_name'],
th=data['target_host'],
sh=data['source_host'],
cdt=datetime.strptime(data['created_datetime'],
'%Y-%m-%d %H:%M:%S'),
au=data['api_url'],
)
db.session.add(entity)
try:
db.session.commit()
except SQLAlchemyError:
return None
return entity
def __init__(self,params):
'''
get application params
'''
self.number = params.number_of_files
self.frequency = params.frequency
self.epsilon = params.epsilon
self.strategy = params.cache_strategy
self.size = params.cache_size
self.file_list = list()
self.list_of_frequencies = params.list_of_frequencies
self.timeslot = params.timeslot
self.hits = params.hits
self.log = Log(params)
self.increase_epsilon = params.increase_epsilon
self.decrease_epsilon = params.decrease_epsilon
self.z = params.zipf_exponent
class SacombankEnterprise:
def __init__(self, payment, session=None, proxy={}):
self.session = session
self.proxy = proxy
self.config = Config()
self.log = Log()
self.username = payment.get_username()
self.password = payment.get_password()
sacombank = self.get_config()
self.email_transport = EmailTransport()
self.corp_url = sacombank['corp_url']
self.captcha = CaptchaResolver()
self.debug_mode = sacombank['debug_mode']
self.total_transactions = 0
self.history = History()
self.code = GenerateCode()
self.max_attempt_login = 20
self.login_failed = 0
self.session = session
self.proxy = proxy
self.payment = payment
def get_config(self):
config = self.config.get_section_config('SacombankEnterprise')
return config
def perform_login(self):
corp_url = self.corp_url
username = self.username
password = self.password
selenium = Selenium()
if self.session.get_driver() is None:
if self.session.get_last_driver(
) is None or self.session.get_last_driver() is 'Firefox':
driver = selenium.get_firefox_driver(self.proxy)
self.session.set_last_driver('Chrome')
else:
driver = selenium.get_firefox_driver(self.proxy)
self.session.set_last_driver('Firefox')
self.session.set_driver(driver)
try:
while True:
driver.get(corp_url)
online_banking = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH,
"//a[contains(@class,'btn-ebanking')]")))
online_banking.click()
time.sleep(5)
try:
# Click to ignore banner
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//div[@id="pbanner"]')))
element.click()
except:
print('Banner not found')
# Get username input element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located((
By.XPATH,
'//input[@id="AuthenticationFG.USER_PRINCIPAL"]')))
element.send_keys(username, Keys.ARROW_DOWN)
# Get captcha input element
captcha = self.get_captcha(driver)
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located((
By.XPATH,
'//input[@name="AuthenticationFG.VERIFICATION_CODE"]'
)))
element.send_keys(captcha)
# element.send_keys(Keys.RETURN)
# Get submit button element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH,
'//input[@id="STU_VALIDATE_CREDENTIALS"]')))
element.click()
time.sleep(5)
try:
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH,
'//span[@id="LoginHDisplay.Ra4.C1"]')))
element.click()
except:
print('Can not login')
driver.close()
return self.perform_login()
# Get password input element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH,
'//input[@name="AuthenticationFG.ACCESS_CODE"]')))
element.send_keys(password)
element.send_keys(Keys.RETURN)
time.sleep(5)
# Update Account Information
WebDriverWait(driver, 10).until(
EC.visibility_of_element_located(
(By.XPATH,
"//table[@id='HWListTable10072682']//tr/td")))
account_info = driver.find_elements_by_xpath(
"//table[@id='HWListTable10072682']//tr/td")
account_number = account_info[0].text.strip()
account_name = self.payment.get_username()
account_balance = float(
account_info[2].text.strip().replace('\n', '').replace(
'VND', '').replace('.', ''))
account = self.update_account(account_name, account_number,
account_balance,
self.payment.get_id())
# click to transaction menu
action_link = WebDriverWait(driver, 10).until(
EC.element_to_be_clickable(
(By.XPATH, "//a[contains(@name,'HREF_Ti_khon')]")))
hover_action = ActionChains(driver).move_to_element(
action_link)
hover_action.perform()
acc_link = WebDriverWait(driver, 10).until(
EC.element_to_be_clickable(
(By.XPATH,
"//a[contains(@id,'Ti-khon_Tng-quan-ti-khon')]")))
hover_trans = ActionChains(driver).move_to_element(
acc_link)
hover_trans.perform()
acc_link.click()
# time.sleep(5)
trans_link = WebDriverWait(driver, 10).until(
EC.element_to_be_clickable((
By.XPATH,
"//a[contains(@id,'HREF_PageConfigurationMaster_CACCTSW__1:AccountSummaryFG')]"
)))
trans_link.click()
try:
time.sleep(5)
WebDriverWait(driver, 5).until(
EC.visibility_of_element_located((
By.XPATH,
"//a[contains(@id,'PageConfigurationMaster_CACCTSW__1:errorlink1')]"
)))
driver.close()
self.history.set_current_update(
'sacombank_enterprise', "%d/%m/%Y")
self.session.set_driver(None)
self.log.log(
self.payment.get_name() + '-' +
self.payment.get_type() + '-' +
self.payment.get_username() + ": " +
"No transactions today", 'message')
return False
except:
print('ok')
time.sleep(1)
try:
WebDriverWait(driver, 10).until(
EC.visibility_of_element_located(
(By.XPATH,
"//table[contains(@id,'HWListTable')]//tbody"
)))
transactions = driver.find_elements_by_xpath(
"//table[contains(@id,'HWListTable')]//tbody[position() >= 0 and position() <= 10]"
)
for row in transactions:
columns = row.find_elements_by_xpath(".//tr/td")
self.save_transaction(account, columns)
self.log.update_log('Sacombank', self.username)
self.log.log(
self.payment.get_name() + '-' +
self.payment.get_type() + '-' +
self.payment.get_username() + ": " +
str(self.total_transactions) +
' transaction(s) created', 'message')
self.session.set_changing_proxy(0)
except:
self.log.log(
self.payment.get_name() + '-' +
self.payment.get_type() + '-' +
self.payment.get_username() + ": " +
"Cannot load transactions", 'error')
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(
exc_tb.tb_frame.f_code.co_filename)[1]
self.log.log(
str(exc_type) + '-' + fname + '-' +
str(exc_tb.tb_lineno), 'error')
self.session.set_changing_proxy(1)
except:
exc_info = sys.exc_info()
traceback.print_exception(*exc_info)
self.log.log(
self.payment.get_name() + '-' + self.payment.get_type() +
'-' + self.payment.get_username() + ': ' +
str(sys.exc_info()), 'debug')
driver.close()
self.history.set_current_update('sacombank_enterprise', "%d/%m/%Y")
self.session.set_driver(None)
def save_transaction(self, account, detail):
reference_number = detail[0].text
trading_date = self.convert_trading_date(detail[2].text)
account_id = account.get_account_id()
description = detail[3].text
if detail[6].text is not '':
balance = -float(detail[6].text.replace(',', '').replace(
' ', '').replace('VND', ''))
else:
balance = float(detail[7].text.replace(',', '').replace(
' ', '').replace('VND', ''))
transaction = Transaction(account_id, reference_number, trading_date,
balance, description)
if transaction.save() == 1:
self.total_transactions = self.total_transactions + 1
self.email_transport.send_transaction_email(account, transaction)
def get_captcha(self, driver):
img_data = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, "//img[@id='IMAGECAPTCHA']")))
img_file = img_data.screenshot_as_png
self.captcha.save_from_source(img_file, 'png')
captcha_text = self.captcha.resolve(True)
if re.match("^[0-9]{4}$", captcha_text):
return captcha_text
reload_captcha = WebDriverWait(driver, 10).until(
EC.visibility_of_element_located(
(By.XPATH, "//img[@id='TEXTIMAGE']")))
reload_captcha.click()
return self.get_captcha(driver)
def convert_trading_date(self, trading_date):
date = datetime.strptime(trading_date, '%d-%m-%Y')
return date.strftime('%Y-%m-%d')
def update_account(self, name, number, balance, payment_id):
account = SacombankAccount(name, number, payment_id)
account.set_balance(balance)
account.update_account()
return account
def is_debug(self):
return self.debug_mode
class VietcombankEnterprise:
def __init__(self, payment, session=None, proxy={}):
self.session = session
self.proxy = proxy
self.config = Config()
self.log = Log()
self.username = payment.get_username()
self.password = payment.get_password()
vietcombank = self.get_vietcombank_config()
self.email_transport = EmailTransport()
self.login_url = vietcombank['login_url']
self.captcha = CaptchaResolver()
self.debug_mode = vietcombank['debug_mode']
self.total_transactions = 0
self.history = History()
self.code = GenerateCode()
self.max_attempt_login = 5
self.login_failed = 0
self.session = session
self.proxy = proxy
self.payment = payment
def get_vietcombank_config(self):
vietcombank = self.config.get_section_config('VietcombankEnterprise')
return vietcombank
def perform_login(self):
login_url = self.login_url
selenium = Selenium()
if self.session.get_driver() is None:
if self.session.get_last_driver(
) is None or self.session.get_last_driver() is 'Firefox':
driver = selenium.get_firefox_driver(self.proxy)
self.session.set_last_driver('Chrome')
else:
driver = selenium.get_firefox_driver(self.proxy)
self.session.set_last_driver('Firefox')
self.session.set_driver(driver)
try:
driver.get(login_url)
if self.solve_captcha(driver) is False:
driver.close()
return False
time.sleep(5)
# Update account information
try:
# driver.execute_script("window.scrollTo(0, 800);")
WebDriverWait(driver, 10).until(
EC.visibility_of_element_located(
(By.XPATH, "//tbody[@id='dstkdd-tbody']")))
account_info = driver.find_elements_by_xpath(
"//tbody[@id='dstkdd-tbody']/tr/td")
account_name = self.payment.get_username()
account_number = account_info[0].text.strip()
account_balance = float(
account_info[3].text.strip().replace(' VND',
'').replace(
',', ''))
account = self.update_account(account_name, account_number,
account_balance,
self.payment.get_id())
WebDriverWait(driver, 10).until(
EC.presence_of_element_located((
By.XPATH,
"//a[contains(@href,'/IbankingCorp/Accounts/TransactionDetail.aspx')]"
)))
reference_links = driver.find_elements_by_xpath(
"//a[contains(@href,'/IbankingCorp/Accounts/TransactionDetail.aspx')]"
)
reference_links[2].click()
#view_link = WebDriverWait(driver, 10).until(
# EC.presence_of_element_located(
# (By.XPATH, "//a[contains(@id,'bdsdList-tab')]"))
#)
#driver.execute_script("arguments[0].scrollIntoView();", view_link)
#time.sleep(5)
#view_link.click()
tran_by_date = WebDriverWait(driver, 10).until(
EC.element_to_be_clickable(
(By.XPATH, "//a[contains(@id,'TransByDate')]")))
#tran_by_date.click()
driver.execute_script("arguments[0].click();",
tran_by_date)
time.sleep(5)
WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, "//table[@id='tbTranHis']")))
trans_foot = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, "//div[@id='tbTranHis-footer']")))
driver.execute_script("arguments[0].scrollIntoView();",
trans_foot)
transactions = driver.find_elements_by_xpath(
"//table[@id='tbTranHis']//tbody/tr[position() >= 0 and position() <= 25]"
)
for row in transactions:
columns = row.find_elements_by_xpath("td")
self.save_transaction(account, columns)
self.log.update_log('Vietcombank', self.username)
self.log.log(
self.payment.get_name() + '-' +
self.payment.get_type() + '-' +
self.payment.get_username() + ": " +
str(self.total_transactions) +
' transaction(s) created', 'message')
self.session.set_changing_proxy(0)
except:
self.log.log(
self.payment.get_name() + '-' +
self.payment.get_type() + '-' +
self.payment.get_username() + ": " +
"Cannot load transactions", 'error')
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(
exc_tb.tb_frame.f_code.co_filename)[1]
self.log.log(
str(exc_type) + '-' + fname + '-' +
str(exc_tb.tb_lineno), 'error')
self.session.set_changing_proxy(1)
except:
exc_info = sys.exc_info()
traceback.print_exception(*exc_info)
self.log.log(
self.payment.get_name() + '-' + self.payment.get_type() +
'-' + self.payment.get_username() + ': ' +
str(sys.exc_info()), 'debug')
driver.close()
self.history.set_current_update('vietcombank_enterprise',
"%d/%m/%Y")
self.session.set_driver(None)
def save_transaction(self, account, detail):
trading_date = self.convert_trading_date(detail[0].text)
reference_number = detail[1].text.replace('Số tham chiếu: ', '')
account_id = account.get_account_id()
if detail[2].text is not '':
balance = -float(detail[2].text.replace(',', '').replace(
' ', '').replace('VND', ''))
else:
balance = float(detail[3].text.replace(',', '').replace(
' ', '').replace('VND', ''))
description = detail[4].text
transaction = Transaction(account_id, reference_number, trading_date,
balance, description)
if transaction.save() == 1:
self.total_transactions = self.total_transactions + 1
self.email_transport.send_transaction_email(account, transaction)
def solve_captcha(self, driver):
img_data = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH,
"//img[@id='ctl00_Content_Login_Captcha_Captcha']")))
img_file = img_data.screenshot_as_png
self.captcha.save_from_source(img_file, 'png')
captcha_text = self.captcha.resolve(True)
if re.match("^[a-zA-Z0-9]{6}$", captcha_text):
captcha = captcha_text
username = self.username
password = self.password
# Get username input element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="ctl00$Content$Login$TenTC"]')))
element.send_keys(username)
# Get password input element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="ctl00$Content$Login$MatKH"]')))
element.send_keys(password)
# Get captcha input element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="ctl00$Content$Login$ImgStr"]')))
element.send_keys(captcha)
# element.send_keys(Keys.RETURN)
# Get submit button element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@id="ctl00_Content_Login_LoginBtn"]')))
element.click()
# click to account menu
try:
list_account = WebDriverWait(driver, 5).until(
EC.presence_of_element_located(
(By.XPATH,
"//a[contains(@href,'Accounts/ListAccounts.aspx')]")))
time.sleep(5)
list_account.click()
self.login_failed = 0
return True
except:
self.login_failed += 1
if self.login_failed > self.max_attempt_login:
self.history.set_current_update('vietcombank_enterprise',
"%d/%m/%Y")
self.session.set_driver(None)
return False
driver.back()
return self.solve_captcha(driver)
driver.refresh()
return self.solve_captcha(driver)
def convert_trading_date(self, trading_date):
date = datetime.strptime(trading_date, '%Y-%m-%d')
return date.strftime('%Y-%m-%d')
def update_account(self, name, number, balance, payment_id):
account = VietcombankAccount(name, number, payment_id)
account.set_balance(balance)
account.update_account()
return account
def get_config(self, name=None):
if name is None:
name = 'Vietcombank'
techcombank = self.config.get_section_config(name)
return techcombank
def is_debug(self):
return self.debug_mode
from model.log import Log
from view.gui import GUI
try:
gui = GUI()
gui.start_menu.display()
gui.root.mainloop()
except:
Log().write_log_exception(level="error",
message="Un problème est survenu lors de l'exécution de l'application.",
show=True,
log=False)
class Msb:
def __init__(self, payment, session=None, proxy={}):
self.payment = payment
self.session = session
self.proxy = {}
self.captcha = CaptchaResolver()
self.config = Config()
self.log = Log()
self.history = History()
self.code = GenerateCode()
self.email_transport = EmailTransport()
section_config = self.get_msb_config()
self.username = payment.get_username()
self.password = payment.get_password()
self.home_url = section_config['home_url']
self.login_url = section_config['login_url']
self.account_list_url = section_config['account_list_url']
self.account_info_url = section_config['account_info_url']
self.debug_mode = section_config['debug_mode']
self.total_transactions = 0
self.max_attempt_login = 10
self.max_validate_captcha = 10
self.login_failed = 0
self.captcha_failed = 0
def get_msb_config(self):
msb = self.config.get_section_config('Msb')
return msb
def is_logged_in(self):
session_requests = self.session
token = session_requests.get_token()
if token is None:
return 0
try:
account_list_url = self.account_list_url
payload = {
'acctType': "'CA','SA','LN'",
'status': "'ACTV','DORM','MATU'",
'tokenNo': token,
'lang': "vi_VN",
}
list_post = session_requests.post(account_list_url, payload)
response = list_post.json()
if response['status'] == '200':
return 1
return 0
except Exception as e:
if self.debug_mode == 'true':
self.log.log(str(e), 'debug')
return 0
def is_debug(self):
return self.debug_mode
def perform_login(self):
home_url = self.home_url
login_url = self.login_url
username = self.username
password = self.password
session_requests = self.session
if self.is_logged_in() == 0:
session_requests.set_tree(None)
session_requests.init_session(self.proxy)
session_requests.set_changing_proxy(1)
result = session_requests.get(login_url)
tree = html.fromstring(result.text)
window_location = tree.xpath("//script/text()")[0]
window_location = self.replace_all(window_location, {
"window.location.href = '": "",
"';": ""
})
login_redirect_url = str(home_url + window_location.strip())
result = session_requests.get(login_redirect_url,
dict(referer=login_redirect_url))
tree = html.fromstring(result.text)
window_location = tree.xpath("//script/text()")[0]
window_location = self.replace_all(window_location, {
"window.location.href = '": "",
"';": ""
})
real_login_redirect_url = str(home_url + window_location.strip())
result = session_requests.get(real_login_redirect_url,
dict(referer=login_redirect_url))
tree = html.fromstring(result.content)
dse_session_id = tree.xpath(
"//input[@name='dse_sessionId']/@value")[0]
img_data = session_requests.get(
home_url + '/IBSRetail/servlet/ImageServlet').content
self.captcha.save_from_source(img_data)
captcha_text = self.captcha.resolve(True)
if self.validate_captcha(captcha_text) == 0:
if self.captcha_failed < self.max_validate_captcha:
self.captcha_failed = self.captcha_failed + 1
return self.perform_login()
else:
if self.debug_mode == 'true':
self.log.log(
'Can\'t validate captcha after ' +
str(self.captcha_failed) + ' times', 'debug')
self.captcha_failed = 0
return 0
payload = {
'dse_sessionId': dse_session_id,
'dse_applicationId': -1,
'dse_pageId': 2,
'dse_operationName': 'retailUserLoginProc',
'dse_errorPage': 'index.jsp',
'dse_processorState': 'initial',
'dse_nextEventName': 'start',
'orderId': '',
'_userNameEncode': username,
'_userName': username,
'_password': password,
'_verifyCode': captcha_text
}
# Perform login
login_post = session_requests.post(login_url + '/Request', payload)
tree = html.fromstring(login_post.text)
window_location = tree.xpath("//script/text()")[0]
window_location = self.replace_all(window_location, {
"window.location.href = '": "",
"';": ""
})
redirect_url = str(home_url + window_location.strip())
result = session_requests.get(redirect_url)
tree = html.fromstring(result.content)
username = tree.xpath("//p[@class='username']/text()")
if len(username) > 0:
token = self.get_token_from_string(str(result.content))
session_requests.set_token(token)
session_requests.set_changing_proxy(0)
self.login_failed = 0
else:
self.login_failed = self.login_failed + 1
if self.login_failed >= self.max_attempt_login:
if self.debug_mode == 'true':
self.log.log(
"Can not login Msb:" + self.payment.get_username +
" with " + str(self.max_attempt_login) +
" attempts", 'error')
return 0
return self.perform_login()
else:
session_requests.set_changing_proxy(0)
if self.debug_mode == 'true':
self.log.log(
"Login Msb:" + self.payment.get_username +
" successfully by using old session", 'debug')
token = session_requests.get_token()
if token is None:
return 0
# with open('msb.html', 'w') as f:
# f.write(str(result.content))
self.update_transactions(session_requests, token)
def update_transactions(self, session_requests, token):
account_list_url = self.account_list_url
payload = {
'acctType': "'CA','SA','LN'",
'status': "'ACTV','DORM','MATU'",
'tokenNo': token,
'lang': "vi_VN",
}
list_post = session_requests.post(account_list_url, payload)
try:
response = list_post.json()
except:
response = {'status': 401}
if response['status'] == '200':
accounts = response['data']
for account in accounts:
account_name = account['acctName']
account_number = account['acctNo']
account_balance = account['availableBalance']
msb_account = MsbAccount(account_name, account_number,
self.payment.get_id())
msb_account.set_balance(account_balance)
msb_account.update_account()
account_info_url = self.account_info_url
current_date = self.history.get_current_update('maritimebank')
payload = {
'acctNo': msb_account.get_number(),
'page': 1,
'tokenNo': token,
'lang': "vi_VN",
'fromDate': current_date.rstrip('\r\n'),
'toDate': time.strftime("%Y-%m-%d")
}
account_post = session_requests.post(account_info_url, payload)
response = account_post.json()
if response['status'] == '200':
histories = response['data']['history']
for history in histories:
self.save_transaction(msb_account, history)
self.log.update_log('Maritimebank', self.username)
self.history.set_current_update('maritimebank', "%Y-%m-%d")
self.log.log(
"Msb " + self.payment.get_type() + self.payment.get_username() +
": " + str(self.total_transactions) + ' transaction(s) created',
'message')
def save_transaction(self, account, history):
trading_date = self.convert_trading_date(history['transferDate'])
trading_time = history['transferTime']
description = history['remark']
if description is None:
description = 'None'
account_id = account.get_account_id()
balance = float(history['amount'])
if history['dcSign'] == 'D':
balance = -balance
reference_number = self.code.generate_code(description +
history['transferDate'])
created_at = trading_date + ' ' + trading_time
transaction = Transaction(account_id, reference_number, trading_date,
balance, description, created_at)
if transaction.save() == 1:
self.total_transactions = self.total_transactions + 1
self.email_transport.send_transaction_email(account, transaction)
def replace_all(self, text, conditions):
for i, j in conditions.items():
text = text.replace(i, j)
return text
def validate_captcha(self, captcha):
if re.match("^[a-zA-Z0-9]{4}$", captcha):
return 1
return 0
def convert_trading_date(self, trading_date):
date = datetime.strptime(trading_date, '%d/%m/%Y')
return date.strftime('%Y-%m-%d')
def get_token_from_string(self, string):
token = re.search(
"\'[a-zA-Z0-9]{8}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{12}",
string)
return token[0].replace("'", "")
def compare_logging_calls(head_commit_db, file_diff, logging_calls_in_parent, logging_calls_in_head):
file_mapping_list = []
file_added_logging_loc = 0
file_deleted_logging_loc = 0
file_updated_logging_loc = 0
# Add index to make each call unique.
logging_calls_str_parent = \
[str(index) + '#' + etree.tostring(call).decode('utf-8') for index, call in
enumerate(logging_calls_in_parent)]
logging_calls_str_head = \
[str(index) + '#' + etree.tostring(call).decode('utf-8') for index, call in
enumerate(logging_calls_in_head)]
for call_str_in_parent in logging_calls_str_parent:
for call_str_in_head in logging_calls_str_head:
distance_ratio = Levenshtein.ratio(xml_analyzer.transform_xml_str_to_code(call_str_in_parent),
xml_analyzer.transform_xml_str_to_code(call_str_in_head))
if distance_ratio > config.LEVENSHTEIN_RATIO_THRESHOLD:
is_parent_in_mapping = False
# Check mapping list
for mapping in file_mapping_list:
call_mapping_parent = mapping[0]
mapping_ratio = mapping[2]
if call_str_in_parent == call_mapping_parent:
is_parent_in_mapping = True
if distance_ratio > mapping_ratio:
mapping[1] = call_str_in_head
mapping[2] = Levenshtein.ratio(_get_code_text_from_compare(call_str_in_parent),
_get_code_text_from_compare(call_str_in_head))
if not is_parent_in_mapping:
is_head_in_mapping = False
for mapping in file_mapping_list:
call_mapping_head = mapping[1]
mapping_ratio = mapping[2]
if call_str_in_head == call_mapping_head:
is_head_in_mapping = True
if distance_ratio > mapping_ratio:
mapping[0] = call_str_in_parent
mapping[2] = Levenshtein.ratio(_get_code_text_from_compare(call_str_in_parent),
_get_code_text_from_compare(call_str_in_head))
if not is_head_in_mapping:
file_mapping_list.append([call_str_in_parent, call_str_in_head, distance_ratio])
file_calls_mapping_in_parent = [mapping[0] for mapping in file_mapping_list]
file_calls_mapping_in_head = [mapping[1] for mapping in file_mapping_list]
deleted_logging_calls_str = list(set(logging_calls_str_parent) - set(file_calls_mapping_in_parent))
added_logging_calls_str = list(set(logging_calls_str_head) - set(file_calls_mapping_in_head))
file_deleted_logging_loc += len(deleted_logging_calls_str)
file_added_logging_loc += len(added_logging_calls_str)
if not head_commit_db.is_merge_commit:
for call_str in deleted_logging_calls_str:
call_xml = etree.fromstring(_get_code_xml_str_from_compare(call_str))
model_operator.save_logs_of_method_xml_str_if_needed(head_commit_db, file_diff.a_path, None,
LogChangeType.LOG_DELETED, call_xml, None)
for call_str in added_logging_calls_str:
call_xml = etree.fromstring(_get_code_xml_str_from_compare(call_str))
model_operator.save_logs_of_method_xml_str_if_needed(head_commit_db, file_diff.a_path, None,
LogChangeType.LOG_ADDED, call_xml, None)
for mapping in file_mapping_list:
change_from = _get_code_text_from_compare(mapping[0])
change_to = _get_code_text_from_compare(mapping[1])
if change_from != change_to:
# True Update
file_updated_logging_loc += 1
if not head_commit_db.is_merge_commit:
log = Log.create(commit=head_commit_db, file_path=file_diff.b_path, embed_method='NILL',
change_type=LogChangeType.LOG_UPDATED, content=change_to,
content_update_from=change_from)
log.save()
return file_added_logging_loc, file_deleted_logging_loc, file_updated_logging_loc
class Vietcombank:
def __init__(self, payment, session=None, proxy={}):
self.session = session
self.proxy = proxy
self.config = Config()
self.log = Log()
self.username = payment.get_username()
self.password = payment.get_password()
vietcombank = self.get_vietcombank_config()
self.email_transport = EmailTransport()
self.login_url = vietcombank['login_url']
self.captcha = CaptchaResolver()
self.debug_mode = vietcombank['debug_mode']
self.total_transactions = 0
self.history = History()
self.code = GenerateCode()
self.max_attempt_login = 20
self.login_failed = 0
self.session = session
self.proxy = proxy
self.payment = payment
def get_vietcombank_config(self):
vietcombank = self.config.get_section_config('Vietcombank')
return vietcombank
def perform_login(self):
login_url = self.login_url
username = self.username
password = self.password
selenium = Selenium()
if self.session.get_driver() is None:
if self.session.get_last_driver() is None or self.session.get_last_driver() is 'Firefox':
driver = selenium.get_firefox_driver(self.proxy)
self.session.set_last_driver('Chrome')
else:
driver = selenium.get_firefox_driver(self.proxy)
self.session.set_last_driver('Firefox')
self.session.set_driver(driver)
try:
driver.get(login_url)
# Get username input element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="username"]'))
)
element.send_keys(username)
# Get password input element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="pass"]'))
)
element.send_keys(password)
while True:
captcha = self.get_captcha(driver)
# Get captcha input element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="captcha"]'))
)
element.send_keys(captcha)
# element.send_keys(Keys.RETURN)
# Get submit button element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//button[@id="btnLogin"]'))
)
element.click()
time.sleep(5)
# click to account menu
try:
account_link = WebDriverWait(driver, 10).until(
EC.element_to_be_clickable(
(By.XPATH,
"//a[contains(@class,'has-link-arrow tk')]//div[contains(@class,'item-link-arrow')]"))
)
account_link.click()
time.sleep(5)
self.login_failed = 0
break
except:
self.login_failed += 1
if self.login_failed > self.max_attempt_login:
driver.close()
self.history.set_current_update('vietcombank', "%d/%m/%Y")
self.session.set_driver(None)
# Update account information
try:
driver.execute_script("window.scrollTo(0, 800);")
time.sleep(5)
search_button = WebDriverWait(driver, 10).until(
EC.element_to_be_clickable(
(By.XPATH,
"//a[contains(@class,'ubtn ubg-primary ubtn-md ripple')]/span[contains(text(),'Tìm kiếm')]"))
)
search_button.click()
WebDriverWait(driver, 15).until(
EC.visibility_of_element_located(
(By.XPATH, "//form[@id='ChiTietTaiKhoan']"))
)
info = driver.find_element_by_xpath(
"//div[@class='list-info']")
number = info.find_element_by_xpath("//select/option").get_attribute('value')
name = info.find_elements_by_xpath(
"//div[contains(@class,'list-info-txt-main')]")[1].text
balance = float(info.find_elements_by_xpath(
"//div[contains(@class,'list-info-txt-main')]")[2].text.replace(
',', '').replace(' VND', ''))
account = self.update_account(name, number, balance, self.payment.get_id())
transactions = driver.find_elements_by_xpath(
"//div[@id='toanbo']//div[contains(@class,'list-info-item')]")
for row in transactions:
columns = row.find_elements_by_xpath(".//div[contains(@class,'td-xs')]")
self.save_transaction(account, columns)
self.log.update_log('Vietcombank', self.username)
self.log.log("Vcb " + self.payment.get_type() + self.payment.get_username() + ": " + str(
self.total_transactions) + ' transaction(s) created', 'message')
self.session.set_changing_proxy(0)
except:
self.log.log(
"Vcb " + self.payment.get_type() + self.payment.get_username() + ": " + "Cannot load transactions",
'error')
self.log.log(str(sys.exc_info()), 'error')
self.session.set_changing_proxy(1)
except:
exc_info = sys.exc_info()
traceback.print_exception(*exc_info)
self.log.log(str(sys.exc_info()), 'debug')
driver.close()
self.history.set_current_update('vietcombank', "%d/%m/%Y")
self.session.set_driver(None)
def save_transaction(self, account, detail):
trading_date = self.convert_trading_date(
detail[0].find_element_by_xpath("div[contains(@class,'list-info-txt-sub')]").text)
description = detail[0].find_element_by_xpath("div[contains(@class,'list-info-txt-main')]").text
account_id = account.get_account_id()
reference_number = detail[1].find_element_by_xpath("div[contains(@class,'list-info-txt-sub')]").text.replace(
'Số tham chiếu: ', '')
balance = float(
detail[1].find_element_by_xpath("div[contains(@class,'list-info-txt-main')]").text.replace(',', '').replace(
' ', ''))
transaction = Transaction(account_id, reference_number, trading_date, balance, description)
print(reference_number)
if transaction.save() == 1:
self.total_transactions = self.total_transactions + 1
self.email_transport.send_transaction_email(account, transaction)
def get_captcha(self, driver):
img_data = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, "//div[contains(@class,'captcha')]//img"))
)
img_file = img_data.screenshot_as_png
self.captcha.save_from_source(img_file, 'png')
captcha_text = self.captcha.resolve(True)
if re.match("^[a-zA-Z0-9]{5}$", captcha_text):
return captcha_text
ic_reload = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, "//img[contains(@src,'ic_reload')]"))
)
ic_reload.click()
return self.get_captcha(driver)
def convert_trading_date(self, trading_date):
date = datetime.strptime(trading_date, '%d/%m/%Y')
return date.strftime('%Y-%m-%d')
def update_account(self, name, number, balance, payment_id):
account = VietcombankAccount(name, number, payment_id)
account.set_balance(balance)
account.update_account()
return account
def get_config(self, name=None):
if name is None:
name = 'Vietcombank'
vietcombank = self.config.get_section_config(name)
return vietcombank
def is_debug(self):
return self.debug_mode
def __init__(self, name, connector, delay):
threading.Thread.__init__(self)
self.name = name
self.connector = connector
self.log = Log()
self.delay = delay
class Main(object):
'''
Principal controller of the application
'''
def __init__(self,params):
'''
get application params
'''
self.number = params.number_of_files
self.frequency = params.frequency
self.epsilon = params.epsilon
self.strategy = params.cache_strategy
self.size = params.cache_size
self.file_list = list()
self.list_of_frequencies = params.list_of_frequencies
self.timeslot = params.timeslot
self.hits = params.hits
self.log = Log(params)
self.increase_epsilon = params.increase_epsilon
self.decrease_epsilon = params.decrease_epsilon
self.z = params.zipf_exponent
def run(self):
cache = Cache(self.size,self.strategy)
self.gen_frequencies()
self.gen_file_list()
for timeslot in range(self.timeslot):
self.go_time()
self.apply_epsilon()
for hits in range(self.hits):
choice = self.select_file()
response = cache.append_item(choice)
if(response):
self.log.insert_log(response,timeslot+1,'hit',cache.get_file_status())
else:
self.log.insert_log(choice,timeslot+1,'miss',cache.get_file_status())
self.log.end_write()
def gen_frequencies(self):
if not self.list_of_frequencies and self.frequency == 'PERSONAL':
print "You need a list of preferences"
elif self.frequency != 'PERSONAL' and not not self.list_of_frequencies:
print "You need to set preference to PERSONAL"
else:
if not self.list_of_frequencies:
freq = Frequency(self.number,self.frequency,self.z)
else:
freq = Frequency(self.number,self.frequency,self.z,self.list_of_frequencies)
freq.gen_frequency()
self.list_of_frequencies = freq.frequency_
def gen_file_list(self):
for i in range(self.number):
self.file_list.append(File(i,self.list_of_frequencies[i]))
def select_file(self):
limit = uniform(0,1)
acum = 0
helper_list = deepcopy(self.file_list)
while acum <= limit:
item = choice(helper_list)
acum = item.frequency + acum
helper_list.remove(item)
for file_ in self.file_list:
if file_.name == item.name:
return file_
def go_time(self):
for file_ in self.file_list:
file_.usage = file_.usage + 1
def apply_epsilon(self):
if not not self.epsilon:
if len(self.epsilon) > 1:
if self.is_not_negative_list():
for i in range(len(self.file_list)):
self.file_list[i].frequency = self.file_list[i].frequency + self.epsilon[i]
elif not not self.increase_epsilon and not not self.decrease_epsilon:
if self.is_not_negative_increase():
for file_ in self.file_list:
if file_.name in self.increase_epsilon:
file_.frequency = file_.frequency + self.epsilon[0]
else:
file_.frequency = file_.frequency - self.epsilon[0]
else:
length = len(self.file_list)
if length % 2 == 0:
if self.is_not_negative_dual(self.epsilon[0],self.epsilon[0],length/2):
for file_ in self.file_list[:length/2]:
file_.frequency = file_.frequency - self.epsilon[0]
for file_ in self.file_list[length/2:]:
file_.frequency = file_.frequency + self.epsilon[0]
else:
majority = int(length / 2) + 1
minority = majority - 1
divided = (self.epsilon[0]*minority)/majority
if self.is_not_negative_dual(divided,self.epsilon[0],majority):
for file_ in self.file_list[:majority]:
file_.frequency = file_.frequency - divided
for file_ in self.file_list[majority:]:
file_.frequency = file_.frequency + self.epsilon[0]
def is_not_negative_list(self):
counter = 0
for i in range(len(self.file_list)):
counter = counter + self.file_list[i].frequency + self.epsilon[i]
if self.file_list[i].frequency + self.epsilon[i] < 0:
return False
if counter == 1:
return True
else:
return False
def is_not_negative_dual(self,minus,max_,cut):
counter = 0
for file_ in self.file_list[:cut]:
counter = counter + file_.frequency - minus
if file_.frequency - minus < 0:
return False
for file_ in self.file_list[cut:]:
counter = counter + file_.frequency + max_
if file_.frequency + max_ < 0:
return False
if counter == 1:
return True
else:
return False
def is_not_negative_increase(self):
counter = 0
for file_ in self.file_list:
if file_.name in self.increase_epsilon:
counter = counter + file_.frequency + self.epsilon[0]
if file_.frequency + self.epsilon[0] < 0:
return False
else:
counter = counter + file_.frequency - self.epsilon[0]
if file_.frequency - self.epsilon[0] < 0:
return False
if counter == 1:
return True
else:
return False
class TechcombankEnterprise:
def __init__(self, payment, session=None, proxy={}):
self.session = session
self.proxy = proxy
self.payment = payment
self.config = Config()
self.log = Log()
techcombank = self.get_techcombank_config()
self.email_transport = EmailTransport()
self.login_url = techcombank['login_url']
self.username = payment.get_username()
self.password = payment.get_password()
self.debug_mode = techcombank['debug_mode']
self.total_transactions = 0
self.history = History()
self.code = GenerateCode()
self.max_attempt_login = 20
self.login_failed = 0
def perform_login(self):
login_url = self.login_url
username = self.username
password = self.password
selenium = Selenium()
if self.session.get_driver() is None:
if self.session.get_last_driver(
) is None or self.session.get_last_driver() is 'Firefox':
driver = selenium.get_firefox_driver(self.proxy)
self.session.set_last_driver('Chrome')
else:
driver = selenium.get_firefox_driver(self.proxy)
self.session.set_last_driver('Firefox')
self.session.set_driver(driver)
try:
while 1:
driver.get(login_url)
window_before = driver.window_handles[0]
# Get username input element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="signOnName"]')))
element.send_keys(username)
time.sleep(2)
# element.send_keys(Keys.RETURN)
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="password"]')))
# Get password input element
element.send_keys(password)
time.sleep(2)
# element.send_keys(Keys.RETURN)
# Get submit button element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@type="submit"]')))
element.click()
try:
WebDriverWait(driver, 10).until(
EC.visibility_of_element_located(
(By.XPATH,
"//div[contains(@id,'pane__FRAME')]")))
self.login_failed = 0
break
except:
self.login_failed += 1
if self.login_failed > self.max_attempt_login:
driver.close()
self.history.set_current_update(
'techcombank_enterprise', "%d/%m/%Y")
self.session.set_driver(None)
# Update account information
try:
search = WebDriverWait(driver, 30).until(
EC.visibility_of_element_located(
(By.XPATH,
"//img[contains(@src,'drilldown/View.png')]")))
info = driver.find_elements_by_xpath(
"//table[contains(@id,'datadisplay_ACCOUNT')]//tr/td")
number = info[0].text.split('-')[0].strip()
name = info[1].text
balance = float(info[3].text.replace(',', ''))
account = self.update_account(name, number, balance,
self.payment.get_id())
search.click()
window_after = driver.window_handles[1]
driver.switch_to_window(window_after)
WebDriverWait(driver, 60).until(
EC.visibility_of_element_located(
(By.XPATH,
"//table[contains(@id,'datadisplay_DATA')]")))
transactions = driver.find_elements_by_xpath(
"//table[contains(@id,'datadisplay_DATA')]//tr")
for row in transactions:
columns = row.find_elements_by_xpath("td")
self.save_transaction(account, columns)
self.log.update_log('Techcombank', self.username)
self.log.log(
self.payment.get_name() + '-' +
self.payment.get_type() + '-' +
self.payment.get_username() + ": " +
str(self.total_transactions) +
' transaction(s) created', 'message')
self.session.set_changing_proxy(0)
except:
self.log.log(
self.payment.get_name() + '-' +
self.payment.get_type() + '-' +
self.payment.get_username() + ": " +
"Cannot load transactions", 'error')
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(
exc_tb.tb_frame.f_code.co_filename)[1]
self.log.log(
str(exc_type) + '-' + fname + '-' +
str(exc_tb.tb_lineno), 'error')
self.session.set_changing_proxy(1)
except:
exc_info = sys.exc_info()
traceback.print_exception(*exc_info)
self.log.log(str(sys.exc_info()), 'debug')
driver.quit()
self.history.set_current_update('techcombank_enterprise',
"%d/%m/%Y")
self.session.set_driver(None)
def save_transaction(self, account, detail):
trading_date = self.convert_trading_date(detail[0].text)
reference_number = detail[1].text
description = detail[3].text
account_id = account.get_account_id()
if detail[4].text is not '':
balance = float(detail[4].text.replace(',', '').replace(' ', ''))
else:
balance = float(detail[5].text.replace(',', '').replace(' ', ''))
transaction = Transaction(account_id, reference_number, trading_date,
balance, description)
if transaction.save() == 1:
self.total_transactions = self.total_transactions + 1
self.email_transport.send_transaction_email(account, transaction)
def convert_trading_date(self, trading_date):
date = datetime.strptime(trading_date, '%d/%m/%Y')
return date.strftime('%Y-%m-%d')
def update_account(self, name, number, balance, payment_id):
account = TechcombankAccount(name, number, payment_id)
account.set_balance(balance)
account.update_account()
return account
def get_techcombank_config(self):
techcombank = self.config.get_section_config('TechcombankEnterprise')
return techcombank
def is_debug(self):
return self.debug_mode
class KlikbcaEnterprise:
def __init__(self, payment, session=None, proxy={}):
self.payment = payment
self.session = session
self.proxy = proxy
self.config = Config()
self.log = Log()
self.code = GenerateCode()
self.email_transport = EmailTransport()
section_config = self.get_section_config()
self.dashboard_url = section_config['dashboard_url']
self.balance_url = section_config['balance_url']
self.account_info_url = section_config['account_info_url']
self.account_statement_url = section_config['account_statement_url']
self.username = payment.get_username()
self.password = payment.get_password()
self.debug_mode = section_config['debug_mode']
self.total_transactions = 0
self.file = File()
def get_section_config(self):
section_config = self.config.get_section_config('KlikbcaEnterprise')
return section_config
def is_logged(self):
session_requests = self.session
account_info_url = self.account_info_url
tree = session_requests.get_tree()
if tree is None:
return 0
try:
result = session_requests.get(account_info_url)
tree = html.fromstring(result.content)
account_info_text = tree.xpath(
"//a[@href='menu_bar.htm']//b/text()")
if "Account Information" in account_info_text:
return 1
return 0
except:
return 0
def is_debug(self):
return self.debug_mode
def perform_login(self):
dashboard_url = self.dashboard_url
username = self.username
password = self.password
session_requests = self.session
if self.is_logged() == 0:
session_requests.set_tree(None)
session_requests.init_session(self.proxy)
session_requests.set_changing_proxy(1)
payload = {
'value(actions)': 'login',
'value(user_id)': username,
'value(user_ip)': self.proxy['ip'],
'value(browser_info)': session_requests.get_user_agent(),
'value(mobile)': 'false',
'value(pswd)': password,
'value(Submit)': 'LOGIN',
}
# Perform login
try:
login_post = session_requests.post(dashboard_url, payload)
tree = html.fromstring(login_post.content)
menu = tree.xpath("//frame[@name='menu']")
if len(menu) > 0:
session_requests.set_tree(tree)
session_requests.set_changing_proxy(0)
except:
self.log.log(str(sys.exc_info()), 'debug')
session_requests.set_changing_proxy(1)
else:
session_requests.set_changing_proxy(0)
if self.debug_mode == 'true':
self.log.log(
'Login ' + self.name +
' successfully by using old session', 'debug')
tree = session_requests.get_tree()
if tree is None:
return 0
self.update_transactions(session_requests)
def update_transactions(self, session_requests):
balance_url = self.balance_url
account_statement_url = self.account_statement_url
current_date = self.get_current_update().split('/')
now = datetime.now()
payload = {
'value(D1)': 0,
'value(r1)': 1,
'value(startDt)': str(current_date[0]),
'value(startMt)': str(current_date[1]),
'value(startYr)': str(current_date[2]),
'value(endDt)': str(now.day),
'value(endMt)': str(now.month),
'value(endYr)': str(now.year),
'value(fDt)': '',
'value(tDt)': '',
'value(submit1)': 'View Account Statement',
}
statement_post = session_requests.post(account_statement_url, payload)
tree = html.fromstring(statement_post.content)
account_number = None
account_name = None
account_number_row = \
tree.xpath("//table[@bordercolor='#f0f0f0'][@width='90%']//tr[@bgcolor='#e0e0e0']/td/font/text()")
if len(account_number_row) > 0:
account_number = account_number_row[2]
account_name_row = \
tree.xpath("//table[@bordercolor='#f0f0f0'][@width='90%']//tr[@bgcolor='#f0f0f0']/td/font/text()")
if len(account_name_row) > 0:
account_name = account_name_row[2]
account = KlikbcaAccount(account_name, account_number,
self.payment.get_id())
if account_number is not None and 'Period' not in account_number and 'Currency' not in account_name:
balance_get = session_requests.post(
balance_url, dict(referer=self.account_info_url))
acc_tree = html.fromstring(balance_get.content)
available_balance = acc_tree.xpath(
"//table[@width='590']//tr/td/div[@align='right']/font/text()"
)[0]
available_balance = float(available_balance.strip().replace(
',', ''))
account.set_balance(available_balance)
account.update_account()
transactions = tree.xpath(
"//table[@bordercolor='#ffffff'][@width='100%']//tr")
if len(transactions) > 0:
del transactions[0]
for row in transactions:
columns = row.xpath("td")
detail = []
for column in columns:
value = column.xpath("div/font")
if len(value) > 0:
value = value[0]
value = value.text_content()
detail.append(value.strip())
self.save_transaction(account, detail)
self.set_current_update()
self.log.update_log('Klikbca', self.username)
self.log.log(
str(self.total_transactions) + ' ' + self.name +
' transaction(s) created', 'message')
def save_transaction(self, account, detail):
now = datetime.now()
year = str(now.year)
if detail[0] == 'PEND':
detail[0] = str(now.day) + '/' + str(now.month)
trading_date = self.convert_trading_date(detail[0] + '/' + year)
description = detail[1]
account_id = account.get_account_id()
if detail[4] == 'DB':
balance = float('-' + detail[3].replace(',', ''))
else:
balance = float(detail[3].replace(',', ''))
del detail[0]
reference_number = self.code.generate_code('-'.join(detail))
transaction = Transaction(account_id, reference_number, trading_date,
balance, description)
if transaction.save() == 1:
self.total_transactions = self.total_transactions + 1
self.email_transport.send_transaction_email(account, transaction)
def convert_trading_date(self, trading_date):
date = datetime.strptime(trading_date, '%d/%m/%Y')
return date.strftime('%Y-%m-%d')
def get_current_update(self):
path = self.get_update_file()
with open(path, 'r') as content_file:
current_update = content_file.read()
return current_update
def set_current_update(self):
path = self.get_update_file()
current_date = time.strftime("%d/%m/%Y")
date = datetime.strptime(current_date, "%d/%m/%Y")
modified_date = date - timedelta(days=1)
file = open(path, 'w')
file.write(datetime.strftime(modified_date, "%d/%m/%Y"))
file.close()
def get_update_file(self):
update_file = self.config.get_base_dir(
'tmp') + 'klikbca_enterprise_update.txt'
return update_file
class AcbEnterprise:
def __init__(self, payment, session=None, proxy={}):
self.session = session
self.proxy = proxy
self.config = Config()
self.log = Log()
self.username = payment.get_username()
self.password = payment.get_password()
acb = self.get_config()
self.email_transport = EmailTransport()
self.corp_url = acb['corp_url']
self.captcha = CaptchaResolver()
self.debug_mode = acb['debug_mode']
self.total_transactions = 0
self.history = History()
self.code = GenerateCode()
self.max_attempt_login = 20
self.login_failed = 0
self.session = session
self.proxy = proxy
self.payment = payment
def get_config(self):
config = self.config.get_section_config('AcbEnterprise')
return config
def perform_login(self):
corp_url = self.corp_url
username = self.username
password = self.password
selenium = Selenium()
if self.session.get_driver() is None:
if self.session.get_last_driver(
) is None or self.session.get_last_driver() is 'Firefox':
driver = selenium.get_firefox_driver(self.proxy)
self.session.set_last_driver('Chrome')
else:
driver = selenium.get_firefox_driver(self.proxy)
self.session.set_last_driver('Firefox')
self.session.set_driver(driver)
try:
driver.get(corp_url)
online_banking = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, "//a[contains(@href,'obk/login.jsp')]")))
online_banking.click()
time.sleep(5)
captcha = self.get_captcha(driver)
# Get username input element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="UserName"]')))
element.send_keys(username, Keys.ARROW_DOWN)
# Get password input element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="PassWord"]')))
driver.execute_script(
'arguments[0].style = ""; arguments[0].style.display = "block"; arguments[0].style.visibility = "visible";',
element)
element.send_keys(password)
# Get captcha input element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="SecurityCode"]')))
driver.execute_script(
'arguments[0].style = ""; arguments[0].style.display = "block"; arguments[0].style.visibility = "visible";',
element)
element.send_keys(captcha)
time.sleep(2)
# Get submit button element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//a[@id="button-dangnhap"]')))
element.click()
time.sleep(3)
try:
# Update Account Information
WebDriverWait(driver, 10).until(
EC.visibility_of_element_located(
(By.XPATH, "//table[@id='table']//tr/td")))
account_info = driver.find_elements_by_xpath(
"//table[@id='table']//tr/td")
account_number = account_info[0].text.strip()
account_name = self.payment.get_username()
account_balance = float(
account_info[2].text.strip().replace(' ', '').replace(
'(VND)', '').replace('.', ''))
account = self.update_account(account_name, account_number,
account_balance,
self.payment.get_id())
except:
driver.close()
return self.perform_login()
# click to transaction menu
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, "//a[contains(@class,'acc_bold')]")))
element.click()
time.sleep(3)
view_link = WebDriverWait(driver, 10).until(
EC.element_to_be_clickable(
(By.XPATH,
"//input[contains(@onclick,'OutPrintByDate')]")))
view_link.click()
try:
window_after = driver.window_handles[1]
driver.switch_to_window(window_after)
WebDriverWait(driver, 10).until(
EC.visibility_of_element_located(
(By.XPATH, "//table[@id='table1']//tbody")))
transactions = driver.find_elements_by_xpath(
"//table[@id='table1']//tbody/tr[position() >= 0 and position() <= 10]"
)
for row in transactions:
columns = row.find_elements_by_xpath("td")
self.save_transaction(account, columns)
self.log.update_log('Acb', self.username)
self.log.log(
self.payment.get_name() + '-' +
self.payment.get_type() + '-' +
self.payment.get_username() + ": " +
str(self.total_transactions) +
' transaction(s) created', 'message')
self.session.set_changing_proxy(0)
driver.close()
except:
self.log.log(
self.payment.get_name() + '-' +
self.payment.get_type() + '-' +
self.payment.get_username() + ": " +
"Cannot load transactions", 'error')
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(
exc_tb.tb_frame.f_code.co_filename)[1]
self.log.log(
self.payment.get_name() + '-' +
self.payment.get_type() + '-' +
self.payment.get_username() + ': ' +
str(sys.exc_info()), 'debug')
self.log.log(
str(exc_type) + '-' + fname + '-' +
str(exc_tb.tb_lineno), 'error')
self.session.set_changing_proxy(1)
except:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
self.log.log(
self.payment.get_name() + '-' + self.payment.get_type() +
'-' + self.payment.get_username() + ': ' +
str(sys.exc_info()), 'debug')
self.log.log(
str(exc_type) + '-' + fname + '-' + str(exc_tb.tb_lineno),
'error')
self.session.set_changing_proxy(1)
driver.quit()
self.history.set_current_update('acb_enterprise', "%d/%m/%Y")
self.session.set_driver(None)
def save_transaction(self, account, detail):
if len(detail) < 4:
return False
trading_date = self.convert_trading_date(detail[0].text)
reference_number = detail[1].text
account_id = account.get_account_id()
if detail[3].text.strip() is not '':
balance = -float(detail[3].text.strip().replace('.', ''))
else:
balance = float(detail[4].text.strip().replace('.', ''))
description = detail[2].text
transaction = Transaction(account_id, reference_number, trading_date,
balance, description)
if transaction.save() == 1:
self.total_transactions = self.total_transactions + 1
self.email_transport.send_transaction_email(account, transaction)
def get_captcha(self, driver):
img_data = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, "//img[@src='Captcha.jpg']")))
img_file = img_data.screenshot_as_png
self.captcha.save_from_source(img_file, 'png')
captcha_text = self.captcha.resolve(True)
if re.match("^[a-zA-Z0-9]{5}$", captcha_text):
return captcha_text
driver.refresh()
return self.get_captcha(driver)
def convert_trading_date(self, trading_date):
date = datetime.strptime(trading_date, '%d-%m-%y')
return date.strftime('%Y-%m-%d')
def update_account(self, name, number, balance, payment_id):
account = AcbAccount(name, number, payment_id)
account.set_balance(balance)
account.update_account()
return account
def is_debug(self):
return self.debug_mode
class IntegrationController:
def __init__(self):
self.trello = Trello()
self.log = Log()
self.petitionsList = []
self.petition = Petition()
def pushPlipToTrelloBoard(self):
log = Log()
#recover date from last Sync and displays it before accually syncs
lastSyncDate = self.log.recoverLastSync('TRELLO_SYNC')
#for p in Petition.where(Petition.submitDate >= lastSyncDate).get():
count = 0
print("Last sync: " + str(lastSyncDate))
for petition in Petition.select().where(Petition.submitDate >= lastSyncDate):
print(petition.plip_name)
count += self.trello.createCard(petition)
print("Tototal of [" + str(count) +"] roposes pushed to Trello board")
#if plip finishes now will create a log for it
now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
log.motive = "TRELLO_SYNC"
log.quantity = count
log.sync_date = now
self.log.createLogSyncPL(log.sync_date, log.quantity, log.motive)
# downloads and store plips from google sheets on local repositoty
def downloadPLIPFile(self):
plipSheet = os.getenv("GOOGLE_SHEET_URL")
fileName = 'plip.csv'
#tries to create plip repo file in case not exists
self.petition.createPlipRepo()
print('Baixando PLIPs')
filedata = urllib2.urlopen(plipSheet)
datatowrite = filedata.read()
try:
with open('plip-repo/plip.csv', 'wb') as f:
f.write(datatowrite)
print("Arquivo baixado com sucesso!")
except OSError as e:
if e.errno != errno.EEXIST:
raise
# read lines from csv file
# and transform then into petition's objects
# then store each plip in the database
# creates a log of when and how many plips were synced
def store(self):
petitionList = []
with open('plip-repo/plip.csv', 'rb') as csvfile:
plips = csv.reader(csvfile)
#pt = Petition.select().where(Petition.submitDate > '2018-02-29 00:00:00').order_by(Petition.submitDate.desc()).limit(1)
lastSync = self.log.recoverLastSync('PLIP_SYNC')
#print(lastSync)
#test = datetime.datetime.strptime(str(lastSync), '%Y-%m-%d %H:%M:%S')
print("Last sync was in: ", lastSync)
for row in plips:
if(row[0] != 'status'):
timestamp = datetime.datetime.strptime(row[15],'%Y-%m-%d %H:%M:%S')
#print("debug timestamp:")
#print(type(timestamp))
#print("debug lastsync")
#print(type(lastSync))
if timestamp > lastSync:
print("última sincronização: "+ str(lastSync))
print("Timestamp de envio da petição:" + str(timestamp))
print("Timestamp de envio maior que a ultima sincronização.. salvando no banco:")
petition = Petition(
plip_status = row[0],
plip_template = row[1],
plip_fantasy_name = row[2],
plip_name = row[3],
plip_text = row[4],
plip_wide = row[5],
plip_state = row[6],
plip_municipality = row[7],
plip_video = row[8],
plip_references = row[9],
plip_links = row[10],
sender_name = row[11],
sender_email =row[12],
sender_telephone =row[13],
submitDate = row[15]
)
is_save = petition.save()
petitionList.append(is_save)
else:
print("Timestamp:")
print(timestamp)
print("petition send date lower then lastSync")
print("Total of:[" + str(len(petitionList))+ "] was synced during this task.")
#create a log of the last petition Date that was synced
if 'petition' in locals():
if hasattr(petition, 'submitDate'):
self.log.createLogSyncPL(petition.submitDate,len(petitionList), "PLIP_SYNC")
else:
#logs in case there is any new petition
self.log.createLogSyncPL(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),len(petitionList), "PLIP_SYNC")
def __init__(self):
self.trello = Trello()
self.log = Log()
self.petitionsList = []
self.petition = Petition()
class Msb:
def __init__(self, name=None, session=None, proxy={}):
self.session = session
self.proxy = proxy
self.config = Config()
self.log = Log()
self.captcha = CaptchaResolver()
section_config = self.get_section_config(name)
self.email_transport = EmailTransport()
self.home_url = section_config['home_url']
self.login_url = section_config['login_url']
self.username = section_config['username']
self.password = section_config['password']
self.debug_mode = section_config['debug_mode']
self.total_transactions = 0
self.max_attempt_login = 10
self.max_validate_captcha = 10
self.login_failed = 0
self.captcha_failed = 0
self.history = History()
self.code = GenerateCode()
def is_debug(self):
return self.debug_mode
def get_section_config(self, name=None):
if name is None:
name = 'Msb'
section_config = self.config.get_section_config(name)
return section_config
def perform_login(self):
login_url = self.login_url
username = self.username
password = self.password
selenium = Selenium()
if self.session.get_driver() is None:
if self.session.get_last_driver() is None or self.session.get_last_driver() is 'Chrome':
driver = selenium.get_firefox_driver(self.proxy)
self.session.set_last_driver('Firefox')
else:
driver = selenium.get_chrome_driver(self.proxy)
self.session.set_last_driver('Chrome')
self.session.set_driver(driver)
try:
driver.get(login_url)
# Get username input element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="_userName"]'))
)
element.send_keys(username)
# Get password input element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="_passwordS"]'))
)
element.send_keys(password)
captcha = self.get_captcha(driver)
print(captcha)
exit(111111)
# Get captcha input element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="_verifyCode"]'))
)
element.send_keys(captcha)
# element.send_keys(Keys.RETURN)
# Get submit button element
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located(
(By.XPATH, '//button[@id="loginBtn"]'))
)
element.click()
# click to account menu
time.sleep(5)
account_link = WebDriverWait(driver, 10).until(
EC.visibility_of_element_located(
(By.XPATH, '//a[@name="AI.QCK.ACCOUNT"]'))
)
retry_account = 0
while retry_account < 3:
try:
account_link.click()
# Click to view last 10 transactions
time.sleep(5)
current_date = self.history.get_current_update('techcombank')
from_date = driver.find_elements_by_xpath(
"//input[@id='fieldName:START.DATE']")[0]
from_date.send_keys(current_date, Keys.ENTER)
time.sleep(5)
to_date = driver.find_elements_by_xpath(
"//input[@id='fieldName:END.DATE']")[0]
to_date.send_keys(current_date)
time.sleep(5)
button = driver.find_elements_by_xpath(
'//a[@title="Xem giao dịch"]')[1]
button.click()
time.sleep(5)
button = driver.find_elements_by_xpath(
'//a[@title="Xem giao dịch"]')[1]
button.click()
break
except:
self.log.log("Techcombank: Re-click to account", 'debug')
self.log.log(str(sys.exc_info()), 'debug')
retry_account = retry_account + 1
# Update account information
try:
WebDriverWait(driver, 15).until(
EC.visibility_of_element_located(
(By.XPATH, "//table[@id='enqheader']//tr[position()>1 and position()<4]"))
)
info = driver.find_elements_by_xpath(
"//table[@id='enqheader']//tr[position()>1 and position()<4]")
number = info[0].find_elements_by_xpath("td")[1].text
balance = float(info[0].find_elements_by_xpath("td")[3].text.replace(',', ''))
name = info[1].find_elements_by_xpath("td")[1].text
account = self.update_account(name, number, balance)
transactions = driver.find_elements_by_xpath(
"//table[starts-with(@id,'datadisplay_MainBody')]//tr")
for row in transactions:
columns = row.find_elements_by_xpath("td")
self.save_transaction(account, columns)
self.log.update_log('Techcombank', self.username)
self.log.log(str(self.total_transactions) + ' Tcb transaction(s) created', 'message')
self.session.set_changing_proxy(0)
except:
self.log.log("Techcombank: Cannot load transactions", 'error')
self.log.log(str(sys.exc_info()), 'error')
self.session.set_changing_proxy(1)
except:
exc_info = sys.exc_info()
traceback.print_exception(*exc_info)
self.log.log(str(sys.exc_info()), 'debug')
driver.close()
self.history.set_current_update('techcombank', "%d/%m/%Y")
self.session.set_driver(None)
def get_captcha(self, driver):
img_data = driver.find_element_by_id('safecode').screenshot_as_png
self.captcha.save_from_source(img_data)
captcha_text = self.captcha.resolve(True)
if re.match("^[a-zA-Z0-9]{4}$", captcha_text):
return captcha_text
return self.get_captcha(driver)
def run():
log = Log()
log.notify()
class Techcombank:
def __init__(self, payment, session=None, proxy={}):
self.session = session
self.proxy = proxy
self.payment = payment
self.config = Config()
self.log = Log()
techcombank = self.get_techcombank_config()
self.email_transport = EmailTransport()
self.login_url = techcombank['login_url']
self.username = payment.get_username()
self.password = payment.get_password()
self.debug_mode = techcombank['debug_mode']
self.total_transactions = 0
self.history = History()
self.code = GenerateCode()
def perform_login(self):
login_url = self.login_url
username = self.username
password = self.password
selenium = Selenium()
if self.session.get_driver() is None:
if self.session.get_last_driver(
) is None or self.session.get_last_driver() is 'Firefox':
driver = selenium.get_firefox_driver(self.proxy)
self.session.set_last_driver('Chrome')
else:
driver = selenium.get_firefox_driver(self.proxy)
self.session.set_last_driver('Firefox')
self.session.set_driver(driver)
try:
driver.get(login_url)
# Get username input element
element = WebDriverWait(driver, 60).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="signOnName"]')))
element.send_keys(username)
# element.send_keys(Keys.RETURN)
element = WebDriverWait(driver, 60).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="password"]')))
# Get password input element
element.send_keys(password)
# element.send_keys(Keys.RETURN)
# Get submit button element
element = WebDriverWait(driver, 60).until(
EC.presence_of_element_located(
(By.XPATH, '//input[@name="btn_login"]')))
element.click()
time.sleep(5)
WebDriverWait(driver, 60).until(
EC.visibility_of_element_located(
(By.XPATH,
"//table[contains(@id,'datadisplay_AcctBalance')]")))
sub_accounts = driver.find_elements_by_xpath(
"//table[contains(@id,'datadisplay_AcctBalance')]//tr")
for i in range(0, len(sub_accounts)):
WebDriverWait(driver, 60).until(
EC.visibility_of_element_located(
(By.XPATH,
"//table[contains(@id,'datadisplay_AcctBalance')]"
)))
WebDriverWait(driver, 60).until(
EC.visibility_of_element_located((
By.XPATH,
"//table[contains(@id,'datadisplay_AcctBalance')]//a/img[contains(@src,'View.png')]"
)))
sub_account = driver.find_elements_by_xpath(
"//table[contains(@id,'datadisplay_AcctBalance')]//tr"
)[i]
search_btn = sub_account.find_element_by_xpath(
".//a/img[contains(@src,'View.png')]")
search_btn.click()
# Update account information
try:
WebDriverWait(driver, 120).until(
EC.visibility_of_element_located(
(By.XPATH, "//table[@id='enqheader']//tr")))
info = driver.find_elements_by_xpath(
"//table[@id='enqheader']//tr")
number = info[2].find_elements_by_xpath("td")[1].text
try:
balance = float(info[2].find_elements_by_xpath(
"td")[3].text.replace(',', ''))
except:
balance = float(0)
name = info[3].find_elements_by_xpath("td")[1].text
account = self.update_account(name, number, balance,
self.payment.get_id())
transactions = driver.find_elements_by_xpath(
"//table[starts-with(@id,'datadisplay_MainBody')]//tr"
)
count = 0
for row in transactions:
count += 1
# Get first 10 records
if count > 10:
break
columns = row.find_elements_by_xpath("td")
self.save_transaction(account, columns)
self.log.update_log('Techcombank', self.username)
self.log.log(
"Tcb " + self.payment.get_type() +
self.payment.get_username() + ": " +
str(self.total_transactions) +
' transaction(s) created', 'message')
self.session.set_changing_proxy(0)
except:
self.log.log(
"Tcb " + self.payment.get_type() +
self.payment.get_username() + ": " +
"Cannot load transactions", 'error')
self.log.log(str(sys.exc_info()), 'error')
self.session.set_changing_proxy(1)
home_btn = driver.find_element_by_xpath(
'//a[@name="AI.QCK.HOME"]')
home_btn.click()
except:
exc_info = sys.exc_info()
traceback.print_exception(*exc_info)
self.log.log(str(sys.exc_info()), 'debug')
driver.close()
self.history.set_current_update('techcombank', "%d/%m/%Y")
self.session.set_driver(None)
def save_transaction(self, account, detail):
trading_date = self.convert_trading_date(detail[0].text)
if trading_date is None:
return 0
description = detail[1].text
account_id = account.get_account_id()
balance = float(detail[2].text.replace(',', ''))
reference_number = self.convert_reference_number(description)
transaction = Transaction(account_id, reference_number, trading_date,
balance, description)
if transaction.save() == 1:
self.total_transactions = self.total_transactions + 1
self.email_transport.send_transaction_email(account, transaction)
def convert_reference_number(self, description):
description_array = description.split('/')
reference_number = description_array[len(description_array) -
1].strip()
return reference_number
def convert_trading_date(self, trading_date):
try:
date = datetime.strptime(trading_date, '%d/%m/%Y')
return date.strftime('%Y-%m-%d')
except:
return None
def update_account(self, name, number, balance, payment_id):
account = TechcombankAccount(name, number, payment_id)
account.set_balance(balance)
account.update_account()
return account
def get_techcombank_config(self):
techcombank = self.config.get_section_config('Techcombank')
return techcombank
def is_debug(self):
return self.debug_mode