def processing(target_call_date):
"""
Processing
:param target_call_date: Target call date
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': CONFIG['log_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
# Connect db
try:
oracle = connect_db(logger)
if not oracle:
print "---------- Can't connect db ----------"
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- Can't connect db ----------"
logger.error(exc_info)
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
try:
call_date = "{0}-{1}-{2}".format(target_call_date[:4],
target_call_date[4:6],
target_call_date[6:])
logger.info("START.. Call date = {0}".format(call_date))
oracle.delete_cs_statistics_dashbrd_tb(call_date)
oracle.insert_cs_statistics_dashbrd_tb(call_date)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- ERROR ----------"
logger.error(exc_info)
logger.error("---------- ERROR ----------")
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
logger.info("END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT)))
logger.info("-" * 100)
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
def processing(dir_list):
"""
Processing
:param dir_list: List of directory
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': CONFIG['encrypt_log_file_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
ts = time.time()
st = datetime.fromtimestamp(ts).strftime('%Y-%m-%d-%H:%M.%S')
encrypt_cnt = 0
for dir_path in dir_list:
if not os.path.exists(dir_path):
logger.debug('Directory is not exists -> {0}'.format(dir_path))
continue
for file_name in os.listdir(dir_path):
try:
if file_name.endswith(".enc") or file_name.endswith(
".tmp") or file_name.endswith("filepart"):
continue
file_path = os.path.join(dir_path, file_name)
rename_file_path = os.path.join(
dir_path, "encrypting_{0}".format(file_name))
encrypt_cnt += 1
logger.info("Rename [ {0} -> {1} ]".format(
file_path, rename_file_path))
os.rename(file_path, rename_file_path)
logger.info("Encrypt [ {0} ]".format(file_name))
openssl.encrypt_file([rename_file_path])
except Exception:
exc_info = traceback.format_exc()
logger.error(
"Can't Rename or Encrypt record file. [ {0} ]".format(
file_name))
logger.error(exc_info)
continue
dt = datetime.fromtimestamp(ts).strftime('%Y%m%d%H%M%S')
logger.debug(
"END.. Start time = {0}, The time required = {1}, Encrypt target file list count = {2}"
.format(st, elapsed_time(dt), encrypt_cnt))
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
def processing(target_call_date):
"""
Processing
:param target_call_date: Target call date
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': CONFIG['log_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
# Connect db
try:
oracle = connect_db(logger, 'Oracle')
if not oracle:
print "---------- Can't connect db ----------"
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- Can't connect db ----------"
logger.error(exc_info)
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
try:
call_date = "{0}-{1}-{2}".format(target_call_date[:4],
target_call_date[4:6],
target_call_date[6:])
select_top_cnt = CONFIG['select_top_cnt']
relation_top_cnt = CONFIG['relation_top_cnt']
logger.info(
"Call date = {0}, Select top count = {1}, Relation top count = {2}"
.format(call_date, select_top_cnt, relation_top_cnt))
oracle.delete_frequent_data(call_date)
oracle.delete_related_data(call_date)
oracle.delete_frequent_detail_data(call_date)
oracle = connect_db(logger, 'Oracle')
based_on_the_word(logger, oracle, call_date)
based_on_the_document(logger, oracle, call_date)
insert_related_sentence(logger, oracle, call_date)
insert_related_keyword(logger, oracle, call_date)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- ERROR ----------"
logger.error(exc_info)
logger.error("---------- ERROR ----------")
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
logger.info("END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT)))
logger.info("-" * 100)
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
def processing(target_call_date):
"""
Processing
:param target_call_date: Target call date
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': CONFIG['log_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
# Connect db
try:
oracle = connect_db(logger, 'Oracle')
if not oracle:
print "---------- Can't connect db ----------"
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- Can't connect db ----------"
logger.error(exc_info)
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
try:
hmd_dict = {
'OM0001': 'OM_staff_reward_hmd', # (임)보상모니터링
'OM0002': 'OM_staff_happycar_hmd', # (임)보상모니터링
'OM0003': 'OM_staff_sitemove_hmd', # (임)현장출동
'OM0004': 'OM_janggi_reward_hmd', # (장)보상모니터링
'OM0005': 'OM_car_pay_hmd', # 납입최고
'OM0006': 'OM_loan_default_hmd', # 대출미납
'OM0007': 'OM_default_guide_hmd', # 미납안내
'OM0008': 'OM_car_reward_hmd', # 보상모니터링
'OM0009': 'OM_invalid_default_hmd', # 실효안내_정상부활건
'OM0010': 'OM_perfect_sales_hmd', # 완전 판매
'OM0011': 'OM_happycar_normal_hmd', # 해피카모니터링1
'OM0012': 'OM_happycar_normal_hmd', # 해피카모니터링2
'OM0013': 'OM_staff_sitemove_hmd' # 현장출동
}
hmd_result_list = list()
overlap_check_dict = dict()
call_date = "{0}-{1}-{2}".format(target_call_date[:4],
target_call_date[4:6],
target_call_date[6:])
oracle.delete_perfect_sales_hmd_result(call_date)
logger.info(
"Select CS perfect sales call list. [Target date -> {0}]".format(
call_date))
target_results = oracle.select_perfect_sales_call_list(call_date)
if target_results:
logger.info("CS perfect sales call count -> {0}".format(
len(target_results)))
for target_result in target_results:
try:
process_id = target_result[0]
call_id = target_result[1]
full_code = target_result[2]
project_code = target_result[3]
business_dcd = target_result[4]
nlp_result_id = target_result[5]
nlp_sentence = target_result[6]
sentence = target_result[7]
logger.info("PROCESS_ID = {0}, CALL_ID = {1}".format(
process_id,
call_id,
))
if full_code in hmd_dict:
model_params = hmd_dict[full_code]
logger.info("Start {0}".format(model_params))
hmd_result = execute_hmd(nlp_sentence, sentence,
model_params)
if len(hmd_result) > 0:
for cls in hmd_result.keys():
key = "{0}_{1}".format(cls, nlp_result_id)
if key in overlap_check_dict:
continue
overlap_check_dict[key] = 1
hmd_result_list.append({
'call_id': call_id,
'cls': cls,
'call_date': call_date,
'business_dcd': business_dcd,
'project_code': project_code,
'nlp_result_id': nlp_result_id,
'full_code': full_code,
'process_id': process_id
})
else:
logger.error("Not define HMD [full_code = {0}".format(
full_code))
except Exception:
exc_info = traceback.format_exc()
logger.error(exc_info)
oracle.disconnect()
oracle = connect_db(logger, 'Oracle')
continue
oracle.insert_perfect_sales_hmd_result(hmd_result_list)
else:
logger.info("No CS perfect sales call")
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- ERROR ----------"
logger.error(exc_info)
logger.error("---------- ERROR ----------")
finally:
logger.info("END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT)))
logger.info("-" * 100)
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
def processing(type_code, target_call_date):
"""
Processing
:param type_code: CALL_TYPE_CODE
:param target_call_date: Target call date
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': type_code + "_" + CONFIG['log_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
# Connect db
try:
oracle = connect_db(logger)
if not oracle:
print "---------- Can't connect db ----------"
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- Can't connect db ----------"
logger.error(exc_info)
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
try:
call_type_code = 'CT0001' if type_code == 'IB' else 'CT0002'
call_date = "{0}-{1}-{2}".format(target_call_date[:4],
target_call_date[4:6],
target_call_date[6:])
select_top_cnt = CONFIG['select_top_cnt']
relation_top_cnt = CONFIG['relation_top_cnt']
logger.info(
"START.. Call date = {0}, Call type code = {1}, Select top count = {2}, Relation top count = {3}"
.format(call_date, call_type_code, select_top_cnt,
relation_top_cnt))
oracle.delete_frequent_data(call_date, call_type_code)
oracle.delete_related_data(call_date, call_type_code)
oracle.delete_frequent_detail_data(call_date, call_type_code)
# 키워드 빈도수 추출
extract_frequent_keyword(logger, oracle, call_date, call_type_code)
# 키워드 문장 추출
extract_related_sentence(logger, oracle, call_date, call_type_code)
# 연관 키워드 추출
extract_related_keyword(logger, oracle, call_date, call_type_code)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- ERROR ----------"
logger.error(exc_info)
logger.error("---------- ERROR ----------")
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
logger.info("END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT)))
logger.info("-" * 100)
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
def processing(dir_list):
"""
Processing
:param dir_list: List of directory
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': CONFIG['encrypt_log_file_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
ts = time.time()
st = datetime.fromtimestamp(ts).strftime('%Y-%m-%d-%H:%M.%S')
encrypt_cnt = 0
for dir_path in dir_list:
if not os.path.exists(dir_path):
logger.debug('Directory is not exists -> {0}'.format(dir_path))
continue
w_ob = os.walk(dir_path)
for dir_path2, sub_dirs, files in w_ob:
for file_name in files:
try:
dir_name = os.path.basename(dir_path)
encrypt_dir_path = os.path.join(CONFIG['encrypt_rec_dir_path'], dir_name)
encrypt_file_path = "{0}/{1}".format(encrypt_dir_path, file_name)
file_path = os.path.join(dir_path2, file_name)
if file_name.endswith(".enc"):
if not os.path.exists(encrypt_dir_path):
os.makedirs(encrypt_dir_path)
if os.path.exists(encrypt_file_path):
os.remove(encrypt_file_path)
logger.debug("Move [ {0} -> {1}.tmp ]".format(file_path, encrypt_file_path))
shutil.move(file_path, '{0}.tmp'.format(encrypt_file_path))
logger.debug("Rename [ {0}.tmp -> {0} ]".format(encrypt_file_path))
os.rename('{0}.tmp'.format(encrypt_file_path), encrypt_file_path)
continue
if file_name.endswith(".tmp") or file_name.endswith("filepart"):
continue
rename_file_path = os.path.join(dir_path2, "encrypting_{0}".format(file_name))
encrypt_cnt += 1
logger.debug("Rename [ {0} -> {1} ]".format(file_path, rename_file_path))
os.rename(file_path, rename_file_path)
logger.debug("Encrypt [ {0} ]".format(file_name))
openssl.encrypt_file([rename_file_path])
except Exception:
exc_info = traceback.format_exc()
logger.error("Can't Rename or Encrypt record file. [ {0} ]".format(file_name))
logger.error(exc_info)
continue
try:
encrypt_file_path += '.enc'
enc_file_path = os.path.join(dir_path2, "{0}.enc".format(file_name))
if not os.path.exists(encrypt_dir_path):
os.makedirs(encrypt_dir_path)
if os.path.exists(encrypt_file_path):
os.remove(encrypt_file_path)
logger.debug("Move [ {0} -> {1}.tmp ]".format(enc_file_path, encrypt_file_path))
shutil.move(rename_file_path,'{0}.tmp'.format(encrypt_file_path))
logger.debug("Rename [ {0}.tmp -> {0} ]".format(encrypt_file_path))
os.rename('{0}.tmp'.format(encrypt_file_path), encrypt_file_path)
except Exception:
exc_info = traceback.format_exc()
logger.error("Can't move encrypt file. [ {0} ]".format(file_name))
logger.error(exc_info)
continue
dt = datetime.fromtimestamp(ts).strftime('%Y%m%d%H%M%S')
logger.info("END.. Start time = {0}, The time required = {1}, Encrypt target file list count = {2}".format(
st, elapsed_time(dt), encrypt_cnt))
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
def processing(target_call_date, project_code, group_code):
"""
Processing
:param target_call_date: Target call date
:param project_code: PROJECT_CODE
:param group_code: GROUP_CODE
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': "tm_" + CONFIG['log_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
# Connect db
try:
oracle = connect_db(logger, 'Oracle')
if not oracle:
print "---------- Can't connect db ----------"
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- Can't connect db ----------"
logger.error(exc_info)
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
try:
call_date = "{0}-{1}-{2}".format(target_call_date[:4],
target_call_date[4:6],
target_call_date[6:])
oracle.delete_summary_data(call_date, project_code)
# CS(PC0001), TM(PC0002) Multi CY0001, Single CY0002
logger.info("Target date -> {0}".format(call_date))
logger.info("Start multi")
multi_result = oracle.select_call_driver_frequency_by_multi(
group_code, call_date, project_code)
multi_output_dict = dict()
if multi_result:
for multi_item in multi_result:
business_dcd = multi_item[0]
office_hour = multi_item[1]
category_1depth_id = multi_item[2]
category_2depth_id = multi_item[3]
category_3depth_id = multi_item[4]
key = "{0}!@#${1}!@#${2}!@#${3}!@#${4}".format(
business_dcd, office_hour, category_1depth_id,
category_2depth_id, category_3depth_id)
if key not in multi_output_dict:
multi_output_dict[key] = 1
else:
multi_output_dict[key] += 1
for key, frequency in multi_output_dict.items():
business_dcd, office_hour, category_1depth_id, category_2depth_id, category_3depth_id = key.split(
"!@#$")
oracle.insert_frequent_summary_tb(
project_code=project_code,
business_dcd=business_dcd,
office_hour=office_hour,
call_date=call_date,
count_type_code='CY0001',
category_1depth_id=category_1depth_id,
category_2depth_id=category_2depth_id,
category_3depth_id=category_3depth_id,
category_frequency=frequency)
logger.info("Start single")
single_result = oracle.select_call_driver_frequency_by_single(
group_code, call_date, project_code)
if single_result:
classify_dict = dict()
for item in single_result:
call_id = item[0]
business_dcd = item[1]
office_hour = item[2]
category_1depth_id = item[3]
category_2depth_id = item[4]
category_3depth_id = item[5]
category_frequency = item[6]
key = "{0}!@#${1}!@#${2}".format(call_id, business_dcd,
office_hour)
if key not in classify_dict:
classify_dict[key] = {
'1depth_id': category_1depth_id,
'2depth_id': category_2depth_id,
'3depth_id': category_3depth_id,
'frequency': category_frequency
}
else:
if category_frequency > classify_dict[key]['frequency']:
classify_dict[key] = {
'1depth_id': category_1depth_id,
'2depth_id': category_2depth_id,
'3depth_id': category_3depth_id,
'frequency': category_frequency
}
merge_frequency_dict = dict()
for classify_key, value in classify_dict.items():
business_dcd = classify_key.split('!@#$')[1]
office_hour = classify_key.split('!@#$')[2]
key = "{0}!@#${1}!@#${2}!@#${3}!@#${4}".format(
business_dcd, office_hour, value['1depth_id'],
value['2depth_id'], value['3depth_id'])
if key not in merge_frequency_dict:
merge_frequency_dict[key] = 1
else:
merge_frequency_dict[key] += 1
for category, frequency in merge_frequency_dict.items():
category_list = category.split('!@#$')
oracle.insert_frequent_summary_tb(
project_code=project_code,
business_dcd=category_list[0],
office_hour=category_list[1],
call_date=call_date,
count_type_code='CY0002',
category_1depth_id=category_list[2],
category_2depth_id=category_list[3],
category_3depth_id=category_list[4],
category_frequency=frequency)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- ERROR ----------"
logger.error(exc_info)
logger.error("---------- ERROR ----------")
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
logger.info("END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT)))
logger.info("-" * 100)
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
def processing(target_call_date):
"""
Processing
:param target_call_date: Target call date
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': CONFIG['log_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
# Connect db
try:
oracle = connect_db(logger, 'Oracle')
if not oracle:
print "---------- Can't connect db ----------"
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- Can't connect db ----------"
logger.error(exc_info)
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
try:
call_date = "{0}-{1}-{2}".format(target_call_date[:4],
target_call_date[4:6],
target_call_date[6:])
oracle.delete_perfect_sales_hmd_result(call_date)
logger.info(
"Select CS perfect sales call list. [Target date -> {0}]".format(
call_date))
target_results = oracle.select_perfect_sales_call_list(call_date)
if target_results:
logger.info("CS perfect sales line count -> {0}".format(
len(target_results)))
proc_list = list()
split_cnt = len(target_results) / 10
manager = Manager()
return_list = manager.list()
for idx in range(0, len(target_results), split_cnt):
proc = Process(
target=upload_perfect_sales,
args=(logger, call_date,
target_results[idx:split_cnt + idx], return_list),
)
proc_list.append(proc)
proc.start()
for proc in proc_list:
proc.join()
overlap_check_dict = dict()
overlap_checked_result = list()
for item in return_list:
key = "{0}_{1}".format(item['cls'], item['nlp_result_id'])
if key in overlap_check_dict:
continue
overlap_check_dict[key] = 1
overlap_checked_result.append(item)
oracle.insert_perfect_sales_hmd_result(overlap_checked_result)
else:
logger.info("No CS perfect sales call")
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- ERROR ----------"
logger.error(exc_info)
logger.error("---------- ERROR ----------")
finally:
logger.info("END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT)))
logger.info("-" * 100)
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
def processing(target_call_date):
"""
Processing
:param target_call_date: Target call date
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': CONFIG['log_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
# Connect db
try:
oracle = connect_db(logger, 'Oracle')
if not oracle:
print "---------- Can't connect db ----------"
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- Can't connect db ----------"
logger.error(exc_info)
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
try:
call_date = "{0}-{1}-{2}".format(target_call_date[:4], target_call_date[4:6], target_call_date[6:])
logger.info("Start repeated call analysis. [Target date -> {0}]".format(call_date))
oracle.delete_repeated_call_analysis_tb(call_date)
meta_result = oracle.select_repeated_call(call_date)
if meta_result:
id_dict = dict()
frequency_dict = dict()
call_id_query = 'AND ('
for cu_id, call_id, ruser_id in meta_result:
id_dict[call_id] = (cu_id, ruser_id)
call_id_query += 'CALL_ID = {0} OR '.format(call_id)
call_id_query = call_id_query[:-3]
call_id_query += ')'
call_driver_result = oracle.select_call_driver_frequency_by_multi(call_date, call_id_query)
if call_driver_result:
for item in call_driver_result:
call_id = item[0]
category_1depth_id = item[1]
category_2depth_id = item[2]
category_3depth_id = item[3]
cu_id = id_dict[call_id][0]
ruser_id = id_dict[call_id][1]
frequency_key = "{0}!@#${1}!@#${2}!@#${3}".format(
cu_id, category_1depth_id, category_2depth_id, category_3depth_id)
if frequency_key not in frequency_dict:
frequency_dict[frequency_key] = [1, [(call_id, ruser_id)]]
else:
frequency_dict[frequency_key][0] += 1
frequency_dict[frequency_key][1].append((call_id, ruser_id))
for key, value in frequency_dict.items():
frequency = value[0]
if frequency > 1:
cu_id, category_1depth_id, category_2depth_id, category_3depth_id = key.split('!@#$')
id_list = value[1]
for call_id, ruser_id in id_list:
oracle.insert_repeated_call_analysis_tb(
call_id=call_id,
cu_id=cu_id,
ruser_id=ruser_id,
call_date=call_date,
category_1depth_id=category_1depth_id,
category_2depth_id=category_2depth_id,
category_3depth_id=category_3depth_id
)
else:
logger.info("No repeated call")
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- ERROR ----------"
logger.error(exc_info)
logger.error("---------- ERROR ----------")
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
logger.info("END.. Start time = {0}, The time required = {1}".format(ST, elapsed_time(DT)))
logger.info("-" * 100)
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
def processing(target_call_date):
"""
Processing
:param target_call_date: Target call date
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': CONFIG['log_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
# Connect db
try:
oracle = connect_db(logger, 'Oracle')
if not oracle:
print "---------- Can't connect db ----------"
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- Can't connect db ----------"
logger.error(exc_info)
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
try:
call_date = "{0}-{1}-{2}".format(target_call_date[:4],
target_call_date[4:6],
target_call_date[6:])
logger.info(
"Start repeated call analysis. [Target date -> {0}]".format(
call_date))
oracle.delete_repeated_call_analysis_tb(call_date)
meta_result = oracle.select_repeated_call(call_date)
call_driver_classify_result = oracle.select_call_driver_frequency_by_single(
call_date)
call_driver_classify_dict = dict()
if call_driver_classify_result:
for item in call_driver_classify_result:
call_id = item[0]
category_1depth_id = item[1]
category_2depth_id = item[2]
category_3depth_id = item[3]
call_driver_classify_dict[call_id] = (category_1depth_id,
category_2depth_id,
category_3depth_id)
if meta_result:
for meta_item in meta_result:
first_flag = True
cu_id = meta_item[0]
result = oracle.select_call_meta_info(cu_id, call_date)
if result:
for call_id, ruser_id in result:
flag = 'Y' if first_flag else 'N'
first_flag = False
if call_id in call_driver_classify_dict:
category_1depth_id = call_driver_classify_dict[
call_id][0]
category_2depth_id = call_driver_classify_dict[
call_id][1]
category_3depth_id = call_driver_classify_dict[
call_id][2]
else:
category_1depth_id = ''
category_2depth_id = ''
category_3depth_id = ''
oracle.insert_repeated_call_analysis_tb(
call_id=call_id,
cu_id=cu_id,
ruser_id=ruser_id,
call_date=call_date,
category_1depth_id=category_1depth_id,
category_2depth_id=category_2depth_id,
category_3depth_id=category_3depth_id,
flag=flag)
else:
logger.info("No repeated call")
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- ERROR ----------"
logger.error(exc_info)
logger.error("---------- ERROR ----------")
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
logger.info("END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT)))
logger.info("-" * 100)
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
def processing(target_call_date):
"""
Processing
:param target_call_date: Target call date
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': CONFIG['log_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
# Connect db
try:
oracle = connect_db(logger, 'Oracle')
if not oracle:
print "---------- Can't connect db ----------"
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- Can't connect db ----------"
logger.error(exc_info)
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
# Execute
try:
call_date = "{0}-{1}-{2}".format(target_call_date[:4], target_call_date[4:6], target_call_date[6:])
print "CALL_DATE = {0}".format(call_date)
logger.info("CALL_DATE = {0}".format(call_date))
print "1. Select target data"
logger.info("1. Select target data")
target_results = oracle.select_call_driver_quality_list(call_date)
if target_results:
print "2. Delete data"
logger.info("Delete data")
oracle.delete_call_driver_quality_hmd_result(call_date)
oracle.disconnect()
print "Target data count = {0}".format(len(target_results))
logger.info("Target data count = {0}".format(len(target_results)))
print "3. Execute HMD"
logger.info("3. Execute HMD")
proc_list = list()
split_cnt = len(target_results) / 60
for idx in range(0, len(target_results), split_cnt):
proc = Process(target=extract_call_driver_quality_hmd, args=(
logger, idx, call_date, target_results[idx:split_cnt+idx]), )
proc_list.append(proc)
proc.start()
for proc in proc_list:
proc.join()
else:
print "No target data"
logger.info("No target data")
print "END.. Start time = {0}, The time required = {1}".format(ST, elapsed_time(DT))
logger.info("END.. Start time = {0}, The time required = {1}".format(ST, elapsed_time(DT)))
logger.info("-" * 100)
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- ERROR ----------"
logger.error(exc_info)
logger.error("---------- ERROR ----------")
print "END.. Start time = {0}, The time required = {1}".format(ST, elapsed_time(DT))
logger.info("END.. Start time = {0}, The time required = {1}".format(ST, elapsed_time(DT)))
logger.info("-" * 100)
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
def processing(target_call_date):
"""
Processing
:param target_call_date: Target call date
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': CONFIG['log_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
# Connect db
try:
oracle = connect_db(logger)
if not oracle:
print "---------- Can't connect db ----------"
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- Can't connect db ----------"
logger.error(exc_info)
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
try:
call_date = "{0}-{1}-{2}".format(target_call_date[:4], target_call_date[4:6], target_call_date[6:])
logger.info("START.. Call date = {0}".format(call_date))
oracle.delete_statistics_data(call_date)
# 고객상담지원
agent_quality_result = oracle.select_agent_quality_result(call_date)
ruser_dict = dict()
for item in agent_quality_result:
ruser_id = item[1]
ruser_name = item[2]
rate = item[3]
speed = item[8]
silence_cnt = item[9]
key = '{0}_{1}'.format(ruser_id, ruser_name)
if key not in ruser_dict:
ruser_dict[key] = {
'TOTAL_SPEED': 0,
'SPEED_CNT': 0,
'TOTAL_SILENCE': 0,
'TOTAL_RATE': 0,
'RATE_CONT': 0,
'RESULT': item
}
if speed:
ruser_dict[key]['TOTAL_SPEED'] += float(speed)
ruser_dict[key]['SPEED_CNT'] += 1
if silence_cnt:
ruser_dict[key]['TOTAL_SILENCE'] += int(silence_cnt)
if rate:
ruser_dict[key]['TOTAL_RATE'] += float(rate)
ruser_dict[key]['RATE_CNT'] += 1
modify_agent_quality_result = list()
for ruser_dict in ruser_dict.values():
call_id = ruser_dict['RESULT'][0]
ruser_id = ruser_dict['RESULT'][1]
ruser_name = ruser_dict['RESULT'][2]
ruser_dict['RATE_CNT'] = 1 if ruser_dict['RATE_CNT'] == 0 else ruser_dict['RATE_CNT']
rate = ruser_dict['TOTAL_RATE'] / ruser_dict['RATE_CNT']
cntc_user_depart_c = ruser_dict['RESULT'][4]
cntc_user_depart_nm = ruser_dict['RESULT'][5]
cntc_user_part_c = ruser_dict['RESULT'][6]
cntc_user_part_nm = ruser_dict['RESULT'][7]
ruser_dict['SPEED_CNT'] = 1 if ruser_dict['SPEED_CNT'] == 0 else ruser_dict['SPEED_CNT']
speed = ruser_dict['TOTAL_SPEED'] / ruser_dict['SPEED_CNT']
silence_cnt = ruser_dict['TOTAL_SILENCE']
modify_agent_quality_result.append((call_id, ruser_id, ruser_name, rate, cntc_user_depart_c,
cntc_user_depart_nm, cntc_user_part_c, cntc_user_part_nm, speed,
silence_cnt))
if modify_agent_quality_result:
logger.info("1. Start CS_AGENT_QUALITY_RESULT_TB [Target count = {0}]".format(len(modify_agent_quality_result)))
logger.info("1-1. Insert CS_STATISTICS_OF_CALL_TB")
oracle.insert_statistics_of_call_data(call_date, 'C', modify_agent_quality_result)
else:
logger.info("1. Start CS_AGENT_QUALITY_RESULT_TB [Target count = 0]")
# # 해피콜모니터링
# happy_call_result = oracle.select_happy_call_hmd_result(call_date)
# if happy_call_result:
# logger.info("2. Start CS_HAPPY_CALL_MT_DETAIL_TB [Target count = {0}]".format(len(agent_quality_result)))
# logger.info("2-1. Insert CS_STATISTICS_OF_CALL_TB")
# oracle.insert_statistics_of_call_data(call_date, 'H', happy_call_result)
# else:
# logger.info("2. Start CS_HAPPY_CALL_MT_DETAIL_TB [Target count = 0]")
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- ERROR ----------"
logger.error(exc_info)
logger.error("---------- ERROR ----------")
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
logger.info("END.. Start time = {0}, The time required = {1}".format(ST, elapsed_time(DT)))
logger.info("-" * 100)
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
def processing(target_call_date):
"""
Processing
:param target_call_date: Target call date
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': CONFIG['log_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
# Connect db
try:
oracle = connect_db(logger, 'Oracle')
if not oracle:
print "---------- Can't connect db ----------"
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- Can't connect db ----------"
logger.error(exc_info)
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
try:
call_date = "{0}-{1}-{2}".format(target_call_date[:4],
target_call_date[4:6],
target_call_date[6:])
logger.info(
"Select CS perfect sales call list. [Target date -> {0}]".format(
call_date))
target_results = oracle.select_perfect_sales_call_list(call_date)
if target_results:
for target_result in target_results:
process_id = target_result[0]
call_id = target_result[1]
ticket_id = target_result[2]
ruser_id = target_result[3]
cu_id = target_result[4]
cu_name_hash = target_result[5]
file_name = target_result[6]
logger.info(
"PROCESS_ID = {0}, CALL_ID = {1}, TICKET_ID = {2}, RUSER_ID = {3}, CU_ID = {4},"
" CU_NAME_HASH = {5}, FILE_NAME = {6}".format(
process_id, call_id, ticket_id, ruser_id, cu_id,
cu_name_hash, file_name))
meta_code = oracle.select_outbound_monitoring_task_tb(
call_date, ruser_id, cu_id, cu_name_hash)
if meta_code:
full_code = oracle.select_full_code(meta_code)
result = oracle.select_json_data(ticket_id)
# 완전 판매
if full_code == 'OM0010':
logger.info("Start perfect_sales_hmd")
model_params = 'perfect_sales_hmd'
load_meta_info_and_execute_hmd(oracle, call_date,
call_id, process_id,
result, model_params,
full_code)
# (임) 해피카모니터링
elif full_code == 'OM0002':
logger.info("Start OM_happycar_emp_hmd")
model_params = 'OM_happycar_emp_hmd'
load_meta_info_and_execute_hmd(oracle, call_date,
call_id, process_id,
result, model_params,
full_code)
else:
logger.error("Not define HMD [full_code = {0}".format(
full_code))
else:
logger.error(
"Can't select meta_code [CALL_DATE = {0}, RUSER_ID = {1}. CU_ID = {2},"
" CU_NAME_HASH = {3}".format(call_date, ruser_id,
cu_id, cu_name_hash))
else:
logger.info("No CS perfect sales call")
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- ERROR ----------"
logger.error(exc_info)
logger.error("---------- ERROR ----------")
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
logger.info("END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT)))
logger.info("-" * 100)
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
def processing(target_call_date):
"""
Processing
:param target_call_date: Target call date
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': CONFIG['log_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
# Connect db
try:
oracle = connect_db(logger, 'Oracle')
if not oracle:
print "---------- Can't connect db ----------"
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- Can't connect db ----------"
logger.error(exc_info)
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
try:
call_date = "{0}-{1}-{2}".format(target_call_date[:4],
target_call_date[4:6],
target_call_date[6:])
oracle.delete_summary_data(call_date)
# TM(PC0002), CS(PC0001) Multi CY0001
logger.info("Count type Multi CY0001")
for project_code in ['PC0001', 'PC0002']:
group_code = 'CJ' if project_code == 'PC0001' else 'TD'
business_dcd_list = oracle.select_business_dcd(group_code)
if business_dcd_list:
for business_dcd_result in business_dcd_list:
business_dcd = business_dcd_result[0]
result = oracle.select_call_driver_frequency_by_multi(
call_date, project_code, business_dcd)
logger.info(
"CALL_DATE = {0}, PROJECT_CODE = {1}, BUSINESS_DCD = {2}"
.format(call_date, project_code, business_dcd))
if result:
for item in result:
oracle.insert_frequent_summary_tb(
project_code=project_code,
business_dcd=business_dcd,
call_date=call_date,
count_type_code='CY0001',
category_1depth_id=item[0],
category_2depth_id=item[1],
category_3depth_id=item[2],
category_frequency=item[3])
else:
logger.error(
"Can't select business_dcd. [GROUP_CODE = {0}]".format(
group_code))
# TM(PC0002), CS(PC0001) Single CY0002
logger.info("Count type Single CY0002")
for project_code in ['PC0001', 'PC0002']:
group_code = 'CJ' if project_code == 'PC0001' else 'TD'
business_dcd_list = oracle.select_business_dcd(group_code)
if business_dcd_list:
for business_dcd_result in business_dcd_list:
business_dcd = business_dcd_result[0]
call_id_list = oracle.select_call_id(
call_date, project_code, business_dcd)
if call_id_list:
temp_dict = dict()
for item in call_id_list:
call_id = item[0]
result = oracle.select_call_driver_frequency_by_single(
call_date, project_code, call_id, business_dcd)
logger.info(
"CALL_DATE = {0}, PROJECT_CODE = {1}, BUSINESS_DCD = {2}"
.format(call_date, project_code, business_dcd))
if result:
key = "{0}_{1}_{2}".format(
result[0], result[1], result[2])
if key not in temp_dict:
temp_dict[key] = result[3]
else:
temp_dict[key] += result[3]
for key, frequency in temp_dict.items():
key_list = key.split('_')
oracle.insert_frequent_summary_tb(
project_code=project_code,
business_dcd=business_dcd,
call_date=call_date,
count_type_code='CY0002',
category_1depth_id=key_list[0],
category_2depth_id=key_list[1],
category_3depth_id=key_list[2],
category_frequency=frequency)
else:
logger.error(
"Can't select business_dcd. [GROUP_CODE = {0}]".format(
group_code))
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- ERROR ----------"
logger.error(exc_info)
logger.error("---------- ERROR ----------")
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
logger.info("END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT)))
logger.info("-" * 100)
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
def processing(target_call_date):
"""
Processing
:param target_call_date: Target call date
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': CONFIG['log_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
# Connect db
try:
oracle = connect_db(logger, 'Oracle')
if not oracle:
print "---------- Can't connect db ----------"
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- Can't connect db ----------"
logger.error(exc_info)
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
try:
start_date = "{0}-{1}-{2}".format(target_call_date[:4],
target_call_date[4:6],
target_call_date[6:])
end_date = "{0} 23:59:59".format(start_date)
select_top_cnt = CONFIG['select_top_cnt']
relation_top_cnt = CONFIG['relation_top_cnt']
logger.info(
"Call date = {0}, Select top count = {1}, Relation top count = {2}"
.format(start_date, select_top_cnt, relation_top_cnt))
oracle.delete_frequent_data(start_date)
oracle.delete_related_data(start_date)
# CS (PC0001) , TM (PC0002)
for project_code in ['PC0001', 'PC0002']:
group_code = 'CJ' if project_code == 'PC0001' else 'TD'
business_dcd_list = oracle.select_business_dcd(group_code)
if business_dcd_list:
for item in business_dcd_list:
business_dcd = item[0]
for speaker_code in ['ST0001', 'ST0002']:
logger.info(
"PROJECT_CODE = {0}, SPEAKER_CODE = {1}, BUSINESS_DCD = {2}"
.format(project_code, speaker_code, business_dcd))
logger.info("1. Execute base on the word")
oracle.disconnect()
oracle = connect_db(logger, 'Oracle')
based_on_the_word(logger=logger,
oracle=oracle,
speaker_code=speaker_code,
project_code=project_code,
business_dcd=business_dcd,
start_date=start_date,
end_date=end_date,
select_top_cnt=select_top_cnt,
relation_top_cnt=relation_top_cnt)
logger.info("2. Execute base on the document")
oracle.disconnect()
oracle = connect_db(logger, 'Oracle')
based_on_the_document(
logger=logger,
oracle=oracle,
speaker_code=speaker_code,
project_code=project_code,
business_dcd=business_dcd,
start_date=start_date,
end_date=end_date,
select_top_cnt=select_top_cnt,
relation_top_cnt=relation_top_cnt)
else:
logger.error("Can't select business dcd")
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- ERROR ----------"
logger.error(exc_info)
logger.error("---------- ERROR ----------")
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
logger.info("END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT)))
logger.info("-" * 100)
oracle.disconnect()
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
def processing(target_call_date):
"""
Processing
:param target_call_date: Target call date
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': CONFIG['log_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
# Connect db
try:
oracle = connect_db(logger, 'Oracle')
if not oracle:
print "---------- Can't connect db ----------"
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- Can't connect db ----------"
logger.error(exc_info)
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
# Execute
try:
model_params = 'calltransfer_hmd'
call_date = "{0}-{1}-{2}".format(target_call_date[:4],
target_call_date[4:6],
target_call_date[6:])
print "CALL_DATE = {0}, HMD = {1}".format(call_date, model_params)
logger.info("CALL_DATE = {0}, HMD = {1}".format(
call_date, model_params))
print "1. Select target data"
logger.info("1. Select target data")
target_results = oracle.select_call_transfer_call_list(call_date)
oracle.disconnect()
if target_results:
print "Target data count = {0}".format(len(target_results))
logger.info("Target data count = {0}".format(len(target_results)))
print "2. Execute HMD"
logger.info("2. Execute HMD")
proc_list = list()
split_cnt = len(target_results) / 10
manager = Manager()
return_dict = manager.dict()
pro_id = 0
for idx in range(0, len(target_results), split_cnt):
proc = Process(
target=extract_call_transfer_hmd,
args=(logger, idx, pro_id, model_params,
target_results[idx:split_cnt + idx], return_dict),
)
proc_list.append(proc)
proc.start()
pro_id += 1
for proc in proc_list:
proc.join()
return_list = list()
for item in return_dict.values():
return_list += item
print "Total return : {0}".format(len(return_list))
logger.info("Total return : {0}".format(len(return_list)))
print "3. Delete data"
logger.info("3. Delete data")
oracle = connect_db(logger, 'Oracle')
oracle.delete_call_transfer_hmd_result(call_date)
# Insert call transfer hmd result
insert_result_data(logger, oracle, call_date, return_list)
oracle.disconnect()
else:
print "No CS target data"
logger.info("No CS target data")
print "END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT))
logger.info("END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT)))
logger.info("-" * 100)
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- ERROR ----------"
logger.error(exc_info)
logger.error("---------- ERROR ----------")
print "END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT))
logger.info("END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT)))
logger.info("-" * 100)
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
def processing(target_call_date, pro_code):
"""
Processing
:param target_call_date: Target call date
:param pro_code: PROJECT_CODE
"""
# Add logging
logger_args = {
'base_path': CONFIG['log_dir_path'],
'log_file_name': pro_code + "_" + CONFIG['log_name'],
'log_level': CONFIG['log_level']
}
logger = set_logger_period_of_time(logger_args)
# Connect db
try:
oracle = connect_db(logger, 'Oracle')
if not oracle:
print "---------- Can't connect db ----------"
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- Can't connect db ----------"
logger.error(exc_info)
logger.error("---------- Can't connect db ----------")
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
# Execute
try:
project_code = 'PC0001' if pro_code == 'CS' else 'PC0002'
model_params = 'interest_section_cs_hmd' if pro_code == 'CS' else 'interest_section_tm_hmd'
call_date = "{0}-{1}-{2}".format(target_call_date[:4],
target_call_date[4:6],
target_call_date[6:])
print "CALL_DATE = {0}, PROJECT_CODE = {1}, HMD = {2}".format(
call_date, project_code, model_params)
logger.info("CALL_DATE = {0}, PROJECT_CODE = {1}, HMD = {2}".format(
call_date, project_code, model_params))
print "1. Select target data"
logger.info("1. Select target data")
target_results = oracle.select_interest_section_call_list(
call_date, project_code)
oracle.disconnect()
if target_results:
print "{0} target data count = {1}".format(pro_code,
len(target_results))
logger.info("{0} target data count = {1}".format(
pro_code, len(target_results)))
print "2. Execute HMD"
logger.info("2. Execute HMD")
proc_list = list()
split_cnt = len(target_results) / 10
manager = Manager()
return_dict = manager.dict()
pro_id = 0
for idx in range(0, len(target_results), split_cnt):
proc = Process(
target=extract_interest_section_hmd,
args=(logger, idx, pro_id, model_params,
target_results[idx:split_cnt + idx], return_dict),
)
proc_list.append(proc)
proc.start()
pro_id += 1
for proc in proc_list:
proc.join()
return_list = list()
for item in return_dict.values():
return_list += item
print "Total return : {0}".format(len(return_list))
logger.info("Total return : {0}".format(len(return_list)))
# Make start point information
start_point_dict = dict()
for hmd_result, temp_dict in return_list:
call_id = temp_dict['call_id']
sentence_id = temp_dict['sentence_id']
start_time = temp_dict['start_time']
if not call_id in start_point_dict:
start_point_dict[call_id] = dict()
for cls in hmd_result.keys():
cat_list = cls.split('_')
if len(cat_list) != 3:
continue
section_code, section_number, cust_yn = cat_list
if section_number == '001':
if not section_code in start_point_dict[call_id]:
start_point_dict[call_id][section_code] = [
sentence_id, start_time
]
oracle = connect_db(logger, 'Oracle')
print "3. Make interest section output"
logger.info("3. Make interest section output")
output_dict = make_interest_section_hmd_result(
oracle, return_list, start_point_dict)
print "4. Delete data."
logger.info("4. Delete data.")
oracle.delete_interest_section_hmd_result(call_date, project_code)
# Insert interest section hmd result
insert_result_data(logger, oracle, call_date, project_code,
output_dict)
oracle.disconnect()
else:
print "No {0} target data".format(pro_code)
logger.info("No {0} target data".format(pro_code))
print "END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT))
logger.info("END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT)))
logger.info("-" * 100)
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
except Exception:
exc_info = traceback.format_exc()
print exc_info
print "---------- ERROR ----------"
logger.error(exc_info)
logger.error("---------- ERROR ----------")
print "END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT))
logger.info("END.. Start time = {0}, The time required = {1}".format(
ST, elapsed_time(DT)))
logger.info("-" * 100)
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
sys.exit(1)
