def test_result_update(
sheet_number, row_number, data_list, analysis_file_update=False
):
if analysis_file_update:
result_file_path = (
os.path.abspath(".")
+ "/config/"
+ Common.get_config_value("analysis_input_file")
)
else:
result_file_path = (
os.path.abspath(".")
+ "/report/"
+ Common.get_config_value("analysis_output_file")
)
xlsObj, wb_copy = Xlsparser.copy_xls(result_file_path, sheet_number)
column_number = 0
for content in data_list:
xlsObj.write(
row_number, column_number, f"{content}", Xlsparser.cell_styles()
)
column_number += 1
wb_copy.save(result_file_path)
del xlsObj
del wb_copy
def Conftest():
uri = "/api/user/login"
allure.attach(SX_API_URl + uri, '地址', allure.attachment_type.TEXT)
data = {"account": User_account, "password": User_password}
headers = {'content-type': 'application/json'}
allure.attach(json.dumps(data, ensure_ascii=False, indent=4), '请求',
allure.attachment_type.TEXT)
allure.attach(json.dumps(headers, ensure_ascii=False, indent=4), '请求头',
allure.attachment_type.TEXT)
comm = Common()
response = comm.post(uri, params=data, headers=headers)
allure.attach(json.dumps(response.json(), ensure_ascii=False, indent=4),
'响应', allure.attachment_type.TEXT)
print("__________________________")
print(response.text)
code = int(response.status_code)
print(code)
code1 = json.loads(response.text)['code']
if code == 200 and code1 == 0:
msg = response.json().get('msg')
# with open('./Config/config_token', 'w', encoding='utf-8') as f:
# f.write(msg)
login_headers["token"] = msg
print("Conftest——成功")
else:
print("Conftest——失败")
def index(job_name=None, build_number=None, component_version=None):
"""
This API is used to search the result based on the selected filtered options.
:param str job_name:
:param int build_number:
:param str component_version:
:return: Searched results and search job menu
"""
search_form = JobSearchForm(request.form)
if request.method == "POST":
job_name = search_form.data["job_name"].strip()
try:
pattern_type = re.search(r"\w*-\w*", job_name).group()
except AttributeError:
Common.logger.warn(
f"index:failed to search the job name: {job_name}")
pattern_type = job_name
build_number = search_form.data["build_number"]
component_version = search_form.data["component_version"]
fs = extracting_build_info(
job_name=job_name,
build_number=build_number,
component_version=component_version,
)
if fs.count() == 0:
return render_template("404.html", title="404"), 404
data_list = Common.collection_creation(fs)
return render_template(
"search_results.html",
List=data_list,
pattern_type=pattern_type,
data_display="True",
)
if job_name and build_number and component_version:
fs = extracting_build_info(
job_name=job_name,
build_number=build_number,
component_version=component_version,
)
if fs.count() == 0:
return render_template("404.html", title="404"), 404
data_list = Common.collection_creation(fs)
test_data_map = Common.test_map_details(data_list)
try:
pattern_type = re.search(r"\w*-\w*",
data_list[0]["Job-Name"]).group()
except AttributeError:
Common.logger.warn(
f"index:failed to search the job: {data_list[0]['Job-Name']}")
pattern_type = job_name
return render_template(
"search_results.html",
List=data_list,
pattern_type=pattern_type,
data_display="False",
test_data_map=test_data_map,
)
return render_template("search.html", form=search_form)
def search_by_component():
"""
This API is used to search the job based on the their component
:return:
"""
search_form = SearchByField(request.form)
if request.method == "POST":
Common.logger.info("search_by_component:Post API called")
field_name = search_form.select.data
field_value = search_form.data["search"].strip()
fs = extracting_data_by_field(field_name=field_name,
field_value=field_value)
if fs.count() == 0:
return render_template("404.html", title="404"), 404
data_list = Common.collection_creation(fs)
test_data_map = Common.test_map_details(data_list)
if test_data_map == 500:
Common.logger.warn(
f"search_by_component:Internal server error comes while listing "
f"the data_list={data_list}")
return render_template("500.html", title="500"), 500
return render_template("search_results.html",
List=data_list,
test_data_map=test_data_map)
return render_template("component_search_by_field.html",
search_form=search_form)
def google(client: Client, message: Message) -> None:
query = " ".join(message.command[1:])
command = message.command[0]
with GoogleAPI() as g_client:
if command == "g":
response: GoogleResponse = g_client.search(
query, search_type=SEARCH_TYPE.TEXT)
if response:
client.send_chat_action(message.chat.id, "typing")
client.send_message(
message.chat.id,
f"<b>{response.title}</b>\n\n{response.snippet}\n\n{response.url}",
parse_mode="HTML",
)
else:
Common.send_not_found_message(message)
if command == "gi" or command == "p":
response: GoogleImageResponse = g_client.search(
query, search_type=SEARCH_TYPE.IMAGE)
if response:
client.send_chat_action(message.chat.id, "upload_photo")
client.send_photo(
message.chat.id,
response.url,
caption=
f"<i>{response.snippet}</i>\n\n{response.source_url}",
parse_mode="HTML",
)
else:
Common.send_not_found_message(message)
def __init__(self, client_id, log_obj):
self.logger = log_obj.logger
self.client_id = client_id
self.client = MqttClient(client_id=client_id)
self.config = Common.load_config('../../configs/mqtt_config.yaml')
self.mqtt_configs = self.config['mqtt']
self.__mqtt_host = self.mqtt_configs['host']
self.__mqtt_port = self.mqtt_configs['port']
self.__mqtt_topic = self.mqtt_configs['topic']
self.mqtt_topics = []
self.set_callbacks()
self.kafka_config = Common.load_config(
'../../configs/kafka_configs.yaml')['kafka']
self.__kafka_host = self.kafka_config['host']
self.__kafka_topic = self.kafka_config['topic']
self.mongo_config = Common.load_config(
'../../configs/mongo.yaml')['mongo']
self.__mongo_host = self.mongo_config['host']
self.__mongo_port = self.mongo_config['port']
self.__mongo_database = self.mongo_config['database']
self.__mongo_collection = self.mongo_config['collection']
self.qos = int(self.mqtt_configs['qos'])
self.kafka_service = KafkaService(self.__kafka_host, log_obj=log_obj)
self.mongo_service = MongoService(self.__mongo_host,
self.__mongo_port,
log_obj=log_obj)
def env_setup():
if not os.path.isfile(
os.path.join(os.path.abspath("."),
Common.get_config_value("data_location"))):
os.mkdir(
os.path.join(os.path.abspath("."),
Common.get_config_value("data_location")))
return 0
def __enter__(self):
self.jenkinsObj = Jenkins(
Common.get_config_value("jenkins_base_url"),
Common.decrypt(Common.get_config_value("jenkins_username")),
Common.decrypt(Common.get_config_value("jenkins_password")),
ssl_verify=False,
)
return self.jenkinsObj
def approve(contract_address,pay_address,get_address, amount,node_index = None,errorcode=47001,errorkey="error"):
if len(get_address)!=34 :
send_get_address=ByteToHex(bytes(get_address, encoding = "utf8"))
else:
send_get_address=Common.bl_address(get_address)
if send_get_address=="0000000000000000000000000000000000000000":
send_get_address=ByteToHex(bytes(get_address, encoding = "utf8"))
if len(pay_address)!=34 :
send_pay_address=ByteToHex(bytes(pay_address, encoding = "utf8"))
else:
send_pay_address=Common.bl_address(pay_address)
if send_pay_address=="0000000000000000000000000000000000000000":
send_pay_address=ByteToHex(bytes(pay_address, encoding = "utf8"))
request = {
"REQUEST": {
"Qid": "t",
"Method": "signeovminvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": contract_address,
"version": 1,
"params": [
{
"type": "string",
"value": "approve"
},
{
"type": "array",
"value": [
{
"type": "bytearray",
"value": send_pay_address
},
{
"type": "bytearray",
"value": send_get_address
},
{
"type": "int",
"value": amount
}
]
}
]
}
},
"RESPONSE":{"error" : errorcode},
"NODE_INDEX":node_index
}
if (errorkey =="error_code"):
request["SIGN_RESPONSE"]={errorkey : errorcode}
if len(contract_address)<=5:
logger.error("contract address error! now is contract address:\"" + contract_address+"\"")
return (False,{"error":10000,"desc":"contract address error!"})
return API.contract().call_contract(Task(name="approve", ijson=request), twice = True,sleep=0)
def edit_observation(pattern_type, id):
"""
This API is used to edit the observation based on the available record.
:param pattern_type:
:param id:
"""
fs = accessing_data_via_id(build_id=f"{id}")
if fs.count() == 0:
return render_template("404.html", title="404"), 404
record = Common.collection_creation(fs)[0]
form = ObservationUpdate(request.form)
if request.method == "POST":
Common.logger.info(
f"edit_observation: Post API called against id {id} and pattern type"
f" {pattern_type}")
observations = ast.literal_eval(form.data["observation_data"])
try:
Common.logger.info(
f"edit_observation: The provided observation is {observations}"
f" {pattern_type}")
if pattern_type not in Common.get_config_value("test_map"):
if type(observations) is dict:
for observation in observations:
db_update(
observation_record_key=f"{observation}",
observation_record_value="{}".format(
observations[observation]),
)
record["Validation"] = Common.record_updater(
record["Validation"], observations)
update_record(f"{id}", old_record=record)
else:
os.popen("touch problem_in_before_update")
failed_test_details = {
"test_details":
record["Validation"]["Pre_Upgrade_test_Failure"]
}
updated_data = Common.record_updater(failed_test_details,
observations)
record["Validation"][
"Pre_Upgrade_test_Failure"] = updated_data["test_details"]
update_record(f"{id}", old_record=record)
except Exception as ex:
Common.logger.warn(
f"edit_observation: The provided dictionary is not in correct "
f"format {ex}")
flash(
"Please provide the proper dictionary format {} of pattern {}".
format(observations, pattern_type))
return render_template("observation.html",
form=form,
pattern_type=pattern_type,
record=record)
flash("Data Submitted Successfully")
return render_template("observation.html",
form=form,
pattern_type=pattern_type,
record=record)
def approve(contract_address,
pay_address,
get_address,
amount,
node_index=None,
errorcode=47001,
errorkey="error"):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signeovminvoketx",
"Params": {
"gas_price":
0,
"gas_limit":
1000000000,
"address":
contract_address,
"version":
1,
"params": [{
"type": "string",
"value": "approve"
}, {
"type":
"array",
"value": [{
"type":
"bytearray",
"value":
Common.bl_reserver(
Common.base58_to_address(pay_address))
}, {
"type":
"bytearray",
"value":
Common.bl_reserver(
Common.base58_to_address(get_address))
}, {
"type": "int",
"value": amount
}]
}]
}
},
"RESPONSE": {
"error": errorcode
},
"NODE_INDEX": node_index
}
if (errorkey == "error_code"):
request["SIGN_RESPONSE"] = {errorkey: errorcode}
return API.contract().call_contract(Task(name="approve", ijson=request),
twice=True)
def allowance(contract_address,
pay_address,
get_address,
node_index=None,
errorcode=47001,
errorkey="error"):
if len(get_address) != 34:
send_get_address = ByteToHex(bytes(get_address, encoding="utf8"))
else:
send_get_address = Common.bl_address(get_address)
if len(pay_address) != 34:
send_pay_address = ByteToHex(bytes(pay_address, encoding="utf8"))
else:
send_pay_address = Common.bl_address(pay_address)
request = {
"REQUEST": {
"Qid": "t",
"Method": "signeovminvoketx",
"Params": {
"gas_price":
0,
"gas_limit":
1000000000,
"address":
contract_address,
"version":
1,
"params": [{
"type": "string",
"value": "allowance"
}, {
"type":
"array",
"value": [{
"type": "bytearray",
"value": send_pay_address
}, {
"type": "bytearray",
"value": send_get_address
}]
}]
}
},
"RESPONSE": {
"error": errorcode
},
"NODE_INDEX": node_index
}
if (errorkey == "error_code"):
request["SIGN_RESPONSE"] = {errorkey: errorcode}
return API.contract().call_contract(Task(name="allowance", ijson=request),
twice=True,
sleep=0)
def test_get_mer_addorupdate(self, merchantName_id):
uri = "/api/merchant/getMerchant/{}".format(merchantName_id)
data = {"id": merchantName_id}
headers1 = login_headers
comm = Common()
status = comm.get(uri, data, headers1)
if status:
merchantName_id, is_delete = self.test_select_db(
merchantName_id=merchantName_id)
print("商户的id能够正常的显示，id为{}".format(merchantName_id))
else:
print("商户的id")
def youtube(client: Client, message: Message) -> None:
query = " ".join(message.command[1:])
with YouTubeAPI() as y_client:
response = y_client.search(query)
if response:
client.send_chat_action(message.chat.id, "typing")
result = f'<b><a href="{response.url}">{response.title}</a></b>'
client.send_message(message.chat.id, result, parse_mode="HTML")
else:
Common.send_not_found_message(message)
def progress(job_type):
"""
This API is used to call the action based on the provided job type
:param job_type:
"""
if job_type == "log_analysis":
Common.logger.info("progress: log analysis called")
obj = Controller()
th1 = Thread(target=obj.run)
else:
Common.logger.info("progress: mail send report called")
th1 = Thread(target=Common.mail_send())
th1.start()
return Response(Common.generate(th1), mimetype="text/event-stream")
def __init__(self,
driver: WebDriver = None,
platform="web",
desired_caps=None):
"""
实例化时如果传入 driver，直接使用 传入的 driver，如果没有则判断 platform ，并生成对应的driver
默认生成 selenium webdriver
暂时只实现了web 和 android 平台
:param platform: 平台，web android ios
:param driver:
:param desired_caps: Android 平台的 desired_capabilities
"""
self.project_path = Common().parse_path().get("project_path")
if driver is None:
if platform == "web":
webdriver = selenium.webdriver
options = Options()
options.debugger_address = "127.0.0.1:9999"
self._driver = webdriver.Chrome(
executable_path=ChromeDriver().get_driver(),
options=options)
self._driver.implicitly_wait(3)
elif platform == "android":
webdriver = appium_webdriver
self._driver = webdriver.Remote('http://localhost:4723/wd/hub',
desired_caps)
self._driver.implicitly_wait(10)
elif platform == "ios":
pass
else:
self._driver = driver
if self._base_url != "":
self._driver.get(self._base_url)
self.log.info(f'访问地址：{self._base_url}')
def download_the_logs(downloadlink, job_name):
status = subprocess.call(
[
"wget {} -P {}/{} --no-check-certificate".format(
downloadlink,
os.path.abspath("."),
Common.get_config_value("data_location"),
)
],
shell=True,
)
if status == 0:
rename_file_name = "{}_{}".format(job_name,
random.randint(1, 10000))
os.rename(
f"{os.path.abspath('.')}/{Common.get_config_value('data_location')}"
"/consoleFull",
f"{os.path.abspath('.')}/{Common.get_config_value('data_location')}/"
f"{rename_file_name}",
) if os.path.isfile(
f"{os.path.abspath('.')}/{Common.get_config_value('data_location')}"
f"/consoleFull") else "Nothing"
Common.logger.info(f"[download_the_logs] Downloaded logs renamed")
return rename_file_name
else:
Common.logger.warn(
f"[download_the_logs]: The job does not exist {job_name} "
f"and downloadable link {downloadlink}")
return False
def job_list():
"""
This api help us to get the details of job name, build number and component version.
"""
fs = accessing_all_data()
if fs.count() == 0:
Common.logger.info(
f"job_list: there is no details available in the database")
return render_template("404.html", title="404"), 404
records = Common.collection_creation(fs)
job_records = dict()
for job in records:
if job["Job-Name"] not in job_records and ("Build-Number" in job
and "Build-Version" in job):
job_records[job["Job-Name"]] = {
"Build-Number": [job["Build-Number"]],
"Build-Version": [job["Build-Version"]],
}
elif "Build-Number" in job and "Build-Version" in job:
job_records[job["Job-Name"]]["Build-Number"].append(
job["Build-Number"])
job_records[job["Job-Name"]]["Build-Version"].append(
job["Build-Version"])
if job_records == dict():
return render_template("404.html", title="404"), 404
return render_template("job_name.html", job_records=job_records)
class TestAddMember:
desired_caps = {
"platformName": "Android",
"deviceName": "127.0.0.1:7555",
"appPackage": "com.tencent.wework",
"appActivity": ".launch.WwMainActivity",
"noReset": True
}
data_path = Common().parse_path().get("data_path")
def setup_class(self):
self.main_page = MainPage(platform="android",
desired_caps=self.desired_caps)
def teardown_class(self):
self.main_page.quit()
def teardown(self):
self.main_page.back()
@pytest.mark.parametrize("username, address, mobile_phone",
yaml.safe_load(
open(os.path.join(data_path, 'user.yml'))))
def test_add_member(self, username, address, mobile_phone):
page = self.main_page.go_to_contacts().go_to_add_member().go_to_manual(
).add_member(username=username,
address=address,
mobile_phone=mobile_phone)
result = page.get_toast()
assert "成功" in result
def delete_build_data():
"""
This API is used to delete the job based
"""
search_form = JobSearchForm(request.form)
if request.method == "POST":
job_name = search_form.data["job_name"].strip()
build_number = search_form.data["build_number"]
component_version = search_form.data["component_version"]
fs = extracting_build_info(
job_name=job_name,
build_number=build_number,
component_version=component_version,
)
if fs.count() == 0:
return render_template("404.html", title="404"), 404
record = Common.collection_creation(fs)[0]
response_json = delete_record(build_id=record["_id"])
if response_json.acknowledged:
flash(
"Build No {} of Job {} having version {} deleted successfully".
format(job_name, build_number, component_version))
else:
flash("Failed to delete content")
return render_template("delete_build.html", form=search_form)
def index_pagination(job_name):
"""
This API is used to list the job based on their job name
:param str job_name: Name of the Jenkins job
:return: redirect the build history page
"""
fs = regex_data_retrieval(job_name=job_name)
if fs.count() == 0:
return render_template("404.html", title="404"), 404
try:
pattern_type = re.search(r"\w*-\w*", job_name).group()
except AttributeError:
Common.logger.warn(
f"index_pagination:failed to search the job name: {job_name}")
pattern_type = job_name
offset = {"page": 1, "per_page": Common.get_config_value("per_page")}
page, per_page, offset = get_page_args(page_parameter="page",
per_page_parameter="per_page",
**offset)
pagination_items = page_list(fs, per_page=per_page, offset=offset)
pagination = Pagination(page=page,
per_page=per_page,
total=fs.count(),
css_framework="bootstrap4")
return render_template(
"index_pagination.html",
List=pagination_items,
page=page,
per_page=per_page,
pagination=pagination,
pattern_type=pattern_type,
job_name=job_name,
)
def nodeCountCheck(InResponse, nodeCount):
(result1, response1) = API.rpc().getstorage(
"0700000000000000000000000000000000000000",
ByteToHex(b"governanceView"))
if not result1:
return (False, {"error_info": "getstorage governanceView error !"})
viewvalue = ""
viewvalue = response1["result"][0:8]
print(viewvalue)
(result1, response1) = API.rpc().getstorage(
"0700000000000000000000000000000000000000",
ByteToHex(b"peerPool") + viewvalue)
if not result1:
return (False, {
"error_info":
"getstorage peerPool error ! viewValue:" + viewvalue
})
resCheck = Common.bl_reserver(response1["result"][0:2])
print(resCheck)
resInt = bytes.fromhex(resCheck)
print(resInt.hex())
if isinstance(InResponse, dict):
InResponse["nodeCountNow"] = int(resInt.hex(), 16)
else:
InResponse = {
"response": InResponse,
"nodeCountNow": int(resInt.hex(), 16)
}
if (nodeCount == int(resInt.hex(), 16)):
return (True, InResponse)
else:
return (False, InResponse)
def multi_sig_transfer(neo_contract_address, from_address, to_address, amount, m, pubkey_array, node_index=0):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signeovminvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": neo_contract_address,
"version": 1,
"params": [
{
"type": "string",
"value": "transfer"
},
{
"type" : "string",
"value" : ""
},
{
"type": "array",
"value": [
{
"type": "bytearray",
"value": Common.bl_reserver(Common.base58_to_address(from_address))
},
{
"type": "bytearray",
"value": Common.bl_reserver(Common.base58_to_address(to_address))
},
{
"type": "int",
"value": amount
}
]
}
]
}
},
"RESPONSE":{"error" : 0},
"NODE_INDEX":node_index
}
return CONTRACT_API.call_multisig_contract(Task(name="multi_sig_transfer", ijson=request), m, pubkey_array)
def transfer(contract_address,from_address,to_address,amount, node_index = None):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signeovminvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": contract_address,
"version": 1,
"params": [
{
"type": "string",
"value": "transfer"
},
{
"type" : "string",
"value" : ""
},
{
"type": "array",
"value": [
{
"type": "bytearray",
"value": Common.bl_reserver(Common.base58_to_address(from_address))
},
{
"type": "bytearray",
"value": Common.bl_reserver(Common.base58_to_address(to_address))
},
{
"type": "int",
"value": amount
}
]
}
]
}
},
"RESPONSE":{"error" : 0},
"NODE_INDEX":node_index
}
return API.contract().call_contract(Task(name="transfer", ijson=request), twice = True)
def fate_question(client: Client, message: Message) -> None:
_message = " ".join(
Common.pronoun_replace(message.text).replace("?", "").split()[1:])
random.seed(datetime.now())
correct_answer = f"{_message.split('ли')[1]} {_message.split('ли')[0]}"
incorrect_answer = random.choice(("Нет.", "Ни в коем случае."))
message.reply_text(random.choice((correct_answer, incorrect_answer)))
def run(self):
"""
This method is used to trigger the main method and perform the cleanup of all
properties
:return:
"""
sheet_number = {"Sheet_1": 0}
Common.environment_preparation()
for sheet in sheet_number.keys():
row_no = 0
self.prop_obj.sheets_number = sheet_number
self.prop_obj.rows_no = row_no
self.prop_obj.sheets = sheet
self.mapper_builder()
del self.prop_obj.rows_no
del self.prop_obj.job_mapper
del self.prop_obj.jobs_list
del self.prop_obj.sheets_number
del self.prop_obj.sheets
def forNeo(contract_address, pay_address, get_address, node_index=None):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signeovminvoketx",
"Params": {
"gas_price":
0,
"gas_limit":
1000000000,
"address":
contract_address,
"version":
1,
"params": [{
"type": "string",
"value": "transfer"
}, {
"type":
"array",
"type":
"array",
"value": [{
"type": "bytearray",
"value": Common.bl_address(pay_address)
}, {
"type": "bytearray",
"value": Common.bl_address(get_address)
}, {
"type": "int",
"value": "10"
}]
}]
}
},
"RESPONSE": {
"error": 0
},
"NODE_INDEX": node_index
}
return API.contract().call_contract(Task(name="forNeo", ijson=request),
twice=True)
def run_single_task(task, judge=True, process_log=True):
connecttype = task.type()
name = task.name()
start_time = time.time()
if process_log:
logger.print("[-------------------------------]")
logger.print("[ CONNECT ] " + str(connecttype) + "." + str(name))
cfg_content = task.data()
cfg_request = cfg_content["REQUEST"]
cfg_response = cfg_content["RESPONSE"]
if process_log:
logger.print(
"[ REQUEST ]" +
json.dumps(cfg_content, indent=4, sort_keys=True).replace(
"\"num#!#start-", "").replace("-num#!#end\"", ""))
# (result, response) = self.multithread_run(logger, cfg_request, cfg_response)
node_index = task.node_index()
node_ip = None
if node_index is None:
node_index = 0
if connecttype.lower() == "rpc":
node_ip = Config.NODES[int(node_index)]["ip"] + ":" + str(
Config.NODES[int(node_index)]["rpcport"])
if connecttype.lower() == "st":
node_ip = Config.NODES[int(node_index)]["ip"] + ":" + str(
Config.NODES[int(node_index)]["stport"])
logger.print("run on service(" + str(node_index) + "): " + node_ip)
response = utils.connect.con(connecttype, node_ip, cfg_request)
if process_log:
logger.print("[ RESPONSE ]" + json.dumps(response, indent=4))
end_time = time.time()
time_consumed = (end_time - start_time) * 1000
result = True
if judge:
result = Common.cmp(cfg_response, response)
if process_log:
if result:
logger.print("[ OK ] " + connecttype + "." + name +
" (%d ms)" % (time_consumed))
else:
logger.print("[ Failed ] " + connecttype + "." + name +
" (%d ms)" % (time_consumed))
logger.print("[-------------------------------]")
logger.print("")
return (result, response)
def page_list(fs, per_page, offset=0):
"""
This function is used to calculate the current offset value
:param fs:
:param per_page:
:param offset:
:return: offset number
"""
Common.logger.info(
f"Collecting the requested record by the pagination module {fs}")
requested_record = Common.collection_creation(fs)
return requested_record[offset:offset + per_page]
def job_process():
"""
This API is used to download the logs and analyze it based on the provided details
"""
form = ValidatorName(request.form)
if request.method == "POST":
Common.logger.info(f"job_process: Post method called")
job_processing_type = "log_analysis"
job_type = form.data["job_type"].strip()
job_number = form.data["job_number"]
component_not_check = form.data["skip_selection"]
component_version = form.data["component_version"]
snap_number = form.data["snap_number"]
Common.version_update(component_version, job_type)
DataUpdater.build_sheet_update(job_type, job_number,
component_not_check, component_version,
snap_number)
return render_template("data_processing.html",
form=form,
job_processing_type=job_processing_type)
return render_template("analyser_input.html", form=form)
