def get_tag(obj, E): try: data = [] dictionary = {} for item in obj: if type(obj[item]) == dict: data.append(E(item, *get_tag(obj[item], E))) elif type(obj[item]) == list: for i in obj[item]: data.append(E(item, *get_tag(i, E))) else: dictionary[item] = obj[item] data.append(dictionary) return data # Handle other exception (i.e. internal server error) except: # Get exception: other_exception = str(sys.exc_info()[1]) # Build error from exception: other_error = Error(_Pauli_Constants.HTTP_CODES['INTERNAL'], _Pauli_Constants.ERROR_MESSAGES['INTERNAL']) # Log exception/error: logger.critical(other_error.content + other_exception) # Exception was already handled (i.e. error was built and logged int this except) so it is transformed into an already handled exception: already_handled_exception = Already_Handled_Exception(other_error) # Raise exception to outer except(s): raise already_handled_exception
def instance_to_dict(obj): try: if isinstance(obj, _SAT_data.SAT_TYPE): dictionary = instance_to_dict(obj.__dict__) if type(obj) == dict: dictionary = {} for item in obj: dictionary.update({item: instance_to_dict(obj[item])}) elif type(obj) == list: dictionary = [] for i in obj: dictionary.append(instance_to_dict(i)) elif type(obj) == unicode or type(obj) == int or type(obj) == str: dictionary = obj else: dictionary = instance_to_dict(obj.__dict__) return dictionary # Handle other exception (i.e. internal server error) except: # Get exception: other_exception = str(sys.exc_info()[1]) # Build error from exception: other_error = Error(_Pauli_Constants.HTTP_CODES['INTERNAL'], _Pauli_Constants.ERROR_MESSAGES['INTERNAL']) # Log exception/error: logger.critical(other_error.content + other_exception) # Exception was already handled (i.e. error was built and logged int this except) so it is transformed into an already handled exception: already_handled_exception = Already_Handled_Exception(other_error) # Raise exception to outer except(s): raise already_handled_exception
def translate(dictionary, tr): try: new = {} for item in dictionary: if type(dictionary[item]) == dict: new[tr[item]] = translate(dictionary[item], tr) elif type(dictionary[item]) == list: new[tr[item]] = [] for i in dictionary[item]: new[tr[item]].append(translate(i, tr)) else: new[tr[item]] = dictionary[item] return new # Handle other exception (i.e. internal server error) except: # Get exception: other_exception = str(sys.exc_info()[1]) # Build error from exception: other_error = Error(_Pauli_Constants.HTTP_CODES['INTERNAL'], _Pauli_Constants.ERROR_MESSAGES['INTERNAL']) # Log exception/error: logger.critical(other_error.content + other_exception) # Exception was already handled (i.e. error was built and logged int this except) so it is transformed into an already handled exception: already_handled_exception = Already_Handled_Exception(other_error) # Raise exception to outer except(s): raise already_handled_exception
def log_sl1_thread_logs_at_sl1_main_logs(sl1_execution_log=None, sl1_logger=sl1_logger, cron_logger=cron_logger): try: current_taxpayer_index = sl1_execution_log['current_taxpayer_index'] total_taxpayers = sl1_execution_log['total_taxpayers'] end = sl1_execution_log['end'] current_table_row = sl1_execution_log['current_table_row'] lock = sl1_execution_log['lock'] total_percentage_done = _Utilities.get_process_percentage_done( current_taxpayer_index, total_taxpayers) sl1_execution_log['percentage_done'] = total_percentage_done with lock: current_table_row.value = current_table_row.value + 1 if current_table_row.value >= SL1_LOGGING_CONFIG['table_row_limit']: with lock: current_table_row.value = 0 begin_table_row = _Utilities.format_log(SL1_TABLE_TITLES, SL1_TABLE_FIELD_LENGTHS, begin=True) sl1_logger.info('', extra=begin_table_row) sl1_execution_log = _Utilities.format_log(sl1_execution_log, SL1_TABLE_FIELD_LENGTHS) sl1_logger.info('', extra=sl1_execution_log) if end is True: end_table_row = _Utilities.format_log(DEFAULT_LOG, SL1_TABLE_FIELD_LENGTHS, end=True) sl1_logger.info('', extra=end_table_row) end_message = sl1_execution_log['end_message'] sl1_logger.info(end_message, extra=DEFAULT_LOG) except Exception as e: sl1_logger.critical(e.message) already_handled_exception = Already_Handled_Exception(e.message) raise already_handled_exception
def generate_simple_xml(dictionary, document_type): try: ROOT = _SAT_data.ROOT[document_type] NSMAP = _SAT_data.NSMAP[document_type] NAMESPACE = _SAT_data.NAMESPACE[document_type] XSD = _SAT_data.XSD[document_type] E = ElementMaker(namespace=NSMAP[NAMESPACE], nsmap=NSMAP) xml = E(ROOT, *get_tree(dictionary, E, NSMAP, XSD)) return xml # Exception was already handled (i.e. error was built and logged in a deeper except) so it just raised to outer excepts(s): except Already_Handled_Exception as already_handled_exception: # Raise exception to outer except(s) raise already_handled_exception # Handle other exception (i.e. internal server error) except: # Get exception: other_exception = str(sys.exc_info()[1]) # Build error from exception: other_error = Error(_Pauli_Constants.HTTP_CODES['INTERNAL'], _Pauli_Constants.ERROR_MESSAGES['INTERNAL']) # Log exception/error: logger.critical(other_error.content + other_exception) # Exception was already handled (i.e. error was built and logged int this except) so it is transformed into an already handled exception: already_handled_exception = Already_Handled_Exception(other_error) # Raise exception to outer except(s): raise already_handled_exception
def get_credentials(identifier, certificates): try: credentials_folder = _Constants.IDENTIFIER_PATH + identifier + '/' + _Constants.CREDENTIALS_FOLDER + '/' logger.info(certificates) credentials = { 'pem_file': credentials_folder + identifier + '_EAC.pem', 'cer_file': credentials_folder + certificates['cer_file'], 'key_file': credentials_folder + certificates['key_file'], 'password': certificates['password'] } return credentials # Handle other exception (i.e. internal server error) except: # Get exception: other_exception = str(sys.exc_info()[1]) # Build error from exception: other_error = Error(_Pauli_Constants.HTTP_CODES['INTERNAL'], _Pauli_Constants.ERROR_MESSAGES['INTERNAL']) # Log exception/error: logger.critical(other_error.content + other_exception) # Exception was already handled (i.e. error was built and logged int this except) so it is transformed into an already handled exception: already_handled_exception = Already_Handled_Exception(other_error) # Raise exception to outer except(s): raise already_handled_exception
def new_synchronization_layer_1_log(logger=None): try: synchronization_layer_1_log = { 'forest_db': { 'before': { 'good': 0, 'pending': 0 }, 'after': { 'new': 0, 'pending_completed': 0, 'pending': 0, 'updated': 0 } }, 'firmware': { 'new': 0, 'update': 0 } } # End of synchronization_layer_1_log return synchronization_layer_1_log except Exception as e: logger.critical(e.message) already_handled_exception = Already_Handled_Exception(e.message) raise already_handled_exception
def set_xml_to_pending_cfdi(cfdi, logger=None, sl1_execution_log=None): try: forest_db = _Utilities.set_connection_to_forest_db() db_CFDI = forest_db['CFDI'] uuid = cfdi['uuid'] # Get xml data: xml = cfdi['xml'] validation = _Pauli_Helper.validate_xml(xml) xml_warnings = validation['warnings'] xml_invalidations = validation['invalidations'] # Updating data: updating_cfdi_data = { 'xml': xml, 'validated': True if validation['validated'] else False, 'details': { 'invalidations': xml_invalidations, 'warnings': xml_warnings } # End of details } #End of updating_cfdi_data db_CFDI.update({'uuid': uuid}, {'$set': updating_cfdi_data}) sl1_execution_log['forest_db']['after'][ 'pending_completed'] = sl1_execution_log['forest_db']['after'][ 'pending_completed'] + 1 except Exception as e: logger.critical(e.message) already_handled_exception = Already_Handled_Exception(e.message) raise already_handled_exception
def get_tree(dictionary, E, NSMAP, XSD): try: schemaLocation_tag = {'{' + NSMAP['xsi'] + '}schemaLocation': XSD} tags = get_tag(dictionary, E) tree = [schemaLocation_tag] + tags return tree # Exception was already handled (i.e. error was built and logged in a deeper except) so it just raised to outer excepts(s): except Already_Handled_Exception as already_handled_exception: # Raise exception to outer except(s) raise already_handled_exception # Handle other exception (i.e. internal server error) except: # Get exception: other_exception = str(sys.exc_info()[1]) # Build error from exception: other_error = Error(_Pauli_Constants.HTTP_CODES['INTERNAL'], _Pauli_Constants.ERROR_MESSAGES['INTERNAL']) # Log exception/error: logger.critical(other_error.content + other_exception) # Exception was already handled (i.e. error was built and logged int this except) so it is transformed into an already handled exception: already_handled_exception = Already_Handled_Exception(other_error) # Raise exception to outer except(s): raise already_handled_exception
def generate_pem_file(identifier, credentials): try: key_file = credentials['key_file'] password = credentials['password'] file_path = credentials['pem_file'] params_process = [ 'openssl', 'pkcs8', '-inform', 'DET', '-in', key_file, '-passin', 'pass:'******'-out', file_path ] return execute_popen_process(params_process) # Exception was already handled (i.e. error was built and logged in a deeper except) so it just raised to outer excepts(s): except Already_Handled_Exception as already_handled_exception: # Raise exception to outer except(s) raise already_handled_exception # Handle other exception (i.e. internal server error) except: # Get exception: other_exception = str(sys.exc_info()[1]) # Build error from exception: other_error = Error(_Pauli_Constants.HTTP_CODES['INTERNAL'], _Pauli_Constants.ERROR_MESSAGES['INTERNAL']) # Log exception/error: logger.critical(other_error.content + other_exception) # Exception was already handled (i.e. error was built and logged int this except) so it is transformed into an already handled exception: already_handled_exception = Already_Handled_Exception(other_error) # Raise exception to outer except(s): raise already_handled_exception
def stamp_xml(identifier, document_type, xml_without_stamp, certificates): try: credentials = get_credentials(identifier, certificates) # if not os.path.isfile(credentials['pem_file']): # out = generate_pem_file(identifier,credentials) # logger.info(out) out = generate_pem_file(identifier, credentials) logger.info(out) serial_number = get_serial_number(credentials['cer_file']) keys = RSA.load_key(credentials['pem_file']) cert_file = open(credentials['cer_file'], 'r') cert = base64.b64encode(cert_file.read()) xml = xml_without_stamp xsl_root = ET.parse(_SAT_data.XSLT[document_type]) xsl = ET.XSLT(xsl_root) cadena_original = xsl(xml) digest = hashlib.new('sha1', str(cadena_original)).digest() sello = base64.b64encode(keys.sign(digest, "sha1")) xml.attrib['Sello'] = sello xml.attrib['Certificado'] = cert xml.attrib['noCertificado'] = serial_number xml_with_stamp = ET.tostring(xml, pretty_print=True, xml_declaration=True, encoding='UTF-8') logger.info(xml_with_stamp) return xml_with_stamp # Exception was already handled (i.e. error was built and logged in a deeper except) so it just raised to outer excepts(s): except Already_Handled_Exception as already_handled_exception: # Raise exception to outer except(s) raise already_handled_exception # Handle other exception (i.e. internal server error) except: # Get exception: other_exception = str(sys.exc_info()[1]) # Build error from exception: other_error = Error(_Pauli_Constants.HTTP_CODES['INTERNAL'], _Pauli_Constants.ERROR_MESSAGES['INTERNAL']) # Log exception/error: logger.critical(other_error.content + other_exception) # Exception was already handled (i.e. error was built and logged int this except) so it is transformed into an already handled exception: already_handled_exception = Already_Handled_Exception(other_error) # Raise exception to outer except(s): raise already_handled_exception
def update_synchronization_data_for_taxpayer(taxpayer, sl1_execution_log, logger=None): try: forest_db = _Utilities.set_connection_to_forest_db() db_Taxpayer = forest_db['Taxpayer'] # Update sl1 success execution date: sl1_date = STATUS_DATES['synchronization_layer_1'] synchronization_date = Datetime.now() taxpayer[sl1_date] = synchronization_date # Update synchronization logs: identifier = taxpayer['identifier'] begin_date = taxpayer[ 'start_date'] #Since taxpayer claim to be synchronized begin_date = begin_date.replace(hour=0, minute=0) end_date = synchronization_date # Until now cfdis_in_forest_db_count = _Utilities.get_cfdis_count_in_forest_for_this_taxpayer_at_period( taxpayer, begin_date, end_date) synchronization_log = { 'status': 200, 'temporal_data': { 'completed_date': synchronization_date, 'period': { 'year': synchronization_date.year, 'month': synchronization_date.month }, }, 'cfdis': { 'new': sl1_execution_log['stored'], 'updated': sl1_execution_log['updated'], 'total': cfdis_in_forest_db_count } # End of synchronization_log } # End of synchronization_log taxpayer_logs = taxpayer['logs'] if 'logs' in taxpayer and taxpayer[ 'logs'] is not None else {} taxpayer_synchronization_logs = taxpayer_logs[_Constants.SYNCHRONIZATION] if _Constants.SYNCHRONIZATION in taxpayer_logs else [] taxpayer_synchronization_logs.append(synchronization_log) if len(taxpayer_synchronization_logs ) > _Constants.LIMIT_LOGS_PER_TAXPAYER: taxpayer_synchronization_logs[:1] = [] taxpayer_logs[ _Constants.SYNCHRONIZATION] = taxpayer_synchronization_logs taxpayer['logs'] = taxpayer_logs db_Taxpayer.save(taxpayer) except Exception as e: if logger is not None: logger.critical(e.message) already_handled_exception = Already_Handled_Exception(e.message) raise already_handled_exception
def main(argv): try: cron_logger.info('FOREST-CRON PROCESS CALLED') cron_logger.info(LOG_INDENT + 'Getting command line params ... ') process = get_command_line_params(argv) if 'debug' in process: cron_logger.info(LOG_INDENT + 'Running in debug mode ... ') cron_logger.info(LOG_INDENT + 'Calling process handler ... ') _Processes_Handler.execute(process) except Already_Handled_Exception as already_handled_exception: raise already_handled_exception except Exception as e: cron_logger.critical(e.message) already_handled_exception = Already_Handled_Exception(e.message) return already_handled_exception
def get_pending_uuids_in_forest_db(pending_cfdis_in_db=None, logger=None, sl1_execution_log=None): try: pending_cfdi_uuids = {} for pending_cfdi_in_db in pending_cfdis_in_db: uuid = pending_cfdi_in_db['uuid'] pending_cfdi_uuids[uuid] = True number_of_pending_cfdi_uuids = len(pending_cfdi_uuids) sl1_execution_log['forest_db']['before'][ 'pending'] = number_of_pending_cfdi_uuids return pending_cfdi_uuids except Exception as e: logger.critical(e.message) already_handled_exception = Already_Handled_Exception(e.message) raise already_handled_exception
def get_existing_uuids_in_forest_db(cfdis_in_db=None, logger=None, sl1_execution_log=None): try: existing_cfdi_uuids = [] for cfdi_in_db in cfdis_in_db: uuid = cfdi_in_db['uuid'] status = cfdi_in_db['status'] existing_uuid = { 'uuid': uuid, 'status': status } # End of existing_uuid existing_cfdi_uuids.append(existing_uuid) number_of_existing_cfdi_uuids = len(existing_cfdi_uuids) sl1_execution_log['forest_db']['before'][ 'good'] = number_of_existing_cfdi_uuids return existing_cfdi_uuids except Exception as e: logger.critical(e.message) already_handled_exception = Already_Handled_Exception(e.message) raise already_handled_exception
def chart_of_accounts(params): try: logger.info(_Pauli_Constants.FUNCTION_EXECUTION_BEGINNING_MESSAGE) # ... C o d e m o n k e y ... certificates = params['certificates'] # Instance class COA = Chart_of_Accounts(params) # GET stamp_xml xml = COA.get_xml(certificates) logger.info(_Pauli_Constants.FUNCTION_EXECUTION_ENDING_MESSAGE) return xml # Exception was already handled (i.e. error was built and logged in a deeper except) so it just raised to outer excepts(s): except Already_Handled_Exception as already_handled_exception: # Raise exception to outer except(s) raise already_handled_exception # Handle other exception (i.e. internal server error) except: # Get exception: other_exception = str(sys.exc_info()[1]) # Build error from exception: other_error = Error(_Pauli_Constants.HTTP_CODES['INTERNAL'], _Pauli_Constants.ERROR_MESSAGES['INTERNAL']) # Log exception/error: logger.critical(other_error.content + other_exception) # Exception was already handled (i.e. error was built and logged int this except) so it is transformed into an already handled exception: already_handled_exception = Already_Handled_Exception(other_error) # Raise exception to outer except(s): raise already_handled_exception
def set_cancelled_status_to_cfdi(cfdi, updated_cfdi, logger=None, sl1_execution_log=None): try: forest_db = _Utilities.set_connection_to_forest_db() db_CFDI = forest_db['CFDI'] cfdi['status'] = updated_cfdi['status'] # Equalize status if 'cancelation_date' in updated_cfdi: cfdi['cancelation_date'] = _Helper.sat_date_to_ISODate( updated_cfdi['cancelation_date']) xml_exists = 'xml' in cfdi and cfdi['xml'] != '' if not xml_exists: cfdi['xml'] = _Helper.build_default_xml( cfdi['seller'], cfdi['buyer'], cfdi['certification_date'], cfdi['issued_date'], cfdi['voucher_effect'], cfdi['uuid']) sl1_execution_log['forest_db']['after'][ 'updated'] = sl1_execution_log['forest_db']['after']['updated'] + 1 db_CFDI.save(cfdi) except Exception as e: logger.critical(e.message) already_handled_exception = Already_Handled_Exception(e.message) raise already_handled_exception