def processArticles(self, listOfURLs, domain): #======================================================================= # CREATE XPATH LIST FOR TRAINING #======================================================================= for url in listOfURLs: print 'Processing ', url rd = createDom(url=url) rd.readDOMrecursive() pickleFilePath = self.__filesFolder+str(domain) if os.path.isfile(pickleFilePath+'.json'): xpathValues = json.load(open(pickleFilePath+'.json', 'rb')) z = xpathValues.copy() z.update(rd._createDom__domDict) xml = dicttoxml.dicttoxml(z) f= open(pickleFilePath+'.xml', 'wb') f.write(xml) f.close() json.dump(z, open(pickleFilePath+'.json', 'wb')) else: json.dump(rd._createDom__domDict, open(pickleFilePath+'.json', 'wb')) xml = dicttoxml.dicttoxml(rd._createDom__domDict) f= open(pickleFilePath+'.xml', 'wb') f.write(xml) f.close()
def _wrap_xml_output(self, gmeta_dict, timestamp): import dicttoxml from lxml import etree keys_to_drop = ["@context", "subject", "frdr:geospatial"] parser = etree.XMLParser(remove_blank_text=True, recover=True) xml_tree = etree.parse("schema/stub.xml", parser=parser) root_tag = xml_tree.getroot() context_block = gmeta_dict[0]["content"]["@context"] context_xml = etree.fromstring(dicttoxml.dicttoxml(context_block, attr_type=False, custom_root='schema'), parser=parser) root_tag.insert(0, context_xml) control_block = {"timestamp": int(round(time.mktime(timestamp))), "datestamp": time.strftime("%Y-%m-%d %H:%M:%S UTC", timestamp)} control_xml = etree.fromstring(dicttoxml.dicttoxml(control_block, attr_type=False, custom_root='generated'), parser=parser) root_tag.insert(0, control_xml) recordtag = xml_tree.find(".//records") for entry in gmeta_dict: xml_dict = self.change_keys(entry["content"], keys_to_drop) xml_dict["id"] = entry["id"] xml_dict["visible_to"] = entry["visible_to"] try: record_xml = etree.fromstring( dicttoxml.dicttoxml(xml_dict, attr_type=False, custom_root='record', item_func=self.xml_child_namer), parser=parser) recordtag.append(record_xml) except: self.logger.debug("Error converting dict to XML: {}".format(entry["id"])) return xml_tree
def xml_format(labels, results): final = [ dict(zip(labels,item)) for item in results] try: response = HttpResponse(dicttoxml(final), mimetype='application/text') except: response = HttpResponse(dicttoxml(final), content_type='application/text') return response
def prettyxml(target): '''Takes in a target database object and returns cleanly formatted XML''' try: x = dicttoxml(t.serialize for t in target) except: x = dicttoxml(target.serialize) response = make_response(x) response.headers['Content-Type'] = 'application/xml' return response
def to_xml(*args, **kwargs): response.set_header("Content-Type", "text/xml") try: return dicttoxml( callable_(*args, **kwargs), custom_root="data" ) except Exception as e: logger.exception("Error on route: {0}".format(route_)) return dicttoxml({"error": str(e)}, custom_root="data")
def __parseComments(self): result = {} messages = [] #get total count of comments response = self.graph.get_object(self.id+"/comments?summary=1&filter=toplevel&limit=250") xml = dicttoxml.dicttoxml(response) output = open(self.filename,'w') output.write(xml) output.close() flag = True while flag: try: xmldoc = minidom.parse(self.filename) os.remove(self.filename) total_counts = xmldoc.getElementsByTagName('total_count') if len(total_counts): result['total_count'] = total_counts[0].firstChild.data else: result['total_count'] = None #get up to 250 comments in a page #print result['total_count'] #print xmldoc.toxml() if result['total_count'] != None and result['total_count']: message = xmldoc.getElementsByTagName('message') for x in xrange(0,message.length): #print x if message[x].firstChild != None: messages.append(message[x].firstChild.data) link = self.getNext() if link !=None: r = requests.get(link) response = r.json() self.xml = dicttoxml.dicttoxml(response) output = open(self.filename,'w') output.write(self.xml) output.close() else: flag = False except Exception,e: # log = open("ErrorLog","a") # if not log : # log = open("ErrorLog","w") # frameinfo = inspect.getframeinfo(inspect.currentframe()) # log.write(frameinfo.filename+"#"+frameinfo.lineno+"\n") # log.write(e+"\n") # log.close() print "Error %s" % e #print response['summary']['total_count'] result['total_count'] = response['summary']['total_count'] data = response['data'] for x in xrange(0,len(data)): messages.append(data[x]['message']) #result['messages'] = messages finally:
def as_xml(_request, response, content_type): """Return http response object in XML format. """ if hasattr(response, 'root'): xml = dicttoxml.dicttoxml(response[response.root], root=False) else: xml = dicttoxml.dicttoxml(response, root=False) xml = ('<?xml version="1.0" encoding="UTF-8" ?>\n' '<{root}>{document}</{root}>'.format( root=getattr(response, 'root', 'root'), document=xml)) if settings.DEBUG: xml = parseString(xml).toprettyxml() return HttpResponse(xml, content_type, status=response['_meta']['status'])
def format_context(self, context): """ Function to format context that will be returned to http response :param context: context that will be formatted :type context: dict :return: formatted context :rtype: str """ if self.format == 'xml': output = dicttoxml.dicttoxml(context) elif self.format == 'geojson': if not isinstance(context, list): context = [context] output = json.dumps( {'type': 'FeatureCollection', 'features': context}, cls=DjangoJSONEncoder ) else: output = json.dumps(context, cls=DjangoJSONEncoder) output.replace('|', ',') return output
def showOne(region_id): catalog_mode = request.args.get('catalog') xml_format = request.args.get('xml') region_list = db_session.query(Region).filter( Region.id == region_id).all() # Check if query parameters were added to the request if (catalog_mode == 'true' or catalog_mode == 'TRUE'): # Get single region's catalog regions = [] for i in region_list: recipes = [] for recipe in i.region_recipes: recipes.append(recipe.serialize) region = i.serialize region['recipes'] = recipes regions.append(region) serialized_result = [regions] else: # Get single region serialized_result = [i.serialize for i in region_list] # Lastly we decide which data format to send if (xml_format == 'true' or xml_format == 'TRUE'): xml_output = dicttoxml.dicttoxml(serialized_result) return xml_output, 200, {'Content-Type': 'text/xml; charset=utf-8'} else: return jsonify(collection=serialized_result)
def xml_leaf_nodes(): list = execute_query("""SELECT browse_node_name, browse_node_id FROM browse_nodes WHERE leaf = TRUE """) nodes_dict = [{'name': x[0], 'id': x[1]} for x in list] return dicttoxml.dicttoxml({"leaf_nodes": nodes_dict})
def write_xml(data, file_name): #TO-DO: write the data to an xml tree and save in a file print('Working on it') tree = dicttoxml.dicttoxml(data) f = open("data/" + file_name + ".xml", 'a') print >> f, tree f.close()
def DemoApi(request): # Demo API application_title = settings.APPLICATION_TITLE DEBUG = settings.DEBUG_SETTINGS if DEBUG: print(application_title, "in demo.views.DemoApi") fhir_server_url = "http://localhost:8080/fhir-p/" fhir_server_param = "baseDstu2/Patient/1/$everything?_format=json" data = json.dumps({}) r = requests.get(fhir_server_url+fhir_server_param, ) #print(r.json) #print(r.content) result = r.content result_content = json.loads(r.content) #result = result["resource"] result = json.dumps(result_content, indent=4, ) xmlresult = dicttoxml.dicttoxml(result_content) dom = parseString(xmlresult) #print(dom.toprettyxml()) context = {"APPLICATION_TITLE": application_title,"result": result, "xmlresult": dom.toprettyxml(), "url": fhir_server_url, "params": fhir_server_param } return render_to_response('demo/demoapi.html', RequestContext(request, context))
def restaurantMenuXML(restaurant_id): restaurant = session.query(Restaurant).filter_by( id=restaurant_id).one() items = session.query(MenuItem).filter_by( restaurant_id=restaurant_id).all() response = make_response(dicttoxml({'items': [i.serialize for i in items]}), 200) return response, 200, {'Content-Type': 'text/css; charset=utf-8'}
def bookListXML(city_id): city = session.query(City).filter_by(id = city_id).one() books = session.query(Book).filter_by( city_id=city.id).all() response = make_response(dicttoxml({'Books':[b.serialize for b in books]}), 200) response.headers['Content-Type'] = 'application/xml' return response
def processLog(sourceFile, destFile): destDict = dict() file = open(sourceFile, 'r', encoding='utf8') sourceDict = xmltodict.parse(file.read()) sourceDict = sourceDict["Tournament"] file.close() destDict["header"] = dict() destDict["header"]["date"] = sourceDict["Date"] games = list() createMatchesFromRoundsDict(sourceDict["Rounds"], games) if "Playoffs" in sourceDict: createMatchesFromPlayoffDict(sourceDict["Playoffs"], games) if "Playoffs16" in sourceDict: createMatchesFromPlayoffDict(sourceDict["Playoffs16"], games) if "Playoffs8" in sourceDict: createMatchesFromPlayoffDict(sourceDict["Playoffs8"], games) destDict["games"] = games xml = dicttoxml.dicttoxml(destDict, attr_type=False) file = open(destFile, 'w', encoding='utf8') file.write(xml.decode("utf-8")) file.close()
def post(self): self.__class__.lock.acquire() self.__class__.request_id += 1 self.__class__.lock.release() options = {} options['email'] = self.get_secure_cookie("mail") batch_size = self.get_argument('batch_size') options['batch_size'] = 0 if batch_size == 'auto' else batch_size options['iterations'] = self.get_argument('iterations') options['gpu_model'] = self.get_argument('gpu_model') options['topology'] = self.get_argument('topology') options['gpu_boost'] = self.get_argument('gpu_boost') options['cuda'] = self.get_argument('CUDA') options['cudnn'] = self.get_argument('CUDNN') options['framework'] = self.get_argument('framework') options['profiling'] = self.get_argument('profiling') timestamp = datetime.datetime.now().strftime("%s") request_string = 'request_%s_%d' % (timestamp, self.__class__.request_id) options['request_id'] = request_string dom = parseString(dicttoxml.dicttoxml(options, attr_type=False)) if not os.path.exists("./xml"): os.mkdir("./xml") xml_string = dom.toprettyxml() filename = "%s_%d.xml" % (timestamp, self.__class__.request_id) filepath = os.path.join('xml', filename) with open(filepath, 'w') as f: f.write(xml_string) scheduler.assign_request(filepath) self.redirect('/result?request=%s' % request_string)
def getEmployeesXml(self): output = self.makeRequest( 'GET', 'api/employees/all' ) json_str = json.loads(output) return dicttoxml.dicttoxml(json_str)
def getItemDetailsXML(category_id, item_id): item = db_session.query(Item).filter_by(id=item_id).one() obj = {"Item": [item.serialize]} xml = dicttoxml.dicttoxml(obj) resp = app.make_response(xml) resp.headers["Content-type"] = "text/xml; charset=utf-8" return resp
def refund(self, **kwargs): """微信支付申请退款,对接口进行封装。 :param out_trade_no: 订单号 :param out_refund_no: 退款记录ID :param total_fee: 订单金额 :param refund_fee: 退款金额 :rtype: 微信接口返回结果 """ if 'out_trade_no' not in kwargs: raise ValueError('out_trade_no is required.') kwargs.setdefault('appid', self.config.get('appid')) kwargs.setdefault('mch_id', self.config.get('mchid')) kwargs.setdefault('device_info', 'WEB') kwargs.setdefault('out_refund_no', kwargs.get('out_trade_no')) kwargs.setdefault('total_fee', 1) kwargs.setdefault('refund_fee', kwargs.get('total_fee')) kwargs.setdefault('refund_fee_type', 'CNY') kwargs.setdefault('op_user_id', self.config.get('mchid')) kwargs.setdefault('nonce_str', randstr(32)) kwargs.setdefault('sign', self.sign(**kwargs)) data = dicttoxml(kwargs, custom_root='xml', attr_type=False) try: xml = requests.post(self.REFUND_URL, data=data, cert=self.config.get('cert')).content return self.xml2dict(xml) except Exception, e: return dict(return_code='ERROR', return_msg=str(e))
def prepay(self, **kwargs): """微信支付预付款下单,对接口进行封装。 :param body: 订单名称 :param detail: 订单详情 :param out_trade_no: 订单号 :param openid: 用户OpenID :param type: 订单分类,默认为normal :rtype: 微信接口返回结果 """ type = kwargs.pop('type', 'normal') kwargs.setdefault('appid', self.config.get('appid')) kwargs.setdefault('mch_id', self.config.get('mchid')) kwargs.setdefault('spbill_create_ip', get_ip()) kwargs.setdefault('notify_url', url_for('wxpay_callback', type=type, _external=True)) kwargs.setdefault('trade_type', 'JSAPI') kwargs.setdefault('body', '微信支付') kwargs.setdefault('out_trade_no', 'wxtest') kwargs.setdefault('total_fee', 100) kwargs.setdefault('nonce_str', randstr(32)) kwargs.setdefault('sign', self.sign(**kwargs)) if 'openid' not in kwargs: raise ValueError('openid is required.') data = dicttoxml(kwargs, custom_root='xml', attr_type=False) try: xml = requests.post(self.PREPAY_URL, data=data).content return self.xml2dict(xml) except Exception, e: return dict(return_code='ERROR', return_msg=str(e))
def prepare_request(request, parameters): """ 把数据转换成为xml @parameters 是一个字典,字典嵌套字典。 """ return dicttoxml.dicttoxml(parameters, attr_type=False, custom_root=request, fold_list=False)
def send_red_pack(self, **kwargs): """微信支付发红包,对接口进行封装。 :param total_amount: 金额总数 :param total_num: 红包数量 :param wishing: 祝福语 :param act_name: 活动名称 :param remark: 备注 :param re_openid: 用户OpenID :rtype: 微信接口返回结果 """ kwargs.setdefault('wxappid', self.config.get('appid')) kwargs.setdefault('mch_id', self.config.get('mchid')) kwargs.setdefault('client_ip', self.config.get('client_ip')) kwargs.setdefault('send_name', self.config.get('send_name', '小酷科技')) kwargs.setdefault('total_amount', 100) kwargs.setdefault('total_num', 1) kwargs.setdefault('nonce_str', randstr(32)) kwargs.setdefault('wishing', '恭喜发财') kwargs.setdefault('act_name', '现金红包') kwargs.setdefault('remark', '备注') kwargs['mch_billno'] = kwargs['mch_id'] + kwargs.get('mch_billno', '') kwargs.setdefault('sign', self.sign(**kwargs)) if 're_openid' not in kwargs: raise ValueError('re_openid is required.') data = dicttoxml(kwargs, custom_root='xml', attr_type=False) try: xml = requests.post(self.SEND_RED_PACK, data=data, cert=self.config.get('cert')).content return self.xml2dict(xml) except Exception, e: return dict(return_code='ERROR', return_msg=str(e))
def output_extraction(data_dict, out_format, out_mode, out_path_file): try: output_data = None output_fileext = None if out_format == 'json': output_data = json.dumps(data_dict, sort_keys=True, indent=4, separators=(',', ': ')) output_fileext = '.json' if out_format == 'xml': output_data = minidom.parseString(dicttoxml.dicttoxml(data_dict, attr_type=False)).toprettyxml(indent='\t') output_fileext = '.xml' if out_mode == '@s': # give out to screen print(output_data) return None elif out_mode == '@none': # silent mode pass else: # output path is given in <out_mode> if out_path_file is not None: if os.path.basename(out_path_file) != CONFIG['output_md_filename']: timestamp = re.sub('\D', '', str(datetime.datetime.now().strftime('%Y%m%d%H:%M:%S.%f')[:-4])) # "meta_" prefix as distinctive feature for metabroker later in workflow out_path_file = os.path.join(out_mode, '_'.join(('meta', timestamp, os.path.basename(out_path_file)[:8].replace('.', '_'), output_fileext))) if not os.path.exists(out_mode): os.makedirs(out_mode) with open(out_path_file, 'w', encoding='utf-8') as outfile: outfile.write(output_data) status_note([str(round(os.stat(out_path_file).st_size / 1024, 4)), ' KB written to ', os.path.normpath(os.path.relpath(out_path_file))]) except Exception as exc: status_note(str(exc), d=is_debug)
def zip_chunk(req_dict, ichunk, hits_list, zip_file, csv_writer, format): """Zip a chunk of documents. Documents are retrieved from elasticsearch in chunks. """ msg = "%s: %s" % (__name__, "zip_chunk()") logger.debug(msg) if settings.DEBUG: print >> stderr, msg if hits_list is None: print >> stderr, "zip_chunk(): empty hit list" return for h in range(len(hits_list)): hit = hits_list[h] _id = hit["_id"] # use '-' instead of ':' in file names pseudo_filename = _id.replace(':', '-') if format == "xml": pseudo_filename += ".xml" xml = dicttoxml(hit) zip_file.writestr(pseudo_filename, xml.encode("utf-8")) elif format == "csv": if h == 0: if ichunk == 0: hit2csv_metadata(csv_writer, req_dict) es_header_names, kb_header_names = hit2csv_header(csv_writer, ichunk) hit2csv_data(csv_writer, hit, es_header_names, kb_header_names) else: # "json" pseudo_filename += ".json" zip_file.writestr(pseudo_filename, json.dumps(hit))
def convert_results(self, results, output_format, return_format, inherit_from): if output_format == 'json': if return_format.lower() == 'xml': results = dicttoxml(json.loads(results)) elif return_format.lower() == 'object': results = self.json_to_object(json.loads(results), 'QueryObject', inherit_from) else: results = json.loads(results) elif output_format == 'xml': if return_format.lower() == 'json': results = json.loads(json.dumps(xmltodict.parse(results))) elif return_format.lower() == 'object': jsonresults = json.loads(json.dumps(xmltodict.parse(results))) results = self.json_to_object(jsonresults, 'QueryObject', inherit_from) elif output_format == 'javascript': if return_format.lower() in ('json', 'xml', 'object'): print ('Cannot Convert \'JavaScript\' response to \'' + return_format.lower() +'\'...returning \'JavaScript\'') pass return results
def showItemEndPoint(category_id, item_id, endPoint='XML'): item = session.query(Items).filter_by(id=item_id).all() # category = session.query(Categories).filter_by(id=category_id).\ # all() # return jsonify(Categories=[c.serialize for c in categories]) # print category[0].vehicle_type serial_data = {item[0].model: [i.serialize for i in item]} if endPoint == 'JSON': JSON_data = json.dumps(serial_data, indent=4) endPoint_type = "JSON endpoint data" return render_template('endPoint.html', endPoint_type=endPoint_type, endPointData=JSON_data) if endPoint == 'XML': xml_string = BeautifulStoneSoup(dicttoxml.dicttoxml(serial_data)).\ prettify() endPoint_type = "XML endpoint data" return render_template('endPoint.html', endPoint_type=endPoint_type, endPointData=xml_string)
def search(request, place_name, map=None, layer=None, start_date=None, end_date=None, project=None, services=None, user=None, format='json'): """ Search the Gazetteer and return results in JSON or XML format. """ if not format: out_format = 'json' else: out_format = format.lower() if out_format not in ('xml', 'json'): out_format = 'json' if place_name.isdigit(): posts = getGazetteerEntry(place_name) else: posts = getGazetteerResults(place_name, map, layer, start_date, end_date, project, user) if services is not None: posts.extend(getExternalServiceResults(place_name, services)) if out_format == 'json': return HttpResponse(json.dumps(posts, sort_keys=True, indent=4), content_type="application/json") elif out_format == 'xml': return HttpResponse(dicttoxml([{'resource': post} for post in posts], attr_type=False, custom_root='response'), content_type="application/xml")
def get_cases_bykey(type): if(request.args.get('key1') is not None): key1 = request.args.get('key1') else: key1 = "" if(request.args.get('key2') is not None): key2 = request.args.get('key2') else: key2 = "" if(key1 != "" and key2 != ""): query_string = 'MATCH (n:`case`) WHERE ".*'+key1+'.*" IN n.keywords AND ".*'+key2+'.*" IN n.keywords RETURN n' result = neo4j.CypherQuery(graph_db, query_string).execute() if(result.__len__() == 0): query_string = 'MATCH (n:`case`) WHERE ".*'+key1+'.*" IN n.keywords OR ".*'+key2+'.*" IN n.keywords RETURN n' result = neo4j.CypherQuery(graph_db, query_string).execute() else: if(key2 != ""): query_string = 'MATCH (n:`case`) WHERE ".*'+key2+'.*" IN n.keywords RETURN n' result = neo4j.CypherQuery(graph_db, query_string).execute() else: if(key1 != ""): query_string = 'MATCH (n:`case`) WHERE "'+key1+'" IN n.keywords RETURN n' result = neo4j.CypherQuery(graph_db, query_string).execute() to_send = [] for node in result: to_send.append(node.values[0]._properties) print to_send if(type == 'json'): json_data = jsonify({"response" : (to_send)}) return json_data else: if(type == 'xml'): xml_data = dicttoxml({"response" : (to_send)}) return (xml_data)
def get_case_bydate(type): if(request.args.get('date') is not None): date = request.args.get('date') date_split = date.split('-') year = date_split[0] query_string = 'MATCH (n:date)-->(m:case)<--(j),(m:case)-->(c) WHERE n.year = "'+ year +'" RETURN m,j,c' result = neo4j.CypherQuery(graph_db, query_string).execute() print result #court_name = 'The Administrative Review Tribunal' #date = date.replace('-','/') #query_string = 'MATCH (n:court) WHERE n.court_name = "'+ date +'" RETURN n' nodes_list = [] for node in result: if(node.values[0]['date'] == date): nodes_list.append(node) to_send = [] for node in nodes_list: #add judge and court properties to case node.values[0]._properties['judge'] = (node.values[1]._properties['j_name'] + " " + node.values[1]._properties['j_surname']) node.values[0]._properties['court'] = (node.values[2]._properties['court_name']) to_send.append(node.values[0]._properties ) #to_send.append(node.values[1]._properties ) #to_send.append(node.values[2]._properties ) #result = neo4j.CypherQuery(graph_db, query_string).execute() #print result.data[0].values[0]._properties print to_send xml_data = dicttoxml({"response" : (to_send)}) json_data = jsonify({"response" : (to_send)}) if(type == 'json'): return json_data else: if(type == 'xml'): #dom = parseString(xml_data,unicode) #print(dom.toprettyxml()) return (xml_data)
def showAll(): """RESTful method for reading recipes""" region_id = request.args.get('region_id') user_id = request.args.get('user_id') xml_format = request.args.get('xml') # Check if query parameters were added to the request if (region_id != '' and region_id is not None): # Get recipes from one region recipes_list = db_session.\ query(Recipe).filter_by(region_id=region_id).order_by( Recipe.last_update.desc()).all() elif (user_id != '' and user_id is not None): # Get recipes from one user recipes_list = db_session.\ query(Recipe).filter_by(user_id=user_id).order_by( Recipe.last_update.desc()).all() else: # Get all recipes recipes_list = db_session.query(Recipe).order_by( Recipe.last_update.desc()).all() serialized_result = [i.serialize for i in recipes_list] # Lastly we decide which data format to send if (xml_format == 'true' or xml_format == 'TRUE'): xml_output = dicttoxml.dicttoxml(serialized_result) return xml_output, 200, {'Content-Type': 'text/xml; charset=utf-8'} else: return jsonify(collection=serialized_result)
def supplier(keys, website): if website == '1688': import requests from bs4 import BeautifulSoup from dicttoxml import dicttoxml url = 'https://api.exchangerate-api.com/v4/latest/CNY' response = requests.get(url) data = response.json() ratekrw = data["rates"]["KRW"] content = {} i = 0 for key in keys: xml = {} xml['SearchItemsParameters'] = {} xml['SearchItemsParameters']["Provider"] = "Alibaba1688" xml['SearchItemsParameters']["LanguageOfQuery"] = "en" xml['SearchItemsParameters']['ItemTitle'] = key xml_str = dicttoxml(xml, attr_type=False) xml_str = str(xml_str) xml_str = xml_str[xml_str.find('<SearchItemsParameters>'):xml_str. find('</root>')] req = requests.get( 'http://otapi.net/OtapiWebService2.asmx/SearchItemsFrame?instanceKey=36bafd6e-baea-41e4-9e8d-4eb2436b0166&language=en&xmlParameters=' + str(xml_str) + '&framePosition=0&frameSize=40') soup = BeautifulSoup(req.content, 'xml') Items = soup.find("Items") itms = Items.findAll('Item') for item in itms: try: content[i] = {} title = item.find('OriginalTitle') content[i]['group'] = 'Uncategorized' content[i]['title'] = title.text content[i]['image'] = [] pics = item.findAll('ItemPicture') for j, pic in enumerate(pics): if j == 3: break content[i]['image'].append(pic.Url.text) price = item.find('OriginalPrice') content[i]['price'] = round(float(price.text), 2) content[i]['price_krw'] = round( (ratekrw) * float(content[i]['price']), 2) location = item.find('Location') content[i]['region'] = '' if location.City is not None: content[i]['region'] += location.City.text + " " if location.State is not None: content[i]['region'] += location.State.text if content[i]['region'] == '': content[i]['region'] = "China" vendorid = item.find('VendorId').text req = requests.get( 'http://otapi.net/OtapiWebService2.asmx/GetVendorInfo?instanceKey=36bafd6e-baea-41e4-9e8d-4eb2436b0166&language=en&vendorId=' + vendorid) soup = BeautifulSoup(req.content, 'xml') vendor = soup.find('ShopName') if vendor is not None: content[i]['shop-name'] = vendor.text else: vendor = soup.find('DisplayName') content[i]['shop-name'] = vendor.text url = item.find('ExternalItemUrl') content[i]['url'] = url.text i += 1 except Exception as e: print(e) pass return content elif website == "Alibaba": from selenium import webdriver import time from selenium.webdriver.chrome.options import Options options = Options() options.add_argument("--headless") options.add_argument("start-maximized") options.add_argument("disable-infobars") options.add_argument("--disable-extensions") options.add_argument("--no-sandbox") options.add_argument("window-size=1920,1080") options.add_argument("--disable-dev-shm-usage") from selenium.webdriver.common.keys import Keys urls = {} driver = webdriver.Chrome('contentdownloader/chromedriver', options=options) driver.get('https://www.alibaba.com/corporations/watch.html') i = 0 for key in keys: time.sleep(5) Send = driver.find_element_by_name('SearchText') Send.clear() Send.send_keys(key) button = driver.find_element_by_xpath( '//*[@id="J_SC_header"]/header/div[2]/div[2]/div/div[1]/form/input[4]' ).click() for company_detali in driver.find_elements_by_xpath( '//div[@class="item-main"]'): name = company_detali.find_elements_by_xpath( './/*[@class="ellipsis search"]') region = name[0].text try: link = company_detali.find_element_by_xpath( './/*[@class="img-thumb"]/a') urls[i] = {} urls[i]['region'] = region urls[i]['url'] = link.get_attribute('href') i += 1 except Exception as e: pass supplier = alibaba(urls) return supplier
def to_xml(self, output_file_name): with open(str(output_file_name), "wb") as xml_file: xml_file.write(dicttoxml.dicttoxml(self.generate(), attr_type=True, cdata=True))
#!/usr/bin/env python # (c) 2016 John Strickler # import csv from dicttoxml import dicttoxml # <1> import lxml.etree as ET rivers = {'rivers': []} # <2> with open('../DATA/longest_rivers.csv') as rivers_in: rdr = csv.reader(rivers_in) for row in rdr: # <3> rivers['rivers'].append({'name': row[0], 'length': row[1]}) snippet = dicttoxml(rivers) # <4> river_root = ET.fromstring(snippet) # <5> river_doc = ET.ElementTree(river_root) # <6> print( ET.tostring(river_doc, pretty_print=True, xml_declaration=True).decode()) # <7> river_doc.write('longest_rivers_default.xml', pretty_print=True, xml_declaration=True) # <8>
def create_full(req_type, content): req = { 'request_type': req_type, 'request_content': content } return dicttoxml(req, custom_root='req', attr_type=False)
import json import dicttoxml f = open('files/products.json', 'r', encoding='utf-8') jsonStr = f.read() # 将JSON字符串转换为字典 d = json.loads(jsonStr) print(d) # 将字典转换为XML字符串 xmlStr = dicttoxml.dicttoxml(d).decode('utf-8') print(xmlStr) f.close()
#conexion-datos try: cnx = mysql.connector.connect(host="127.0.0.1", user="******", passwd="12345", db="bd_reto") except mysql.connector.Error as er: if er.errno == errorcode.ER_ACCESS_DENIED_ERROR: print("Usuario o contraseña incorrecto.") print('') elif er.errno == errorcode.ER_BAD_DB_ERROR: print("No existe la Base de Datos indicada.") print('') else: print(er) else: exe = cnx.cursor(dictionary=True) #codigos query = "SELECT * FROM oc" exe.execute(query) filas = exe.fetchall() cnx.close() #Archivo XML ruta = "E:/C disk/Local C/Documentos/Universidad/5° Semestre/Repos 5°/Bases de datos/proyecto/Reto" xml = dicttoxml.dicttoxml(filas, custom_root='productos', attr_type=False) print(xml) tree = ET.ElementTree(ET.fromstring(xml)) tree.write("extra/output.xml", xml_declaration=True)
def create(): # get the HTTP arguments lgaName = request.headers.get("lgaName") postcode = request.headers.get("postcode") content_type = request.headers.get("Content-Type") # a list that store lgaName, may be more than 1 name lgaName_list = [] if postcode: lgaName_list = postcode_database[int(postcode)][:] # normilize lgaName if lgaName: lgaName = name_to_lgaName(lgaName) lgaName_list.append(lgaName) # save to database lgaName_to_return = set() for name in lgaName_list: # check whether it is in lgaName_database if name in lgaName_database: lgaName_to_return.add(name) else: # check whether it is in database by query my_jason = models.query_database(name) if my_jason: lgaName_to_return.add(name) lgaName_database.add(name) else: # try to download the excel and add it to database if download_xlsx(name): my_dict = read_excel_by_year(name) my_json = simplejson.dumps(my_dict) models.save_database(name, my_json) lgaName_to_return.add(name) lgaName_database.add(name) # check the database if PRINT_INFO: print("lgaName = ", lgaName) print("postcode = ", postcode) print("Content-Type = ", content_type) print("lgaName_list = ", lgaName_list) print("lgaName_for_return = ", lgaName_to_return) print("lgaName_database = ", lgaName_database) # generate return dictionary my_dict = {} for name in lgaName_to_return: my_dict[name] = {"title": name, "url": URL_COLLECTION + name} # generate reture code and error message if my_dict: status_code = 201 else: my_dict["ERROR"] = "Nothing created!" status_code = 400 # return json if content_type == "application/json": return jsonify(my_dict), status_code else: # return xml(by default) return dicttoxml.dicttoxml(my_dict, attr_type=False, custom_root="entry"), status_code
def save_as_xml(file_base_name, obj): file_name = file_base_name + ".xml" xml = dicttoxml.dicttoxml(obj) with open(file_name, "wb") as f: f.write(xml)
def serialize(sequence, file_path): dict = get_dict(sequence) xml = dicttoxml.dicttoxml(dict) with open(file_path, 'w') as file: file.writelines(str(xml, 'utf-8'))
def _validar(self): dicttoxml.set_debug(False) company_id = self.company_id signature_id = self.env.user.get_digital_signature(self.company_id) if not signature_id: raise UserError( _('''There are not a Signature Cert Available for this user, pleaseupload your signature or tell to someelse.''' )) resumenes = [] resumenesPeriodo = {} recs = self._get_moves() for rec in recs: TpoDoc = rec.document_class_id.sii_code if TpoDoc not in resumenesPeriodo: resumenesPeriodo[TpoDoc] = {} if self.tipo_operacion == 'BOLETA': resumen = self._get_resumen_boleta(rec) resumenesPeriodo[TpoDoc] = self._setResumenPeriodoBoleta( resumen, resumenesPeriodo[TpoDoc]) del (resumen['MntNeto']) del (resumen['MntIVA']) if resumen.get('TasaIVA'): del (resumen['TasaIVA']) resumenes.extend([{'Detalle': resumen}]) else: resumen = self.getResumen(rec) resumenes.extend([{'Detalle': resumen}]) resumenesPeriodo[TpoDoc] = self._setResumenPeriodo( resumen, resumenesPeriodo[TpoDoc]) if self.boletas: #no es el libro de boletas especial for boletas in self.boletas: resumenesPeriodo[boletas.tipo_boleta.id] = {} resumen = self._setResumenBoletas(boletas) del (resumen['TotDoc']) resumenesPeriodo[ boletas.tipo_boleta.id] = self._setResumenPeriodo( resumen, resumenesPeriodo[boletas.tipo_boleta.id]) #resumenes.extend([{'Detalle':resumen}]) lista = [ 'TpoDoc', 'TpoImp', 'TotDoc', 'TotAnulado', 'TotMntExe', 'TotMntNeto', 'TotalesServicio', 'TotOpIVARec', 'TotMntIVA', 'TotMntIVA', 'TotOpActivoFijo', 'TotMntIVAActivoFijo', 'itemNoRec', 'TotOpIVAUsoComun', 'TotIVAUsoComun', 'FctProp', 'TotCredIVAUsoComun', 'itemOtrosImp', 'TotImpSinCredito', 'TotIVARetTotal', 'TotIVARetParcial', 'TotMntTotal', 'TotIVANoRetenido', 'TotTabPuros', 'TotTabCigarrillos', 'TotTabElaborado', 'TotImpVehiculo', ] ResumenPeriodo = [] for r, value in resumenesPeriodo.items(): total = collections.OrderedDict() if value: for v in lista: if v in value: total[v] = value[v] ResumenPeriodo.extend([{'TotalesPeriodo': total}]) dte = collections.OrderedDict() if ResumenPeriodo: dte['ResumenPeriodo'] = ResumenPeriodo dte['item'] = resumenes dte['TmstFirma'] = self.time_stamp() resol_data = self.get_resolution_data(company_id) RUTEmisor = self.format_vat(company_id.vat) xml = dicttoxml.dicttoxml(dte, root=False, attr_type=False).decode() doc_id = '%s_%s' % (self.tipo_operacion, self.periodo_tributario) libro = self.create_template_envio( RUTEmisor, self.periodo_tributario, resol_data['dte_resolution_date'], resol_data['dte_resolution_number'], xml, signature_id.subject_serial_number, self.tipo_operacion, self.tipo_libro, self.tipo_envio, self.folio_notificacion, doc_id) xml = self.create_template_env(libro) env = 'libro' if self.tipo_operacion in ['BOLETA']: xml = self.create_template_env_boleta(libro) env = 'libro_boleta' root = etree.XML(xml) xml_pret = etree.tostring(root, pretty_print=True).decode('iso-8859-1')\ .replace('<item/>', '\n')\ .replace('<item>', '\n').replace('</item>', '')\ .replace('<itemNoRec>', '').replace('</itemNoRec>', '\n')\ .replace('<itemOtrosImp>', '').replace('</itemOtrosImp>', '\n')\ .replace('<item_refs>', '').replace('</item_refs>', '\n')\ .replace('_no_rec', '') envio_dte = self.sign_full_xml(xml_pret, doc_id, env) self.sii_xml_request = self.env['sii.xml.envio'].create({ 'xml_envio': envio_dte, 'name': doc_id, 'company_id': company_id.id, }).id
__author__ = 'Chung HD' _logger = logging.getLogger(__name__) from dicttoxml import dicttoxml def customer_item_func(parent): if parent == "Customers": return 'Customer' return "Item" data = { "Customers": [{ "name": "abc", "email": "abc@gmail", "hello": ["abc"] }, { "name": "def", "email": "def@gmail" }] } xml_str = dicttoxml(data, root=False, attr_type=False, custom_root='Customers', item_func=customer_item_func) print(xml_str)
def json_to_xml(json_string): """The function is used to translate json string to xml string""" dict_string = json.loads(json_string) xml_string = dicttoxml.dicttoxml(dict_string) return str(xml_string)
import json import urllib import dicttoxml import sys page = urllib.urlopen('http://173.246.108.142/oop/cars.json') content = page.read() obj = json.loads(content) xml = dicttoxml.dicttoxml(obj) f = open('cars.xml', 'w') f.write(xml)
def json_xml(inputStr): jdata = json.loads(inputStr) xml = dicttoxml.dicttoxml(jdata, root=True, attr_type=False) return parseString(xml).toprettyxml()
unitprices = driver.find_elements(By.XPATH, "//div[@class='unitPrice']/span") for unitprice in unitprices: # print(unitprice.text[2:]) ls_unitprices.append(unitprice.text[2:]) driver.find_element_by_link_text('下一页').click() i += 1 print(ls_total_price) print(ls_areas) print(ls_unitprices) ls = [] for i in range(len(ls_total_price)): dict1 = {} dict1['totalPrice'] = ls_total_price[i] dict1['area'] = ls_areas[i] dict1['utilPrice'] = ls_unitprices[i] ls.append(dict1) xml = dicttoxml(ls, custom_root='Itemlist', attr_type=False, root=True) #dicttoxml接受可迭代对象并将它们视为列表 '''parseString方法创建一个XML解析器并解析xml字符串:DOM是Document Object Model的简称, 它是以对象树来表示一个XML文档的方法,使用它的好处就是你可以非常灵活的在对象中进行遍历。 ''' dom = parseString(xml) print(dom.toprettyxml()) #以xml的格式漂亮打印 file_name = '链家' with open(file_name + ".xml", "w", encoding="utf8") as outfile: outfile.write(dom.toprettyxml()) # driver.get_screenshot_as_file('D:\\screenshot')
def printCVE_xml(item): xml = dicttoxml(item) print(xml.decode("utf-8"))
def do_receipt(self): message = "" for inv in self.invoice_ids: if inv.claim in ["ACD", "RCD"]: continue signature_d = self.env.user.get_digital_signature(inv.company_id) if not signature_d: raise UserError( _("""There is no Signer Person with an authorized signature for you in the system. Please make sure that 'user_signature_key' module has been installed and enable a digital signature, for you or make the signer to authorize you to use his signature.""")) dict_recept = self._recep(inv, signature_d["subject_serial_number"]) identifier = \ ("T" + str(inv.sii_document_class_id.sii_code) + "F" + str(inv.get_folio())) doc = """ <Recibo version="1.0" xmlns="http://www.sii.cl/SiiDte" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.sii.cl/SiiDte Recibos_v10.xsd" > <DocumentoRecibo ID="{0}" > {1} </DocumentoRecibo> </Recibo> """.format( identifier, dicttoxml.dicttoxml(dict_recept, root=False, attr_type=False).decode()) message += ("\n " + str(dict_recept["Folio"]) + " " + dict_recept["Declaracion"]) receipt = ( '<?xml version="1.0" encoding="ISO-8859-1"?>\n' + inv.sign_full_xml( doc.replace( '<?xml version="1.0"' ' encoding="ISO-8859-1"?>\n', ""), "Recibo", "recep")) RutRecibe = inv.format_vat(inv.partner_id.vat) dict_caratula = self._caratula_recep( inv.format_vat(inv.company_id.vat), RutRecibe) caratula = dicttoxml.dicttoxml(dict_caratula, root=False, attr_type=False).decode() envio_dte = self._envio_recep(caratula, receipt) envio_dte = ( '<?xml version="1.0" encoding="ISO-8859-1"?>\n' + inv.sign_full_xml( envio_dte.replace( '<?xml version="1.0" encoding="ISO-8859-1"?>\n', ""), "SetDteRecibidos", "env_recep")) att = self._create_attachment( envio_dte, "recepcion_mercaderias_" + str(inv.sii_xml_request.name)) inv.message_post(body=_("XML of the Reception Document\n %s") % message, subject=_("XML of the Reception Document"), partner_ids=[inv.partner_id.id], attachment_ids=att.ids, message_type="comment", subtype="mt_comment") inv.claim = "ERM" try: inv.set_dte_claim( rut_emisor=inv.format_vat(inv.partner_id.vat)) except: _logger.warning("TODO: Create the code that adds the answer.")
def print_result_xml(result): custom_root = "CloudStack-%s" % self.profile.replace(" ", "_") xml = dicttoxml(result, attr_type=False, custom_root=custom_root) self.monkeyprint(parseString(xml).toprettyxml())
def get_response(self, response): if self.request_json: return json.dumps(response) else: xml = dicttoxml.dicttoxml(response, attr_type=False, root=False) return xml.decode("utf-8")
def PrintToXML(fileName, data): makeFolderIfNotExists(DEFAULTOUTPUTPATH) with open(f'{DEFAULTOUTPUTPATH}/{fileName}.xml', 'w+') as file: file.write(dicttoxml(data).decode('UTF-8')) file.close()
def do_validate_comercial(self): id_seq = self.env.ref('l10n_cl_dte.response_sequence').id IdRespuesta = self.env['ir.sequence'].browse(id_seq).next_by_id() NroDetalles = 1 for inv in self.invoice_ids: if inv.claim in ['ACD', 'RCD']: continue try: signature_d = self.env.user.get_digital_signature(inv.company_id) except: return False # raise UserError(_('''There is no Signer Person with an \ # authorized signature for you in the system. Please make sure that \ # 'user_signature_key' module has been installed and enable a digital \ # signature, for you or make the signer to authorize you to use his \ # signature.''')) certp = signature_d['cert'].replace( BC, '').replace(EC, '').replace('\n', '') dte = self._resultado( TipoDTE=inv.document_type_id.code, Folio=inv.document_number, FchEmis=inv.date_invoice, RUTEmisor=inv.format_vat(inv.partner_id.main_id_number), RUTRecep=inv.format_vat(inv.company_id.main_id_number), MntTotal=int(round(inv.amount_total, 0)), IdRespuesta=IdRespuesta, ) ResultadoDTE = dicttoxml.dicttoxml( dte, root=False, attr_type=False, ).decode().replace('<item>','\n').replace('</item>','\n') RutRecibe = inv.format_vat(inv.partner_id.main_id_number) caratula_validacion_comercial = self._caratula_respuesta( inv.format_vat(inv.company_id.main_id_number), RutRecibe, IdRespuesta, NroDetalles, ) caratula = dicttoxml.dicttoxml( caratula_validacion_comercial, root=False, attr_type=False, ).decode().replace('<item>','\n').replace('</item>','\n') resp = self._dte_result( caratula, ResultadoDTE, ) respuesta = '<?xml version="1.0" encoding="ISO-8859-1"?>\n' + inv.sign_full_xml( resp.replace('<?xml version="1.0" encoding="ISO-8859-1"?>\n', ''), signature_d['priv_key'], certp, 'Odoo_resp', 'env_resp', ) inv.sii_message = respuesta att = self._create_attachment( respuesta, 'validacion_comercial_' + str(IdRespuesta), ) template = self.env.ref('l10n_cl_dte_incoming.email_template_receipt_commercial_accept', False) mail_id = template.send_mail( inv.id, force_send=True, email_values={'attachment_ids': att.ids}) inv.dte_reception_status = 'validate' inv.claim = 'ACD' try: inv.set_dte_claim( rut_emisor=inv.format_vat(inv.partner_id.main_id_number), ) except: _logger.warning("@TODO crear código que encole la respuesta")
def dict_to_xml(dictionary): xml_str = dicttoxml(dictionary, custom_root="yandex", attr_type=False) return xml.dom.minidom.parseString(xml_str).toprettyxml()
"is able to use Web-API functions. It is only available " "for automation users.") @property def defaults(self): return config.builtin_role_ids Formatter = Callable[[Dict[str, Any]], Text] _FORMATTERS = { "json": (json.dumps, lambda response: json.dumps( response, sort_keys=True, indent=4, separators=(',', ': '))), "python": (repr, pprint.pformat), "xml": (dicttoxml.dicttoxml, lambda response: xml.dom.minidom.parseString( dicttoxml.dicttoxml(response)).toprettyxml()), } # type: Dict[str, Tuple[Formatter, Formatter]] @cmk.gui.pages.register("webapi") def page_api(): try: pretty_print = False if not html.request.has_var("output_format"): html.set_output_format("json") if html.output_format not in _FORMATTERS: html.set_output_format("python") raise MKUserError( None, "Only %s are supported as output formats" % " and ".join('"%s"' % f for f in _FORMATTERS))
def do_receipt(self): message = "" for inv in self.invoice_ids: if inv.claim in ['ACD', 'RCD']: continue try: signature_d = self.env.user.get_digital_signature(inv.company_id) except: return False # raise UserError(_('''There is no Signer Person with an \ # authorized signature for you in the system. Please make sure that \ # 'user_signature_key' module has been installed and enable a digital \ # signature, for you or make the signer to authorize you to use his \ # signature.''')) certp = signature_d['cert'].replace( BC, '', ).replace(EC, '').replace('\n', '') dict_recept = self._recep( inv, signature_d['subject_serial_number'], ) id = "T" + str(inv.document_type_id.code) + "F" + str(inv.document_number) doc = ''' <Recibo version="1.0" xmlns="http://www.sii.cl/SiiDte" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" \ xsi:schemaLocation="http://www.sii.cl/SiiDte Recibos_v10.xsd" > <DocumentoRecibo ID="{0}" > {1} </DocumentoRecibo> </Recibo> '''.format( id, dicttoxml.dicttoxml( dict_recept, root=False, attr_type=False, ).decode(), ) message += '\n ' + str(dict_recept['Folio']) + ' ' + dict_recept['Declaracion'] receipt = '<?xml version="1.0" encoding="ISO-8859-1"?>\n' + inv.sign_full_xml( doc.replace('<?xml version="1.0" encoding="ISO-8859-1"?>\n', ''), signature_d['priv_key'], certp, 'Recibo', 'recep') RutRecibe = inv.format_vat(inv.partner_id.main_id_number) dict_caratula = self._caratula_recep( inv.format_vat(inv.company_id.main_id_number), RutRecibe, ) caratula = dicttoxml.dicttoxml( dict_caratula, root=False, attr_type=False, ).decode() envio_dte = self._envio_recep( caratula, receipt, ) envio_dte = '<?xml version="1.0" encoding="ISO-8859-1"?>\n' + inv.sign_full_xml( envio_dte.replace('<?xml version="1.0" encoding="ISO-8859-1"?>\n', ''), signature_d['priv_key'], certp, 'SetDteRecibidos', 'env_recep', ) id_seq = self.env.ref('l10n_cl_dte.response_sequence').id IdRespuesta = self.env['ir.sequence'].browse(id_seq).next_by_id() att = self._create_attachment( envio_dte, 'recepcion_mercaderias_' + str(IdRespuesta), ) template = self.env.ref('l10n_cl_dte_incoming.email_template_receipt_of_goods', False) mail_id = template.send_mail( inv.id, force_send=True, email_values={'attachment_ids': att.ids}) inv.dte_reception_status = 'mercaderias' inv.claim = 'ERM' try: inv.set_dte_claim( rut_emisor=inv.format_vat(inv.partner_id.main_id_number), ) except: _logger.warning("(mejora:) crear código que encole la respuesta")
def xml(dataset_blobs): #datasets = [] #contributors = [] subjects = [] resources = [] errors = [] error_reports = [] def normv(v): if is_list_or_tuple(v): return [normv(_) for _ in v] elif isinstance(v, dict): return {k:normv(v) for k, v in v.items()} elif isinstance(v, str) and v.startswith('http'): # needed for loading from json that has been serialized # rather than from our internal representation # probably better to centralized the reload ... # XXX NOTE these days this will only happen if someone # supplies us with a uri in a field where we aren't # expecting one, in which case we should just return it try: v = OntTerm(v) return v.asCell() except Exception as e: loge.error(f'something went wrong with {v}') loge.exception(e) return v #raise e elif isinstance(v, rdflib.URIRef): # FIXME why is this getting converted early? ot = OntTerm(v) return ot.asCell() elif isinstance(v, ProtcurExpression): return str(v) # FIXME for xml? elif isinstance(v, Quantity): return str(v) elif isinstance(v, AsJson): # XXX returns value not tested, may be extremely strange return str(v) elif isinstance(v, pathlib.Path): return str(v) elif isinstance(v, idlib.Stream): return v.asCell() #elif isinstance(v, list) or isinstance(v, str): #return v elif isinstance(v, BaseException): return repr(v) else: #loge.debug(repr(v)) return v for dataset_blob in dataset_blobs: id = dataset_blob['id'] dowe = dataset_blob #id = dataset.id #dowe = dataset.data if 'subjects' in dowe: for subject in dowe['subjects']: subject['dataset_id'] = id subject = {k:normv(v) for k, v in subject.items()} subjects.append(subject) if 'resources' in dowe: for res in dowe['resources']: res['dataset_id'] = id res = {k:normv(v) for k, v in res.items()} resources.append(res) if 'errors' in dowe: ers = get_all_errors(dowe) for path, er in ers: if not isinstance(er, dict): #breakpoint() loge.critical(er) continue if er['pipeline_stage'] in pipes.PipelineEnd._shadowed: continue er['dataset_id'] = id er = {k:normv(v) for k, v in er.items()} errors.append(er) if 'status' in dowe: if 'path_error_report' in dowe['status']: error_reports.append(dowe['status']['path_error_report']) xs = dicttoxml.dicttoxml({'subjects': subjects}) xr = dicttoxml.dicttoxml({'resources': resources}) xe = dicttoxml.dicttoxml({'errors': errors}) xer = dicttoxml.dicttoxml({'error_reports': error_reports}) return (('subjects', xs), ('resources', xr), ('errors', xe), ('error_reports', xer),)
def do_reject(self, document_ids): inv_obj = self.env['account.invoice'] id_seq = self.env.ref('l10n_cl_dte.response_sequence').id IdRespuesta = self.env['ir.sequence'].browse(id_seq).next_by_id() NroDetalles = 1 for doc in document_ids: try: signature_d = self.env.user.get_digital_signature(doc.company_id) except: return False # raise UserError(_('''There is no Signer Person with an \ # authorized signature for you in the system. Please make sure that \ # 'user_signature_key' module has been installed and enable a digital \ # signature, for you or make the signer to authorize you to use his \ # signature.''')) certp = signature_d['cert'].replace( BC, '').replace(EC, '').replace('\n', '') xml = xmltodict.parse(doc.xml)['DTE']['Documento'] dte = self._resultado( TipoDTE=xml['Encabezado']['IdDoc']['TipoDTE'], Folio=xml['Encabezado']['IdDoc']['Folio'], FchEmis=xml['Encabezado']['IdDoc']['FchEmis'], RUTEmisor=xml['Encabezado']['Emisor']['RUTEmisor'], RUTRecep=xml['Encabezado']['Receptor']['RUTRecep'], MntTotal=xml['Encabezado']['Totales']['MntTotal'], IdRespuesta=IdRespuesta, ) ResultadoDTE = dicttoxml.dicttoxml( dte, root=False, attr_type=False, ).decode().replace('<item>', '\n').replace('</item>', '\n') RutRecibe = xml['Encabezado']['Emisor']['RUTEmisor'] caratula_validacion_comercial = self._caratula_respuesta( xml['Encabezado']['Receptor']['RUTRecep'], RutRecibe, IdRespuesta, NroDetalles) caratula = dicttoxml.dicttoxml( caratula_validacion_comercial, root=False, attr_type=False).decode().replace('<item>','\n').replace('</item>','\n') resp = self._dte_result( caratula, ResultadoDTE, ) respuesta = '<?xml version="1.0" encoding="ISO-8859-1"?>\n' + inv_obj.sign_full_xml( resp.replace('<?xml version="1.0" encoding="ISO-8859-1"?>\n', ''), signature_d['priv_key'], certp, 'Odoo_resp', 'env_resp', ) att = self._create_attachment( respuesta, 'rechazo_comercial_' + str(IdRespuesta), id=doc.id, model="mail.message.dte.document", ) #partners = doc.partner_id.ids #if not doc.partner_id: # if att: # values = { # 'res_id': doc.id, # 'email_from': doc.company_id.dte_email, # 'email_to': doc.dte_id.sudo().mail_id.email_from, # 'auto_delete': False, # 'model': "mail.message.dte.document", # 'body': 'XML de Respuesta Envío, Estado: %s , Glosa: %s ' % ( # recep['EstadoRecepEnv'], recep['RecepEnvGlosa']), # 'subject': 'XML de Respuesta Envío', # 'attachment_ids': att.ids, # } # send_mail = self.env['mail.mail'].create(values) # send_mail.send() #doc.message_post( # body='XML de Rechazo Comercial, Estado: %s, Glosa: %s' % ( # dte['ResultadoDTE']['EstadoDTE'], dte['ResultadoDTE']['EstadoDTEGlosa']), # subject='XML de Validación Comercial', # partner_ids=partners, # attachment_ids=[att.id], # message_type='comment', # subtype='mt_comment', ) template = self.env.ref('l10n_cl_dte_incoming.email_template_commercial_reject', False) mail_id = template.send_mail( doc.dte_id.id, force_send=True, email_values={'attachment_ids': att.ids}) doc.dte_id.reception_response_number = IdRespuesta context = dict(self._context or {}) incoming_reject = context.get('incoming_reject', False) or [] if not incoming_reject: inv_obj.set_dte_claim( rut_emisor = xml['Encabezado']['Emisor']['RUTEmisor'], company_id=doc.company_id, sii_document_number=doc.number, document_type_id=doc.document_type_id, claim='RCD', )
def format_xml(data, root, lst=list()): """将dict转换为xml, xml_config是一个bytes""" xml_config = dicttoxml(data, item_func=lambda x: x, custom_root=root, attr_type=False) for i in lst: xml_config = xml_config.replace(to_bytes(i+i), to_bytes(i)) return xml_config
def downloadOneStream(stream, args): try: url = stream.url networkParser = networkParserFactory(url) progMetadata = networkParser.getProgMetaData(url) except Exception as err: # log the error and continue with next stream logger.error(err.__repr__()) updateStreamWithError(stream, err.__repr__()) return # create the filename accoding to file meta-data # generic video filename (without ext) folder = datetime.fromtimestamp( progMetadata.airDate).strftime("%Y-%m-%d_%a") dstFullPath = os.path.join(args.outDir, folder) # create dest folder if doesn't exist if os.path.exists(dstFullPath) is False: os.mkdir(dstFullPath) # add filename dstFullPath = os.path.join(dstFullPath, progMetadata.filename) # rename file if it already exist. fileIndex = 2 while os.path.isfile(dstFullPath + ".mp4") is True: dstFullPath = os.path.join( args.outDir, folder, progMetadata.filename + "_" + str(fileIndex)) fileIndex += 1 # downloading with ffmpeg logger.info("------------") logger.info("Downloading: %s" % (url)) logger.info("++") updateStreamStatus(stream, "downloading") try: ffmpegHLSDownloader = FfmpegHLSDownloader(url=progMetadata.manifestUrl, userAgent=CURRENT_USER_AGENT) ffmpegHLSDownloader.downloadAndConvertFile(dst=dstFullPath + ".mp4") except Exception as err: # log the error and continue with next stream logger.error(err.__repr__()) updateStreamWithError(stream, err.__repr__()) logger.info("++") logger.info("Download interupted with error") logger.info("-------") return # check log file for error logger.info("------------") logger.info(f"Checking log file: {dstFullPath}.log") logger.info("++") with open(dstFullPath + ".log", "r") as f: lines = f.readlines() if any(("error" in l for l in lines)): logger.info("------------") logger.info("Found downloading error. Clean up and will retry later") logger.info("++") cleanUp(dstFullPath) updateStreamWithError(stream, "Segment download error") updateStreamStatus(stream, "pending") return logger.info("++") logger.info("Download completed: %s" % (url)) logger.info("Video : %s" % (dstFullPath)) logger.info("-------") # save metadata if args.saveMetadata: logger.info("Saving metadata") xmlMeta = dicttoxml.dicttoxml(progMetadata._asdict(), attr_type=False) dom = minidom.parseString(xmlMeta) with open(dstFullPath + ".meta", "w") as text_file: print(dom.toprettyxml(), file=text_file) dstFullPath += ".mp4" # save metadata to mongo logger.info("Saving video info") updateStreamWithMetadata(stream, progMetadata) addVideo(dstFullPath, folder, args.repo, progMetadata, stream)
def get_barcode(self, no_product=False): partner_id = self.partner_id or self.company_id.partner_id ted = False RutEmisor = self.format_vat(self.company_id.vat) result['TED']['DD']['RE'] = RutEmisor result['TED']['DD'][ 'TD'] = self.location_id.sii_document_class_id.sii_code result['TED']['DD']['F'] = self.get_folio() result['TED']['DD']['FE'] = fields.Datetime.context_timestamp( self.with_context(tz='America/Santiago'), fields.Datetime.from_string(self.scheduled_date)).strftime(DF) if not partner_id.commercial_partner_id.vat: raise UserError(_("Fill Partner VAT")) result['TED']['DD']['RR'] = self.format_vat( partner_id.commercial_partner_id.vat) result['TED']['DD']['RSR'] = self._acortar_str( partner_id.commercial_partner_id.name, 40) result['TED']['DD']['MNT'] = int(round(self.amount_total)) if no_product: result['TED']['DD']['MNT'] = 0 for line in self.move_lines: result['TED']['DD']['IT1'] = self._acortar_str( line.product_id.name, 40) if line.product_id.default_code: result['TED']['DD']['IT1'] = self._acortar_str( line.product_id.name.replace( '[' + line.product_id.default_code + '] ', ''), 40) break resultcaf = self.location_id.sequence_id.get_caf_file() result['TED']['DD']['CAF'] = resultcaf['AUTORIZACION']['CAF'] if RutEmisor != result['TED']['DD']['CAF']['DA']['RE']: raise UserError( _('NO coincide el Dueño del CAF : %s con el emisor Seleccionado: %s' % (result['TED']['DD']['CAF']['DA']['RE'], RutEmisor))) dte = result['TED']['DD'] timestamp = self.time_stamp() picking_date = fields.Datetime.context_timestamp( self.with_context(tz='America/Santiago'), fields.Datetime.from_string(self.date)).strftime(DTF) if date(int(timestamp[:4]), int(timestamp[5:7]), int( timestamp[8:10])) < date(int(picking_date[:4]), int(picking_date[5:7]), int(picking_date[8:10])): raise UserError( "La fecha de timbraje no puede ser menor a la fecha de emisión del documento" ) dte['TSTED'] = timestamp dicttoxml.set_debug(False) ddxml = '<DD>' + dicttoxml.dicttoxml( dte, root=False, attr_type=False ).decode().replace('<key name="@version">1.0</key>', '', 1).replace( '><key name="@version">1.0</key>', ' version="1.0">', 1).replace( '><key name="@algoritmo">SHA1withRSA</key>', ' algoritmo="SHA1withRSA">').replace( '<key name="#text">', '').replace('</key>', '').replace( '<CAF>', '<CAF version="1.0">') + '</DD>' keypriv = resultcaf['AUTORIZACION']['RSASK'].replace('\t', '') root = etree.XML(ddxml) ddxml = etree.tostring(root) frmt = self.signmessage(ddxml, keypriv) ted = ('''<TED version="1.0">{}<FRMT algoritmo="SHA1withRSA">{}\ </FRMT></TED>''').format(ddxml.decode(), frmt) self.sii_barcode = ted image = False if ted: barcodefile = BytesIO() image = self.pdf417bc(ted) image.save(barcodefile, 'PNG') data = barcodefile.getvalue() self.sii_barcode_img = base64.b64encode(data) ted += '<TmstFirma>{}</TmstFirma>'.format(timestamp) return ted
def exportbookings(request): global user_timezone error_message = "" if request.GET: # pdb.set_trace() duration = request.GET['coming_period'] docformat = request.GET['format'] operation_type = request.GET['type'] user_timezone = request.session['visitor_timezone'] bookingsdetails = getbookinginfos(duration, user_timezone) # create xml or pdf or csv as requested if operation_type == "feed": pass instance = BookingsFeed(bookingsdetails) #get the booking id and all other details and create dictionary elif operation_type == "file": if len(bookingsdetails): if docformat == "csv": response = HttpResponse(content_type='text/csv') response[ 'Content-Disposition'] = 'attachment; filename=' + "bookings" + duration + "." + docformat headings = bookingsdetails[0].keys() csvWriter = csv.DictWriter(response, fieldnames=headings, dialect='excel', quoting=csv.QUOTE_NONNUMERIC) csvWriter.writeheader() for data in bookingsdetails: csvWriter.writerow(data) if docformat == "xml": xml = dicttoxml(bookingsdetails, custom_root='Bookings', attr_type=False) response = HttpResponse(xml, content_type='application/xml') response[ 'Content-Disposition'] = 'attachment; filename=' + "bookings" + duration + "." + docformat if docformat == "pdf": fields = list() for key in bookingsdetails[0].keys(): fields.append((key, key)) buffer = BytesIO() doc = DataToPdf(fields, bookingsdetails, title='Booking Details') doc.export(buffer) response = HttpResponse(content_type='application/xml') response[ 'Content-Disposition'] = 'attachment; filename=' + "bookings" + duration + "." + docformat pdf = buffer.getvalue() buffer.close() response.write(pdf) return response else: error_message = "Booking not available for this " + duration template_name = "exportbookings.html" return render(request, template_name, {"error_message": error_message})