def decryptDict(dct, signingPrivateKey, realPrivateKey, realPublicKey): """decrypt all values in a dictionary Assumes all values in a dictionary are base64ed encrypted with realPublicKey, and signed with signingPrivateKey, and decrypt them with realPrivateKey. If realPrivateKey and realPublicKey do not correspond to each other, or any value in the dictionary is not signed and encrypted correctly, an exception is raised. :param dct: encrypted dictionary :type dct: dictionary with string values and keys :param signingPrivateKey: base64 encoded NaCl private key :type signingPrivateKey: string :param realPrivateKey: base64 encoded NaCl private key :type realPrivateKey: string :param realPublicKey: base64 encoded NaCl private key :type realPublicKey: string :rtype: dictionary with string values and keys """ signingPrivateKey = npublic.PrivateKey(base64.decodestring(signingPrivateKey)) signingPublicKey = signingPrivateKey.public_key realPrivateKey = npublic.PrivateKey(base64.decodestring(realPrivateKey)) realPublicKey = npublic.PublicKey(base64.decodestring(realPublicKey)) if realPrivateKey.public_key.encode() != realPublicKey.encode(): raise ValueError("private key and public key do not match", realPrivateKey.public_key, realPublicKey) box = npublic.Box(realPrivateKey, signingPublicKey) ret = {} for key, value in six.iteritems(dct): decodedValue = base64.decodestring(value) decryptedValue = box.decrypt(decodedValue) ret[key] = decryptedValue return ret
def exp_restore(db_name, data): with _set_pg_password_in_environment(): if exp_db_exist(db_name): _logger.warning('RESTORE DB: %s already exists', db_name) raise Exception, "Database already exists" _create_empty_database(db_name) cmd = ['pg_restore', '--no-owner'] if openerp.tools.config['db_user']: cmd.append('--username='******'db_user']) if openerp.tools.config['db_host']: cmd.append('--host=' + openerp.tools.config['db_host']) if openerp.tools.config['db_port']: cmd.append('--port=' + str(openerp.tools.config['db_port'])) cmd.append('--dbname=' + db_name) args2 = tuple(cmd) buf=base64.decodestring(data) if os.name == "nt": tmpfile = (os.environ['TMP'] or 'C:\\') + os.tmpnam() file(tmpfile, 'wb').write(buf) args2=list(args2) args2.append(tmpfile) args2=tuple(args2) stdin, stdout = openerp.tools.exec_pg_command_pipe(*args2) if not os.name == "nt": stdin.write(base64.decodestring(data)) stdin.close() res = stdout.close() if res: raise Exception, "Couldn't restore database" _logger.info('RESTORE DB: %s', db_name) return True
def create_aeroo_report(self, cr, uid, ids, data, report_xml, context=None, output='odt'): """ Returns an aeroo report generated with aeroolib """ pool = pooler.get_pool(cr.dbname) if not context: context={} context = context.copy() if self.name=='report.printscreen.list': context['model'] = data['model'] context['ids'] = ids print_id = context.get('print_id', False) aeroo_print = self.active_prints[print_id] # Aeroo print object aeroo_print.subreports = [] #self.oo_subreports[print_id] = [] objects = self.getObjects_mod(cr, uid, ids, report_xml.report_type, context) or [] oo_parser = self.parser(cr, uid, self.name2, context=context) oo_parser.localcontext.update(context) oo_parser.set_context(objects, data, ids, report_xml.report_type) self.set_xml_data_fields(objects, oo_parser) # Get/Set XML oo_parser.localcontext['data'] = data oo_parser.localcontext['user_lang'] = context.get('lang', False) if len(objects)>0: oo_parser.localcontext['o'] = objects[0] xfunc = ExtraFunctions(cr, uid, report_xml.id, oo_parser.localcontext) oo_parser.localcontext.update(xfunc.functions) #company_id = objects and 'company_id' in objects[0]._table._columns.keys() and \ # objects[0].company_id and objects[0].company_id.id or False # for object company usage company_id = False style_io=self.get_styles_file(cr, uid, report_xml, company=company_id, context=context) if report_xml.tml_source in ('file', 'database'): if not report_xml.report_sxw_content or report_xml.report_sxw_content=='False': raise osv.except_osv(_('Error!'), _('No template found!')) file_data = base64.decodestring(report_xml.report_sxw_content) else: file_data = self.get_other_template(cr, uid, data, oo_parser) if not file_data and not report_xml.report_sxw_content: self.logger("End process %s (%s), elapsed time: %s" % (self.name, self.table, time.time() - aeroo_print.start_time), logging.INFO) # debug mode return False, output #elif file_data: # template_io = StringIO() # template_io.write(file_data or report_xml.report_sxw_content) # basic = Template(source=template_io, styles=style_io) else: if report_xml.preload_mode == 'preload' and hasattr(self, 'serializer'): serializer = copy.copy(self.serializer) serializer.apply_style(style_io) template_io = serializer.template else: template_io = StringIO() template_io.write(file_data or base64.decodestring(report_xml.report_sxw_content) ) serializer = OOSerializer(template_io, oo_styles=style_io) try: basic = Template(source=template_io, serializer=serializer) except Exception, e: self._raise_exception(e, print_id)
def get_credentials(self, acc): self.__check_valid(acc) try: return Credentials(base64.decodestring(acc["username"]), base64.decodestring(acc["password"])) except Exception, e: raise KeyringException("Cannot decode the base64 username or password for account %s" % (acc.get_name()), e)
def from_line(cls, line): """ Parses the given line of text to find the names for the host, the type of key, and the key data. The line is expected to be in the format used by the openssh known_hosts file. Lines are expected to not have leading or trailing whitespace. We don't bother to check for comments or empty lines. All of that should be taken care of before sending the line to us. @param line: a line from an OpenSSH known_hosts file @type line: str """ fields = line.split(' ') if len(fields) < 3: # Bad number of fields return None fields = fields[:3] names, keytype, key = fields names = names.split(',') # Decide what kind of key we're looking at and create an object # to hold it accordingly. if keytype == 'ssh-rsa': key = RSAKey(data=base64.decodestring(key)) elif keytype == 'ssh-dss': key = DSSKey(data=base64.decodestring(key)) else: return None return cls(names, key)
def _migrate_from_dir(self, cursor, day): entries_fn = self.cache_path.join(day).join(u'entries.log') origins_fn = self.cache_path.join(day).join(u'origins.log') if not fsutil.is_exists(self.fs, entries_fn): return with self.fs.open(entries_fn, 'r') as f: j = 0 for line in f: try: fn, server_path, mtime, size, blocklist = line.strip().split('|') fn = base64.decodestring(fn).decode('utf8') server_path = base64.decodestring(server_path).decode('utf8') fn = unicode(self.cache_path.join(day, fn)) mtime = float(mtime) size = int(size) self._insert_entry(cursor, local_filename=fn, old_filename='*migrated*', date_added=day, ns=None, size=size, mtime=mtime, blocklist=blocklist) j += 1 except DuplicateEntryError as e: TRACE('Duplicate Entry: %r', e.message) except Exception: unhandled_exc_handler() TRACE('DELETED: Migrated %s entries from %r' % (j, day)) fsutil.safe_remove(self.fs, entries_fn) fsutil.safe_remove(self.fs, origins_fn)
def post(self): description = self.request.get("description", None) platform = int(self.request.get("platform", 0)) platform_version = self.request.get("platform_version", None) timestamp = long(self.request.get("timestamp", 0)) mobicage_version = self.request.get("mobicage_version", None) error_message = self.request.get("error_message", None) logging.debug("Error logged over HTTP:\n%s", error_message) ler = LogErrorRequestTO() ler.description = description ler.platform = platform ler.platformVersion = platform_version ler.timestamp = timestamp ler.mobicageVersion = mobicage_version ler.errorMessage = error_message from rogerthat.bizz.system import logErrorBizz user = self.request.headers.get("X-MCTracker-User", None) password = self.request.headers.get("X-MCTracker-Pass", None) if user and password: users.set_json_rpc_user(base64.decodestring(user), base64.decodestring(password)) return logErrorBizz(ler, users.get_current_user()) else: # language = self.request.get("language", None) # Unused # deviceId = self.request.get("device_id", None) # Unused install_id = self.request.get("install_id", None) return logErrorBizz(ler, user=None, install_id=install_id)
def _validate_base64_format(instance): try: base64.decodestring(instance) except base64.binascii.Error: return False return True
def test_encode_images(): # invalid data, but the header and footer are from real files pngdata = b'\x89PNG\r\n\x1a\nblahblahnotactuallyvalidIEND\xaeB`\x82' jpegdata = b'\xff\xd8\xff\xe0\x00\x10JFIFblahblahjpeg(\xa0\x0f\xff\xd9' pdfdata = b'%PDF-1.\ntrailer<</Root<</Pages<</Kids[<</MediaBox[0 0 3 3]>>]>>>>>>' fmt = { 'image/png' : pngdata, 'image/jpeg' : jpegdata, 'application/pdf' : pdfdata } encoded = encode_images(fmt) for key, value in iteritems(fmt): # encoded has unicode, want bytes decoded = decodestring(encoded[key].encode('ascii')) nt.assert_equal(decoded, value) encoded2 = encode_images(encoded) nt.assert_equal(encoded, encoded2) b64_str = {} for key, encoded in iteritems(encoded): b64_str[key] = unicode_to_str(encoded) encoded3 = encode_images(b64_str) nt.assert_equal(encoded3, b64_str) for key, value in iteritems(fmt): # encoded3 has str, want bytes decoded = decodestring(str_to_bytes(encoded3[key])) nt.assert_equal(decoded, value)
def Conectar(self): import json, base64 try: json_data = open(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "config/Variables.json"))) data = json.load(json_data) ConsumerKey = str(data["Consumer_key"]) ConsumerSecret = base64.decodestring(str(data["Consumer_secret"])) json_data.close() json_data = open(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "config/Credenciales.json"))) data = json.load(json_data) AccessKey = str(data["ACCESS_KEY"]) #AccessKey = "asd" AccessSecret = base64.decodestring(str(data["ACCESS_SECRET"])) json_data.close() Auth = tweepy.OAuthHandler(ConsumerKey, ConsumerSecret) Auth.set_access_token(AccessKey, AccessSecret) self.API = tweepy.API(Auth) if(self.API.verify_credentials()): return self.API else: return {"Tipo":0, "Mensaje":"Error al conectar", "Detalle":self.API.__dict__.__str__()} except tweepy.TweepError as e : print e.message print e.__str__() return {"Tipo":0, "Mensaje":"Error al leer Variables", "Detalle":e.__str__()}
def _handle_display_data(self, msg): """ Overridden to handle rich data types, like SVG. """ if not self._hidden and self._is_from_this_session(msg): source = msg["content"]["source"] data = msg["content"]["data"] metadata = msg["content"]["metadata"] # Try to use the svg or html representations. # FIXME: Is this the right ordering of things to try? if data.has_key("image/svg+xml"): self.log.debug("display: %s", msg.get("content", "")) svg = data["image/svg+xml"] self._append_svg(svg, True) elif data.has_key("image/png"): self.log.debug("display: %s", msg.get("content", "")) # PNG data is base64 encoded as it passes over the network # in a JSON structure so we decode it. png = decodestring(data["image/png"].encode("ascii")) self._append_png(png, True) elif data.has_key("image/jpeg") and self._jpg_supported: self.log.debug("display: %s", msg.get("content", "")) jpg = decodestring(data["image/jpeg"].encode("ascii")) self._append_jpg(jpg, True) else: # Default back to the plain text representation. return super(RichIPythonWidget, self)._handle_display_data(msg)
def get(self, article_id): post_path = site_config["post_dir"] + os.sep + article_id.replace(".", "") + ".md" article = SingleFileHandler(post_path) if article["e"]: auth_header = self.request.headers.get("Authorization") if auth_header is None or not auth_header.startswith("Basic "): self.auth() else: try: auth_decoded = base64.decodestring(auth_header[6:]) username, password = auth_decoded.split(":", 2) if username == "201314": key = hashlib.sha256(password).digest() cipher = AES.new(key, AES.MODE_ECB) article["content"] = markdown.markdown( unicode(cipher.decrypt(base64.decodestring(article["content"])), "utf8") ) self.render( "template/article.html", title=site_config["title"], url=site_config["url"], article=article ) else: self.auth() except: self.auth() else: self.render("template/article.html", title=site_config["title"], url=site_config["url"], article=article)
def post(self): params = dict(self.request.POST) logging.debug("PaymentLoginAppHandler with params %s", params) user = self.request.headers.get("X-MCTracker-User", None) password = self.request.headers.get("X-MCTracker-Pass", None) if not (user and password): logging.debug("user not provided") self.response.set_status(500) return if not users.set_json_rpc_user(base64.decodestring(user), base64.decodestring(password)): logging.debug("user not set") self.response.set_status(500) return app_user = users.get_current_user() state = params["state"] login_state = get_login_state(state) if app_user != login_state.app_user: self.response.set_status(500) logging.error("%s tried to finish anothers user login %s", app_user, state) return token = get_api_module(login_state.provider_id).handle_code(login_state) logging.debug('Received token: %s', token) if not finish_login_state(state, token): logging.debug("user already finished this login") self.response.set_status(500) return args = {"result": "success", "payment_provider": serialize_complex_value( get_payment_provider_for_user(app_user, login_state.provider_id), AppPaymentProviderTO, False)} r = json.dumps(args) self.response.out.write(r)
def test_digest_generation(self): token = UsernameDigestToken() token.username = '******' # case 1 token.password = '******' token.nonce = base64.decodestring("8kqcOS9SFYxSRslITbBmlw==") token.created = "2012-10-29T08:18:34.836Z" self.assertEquals(token.generate_digest(), "LOzA3VPv+2hFGOHq8O6gcEXsc/k=") # case 2 token.password = '******' token.nonce = base64.decodestring("m4feQj9DG96uNY1tCoFBnA==") token.created = "2012-10-29T08:49:58.645Z" self.assertEquals(token.generate_digest(), "K80tK4TyuvjuXvMu++O8twrXuTY=") # case 3 token.password = '******' token.nonce = base64.decodestring("MzI2NjYyNzYxMQ==") token.created = "2012-10-29T05:39:24Z" self.assertEquals(token.generate_digest(), "88FDZSIoCwQT9zhMqpcekDvZwVo=")
def authenticate(session, response): '''Process an authentication response. session must be the established session (minimally including assoc_handle and mac_key), response the query string as given in the original URL (i.e. as the CGI variable QUERY_STRING). If authentication succeeds, return the list of signed fields. If the user was not authenticated, NotAuthenticated is raised. If the HTTP request is invalid (missing parameters, failure to validate signature), different exceptions will be raised, typically ValueError. Callers must check openid.response_nonce for replay attacks. ''' response = _prepare_response(response) # 1.1 compat: openid.ns may not be sent # if response['openid.ns'][0] != 'http://specs.openid.net/auth/2.0': # raise ValueError('missing openid.ns') if session['assoc_handle'] != response['openid.assoc_handle'][0]: raise ValueError('incorrect session') if response['openid.mode'][0] == 'cancel': raise NotAuthenticated('provider did not authenticate user (cancelled)') if response['openid.mode'][0] != 'id_res': raise ValueError('invalid openid.mode') if 'openid.identity' not in response: raise ValueError('missing openid.identity') # Will not check nonce value - caller must verify this is not a replay signed = response['openid.signed'][0].split(',') query = [] for name in signed: value = response['openid.'+name][0] value = '%s:%s\n' % (name, value) if sys.version_info >= (3,): value = value.encode('utf-8') query.append(value) query = b('').join(query) mac_key = base64.decodestring(b(session['mac_key'])) transmitted_sig = base64.decodestring(b(response['openid.sig'][0])) computed_sig = hmac.new(mac_key, query, hashlib.sha1).digest() if transmitted_sig != computed_sig: raise ValueError('Invalid signature') # Check that all critical fields are signed. OpenID 2.0 says # that in a positive assertion, op_endpoint, return_to, # response_nonce and assoc_handle must be signed, and claimed_id # and identity if present in the response. 1.1 compatibility # says that response_nonce and op_endpoint may be missing. # In addition, OpenID 1.1 providers apparently fail to sign # assoc_handle often. if response['openid.mode'][0] == 'id_res': if 'return_to' not in signed or \ ('openid.identity' in response and 'identity' not in signed) or \ ('openid.claimed_id' in response and 'claimed_id' not in signed): raise ValueError, "Critical field missing in signature" return signed
def is_ssh_pub_key(key): """Validates if a string is in valid ssh pub key format :param key: A string containing a ssh public key encoded in base64 :return: Boolean """ if not isinstance(key, six.string_types): raise ValueError( "Key should be a string type, received: %s" % type(key)) # 1) a valid pub key has 3 parts separated by space try: key_type, key_string, comment = key.split() except ValueError: # need more than one value to unpack return False # 2) The second part (key string) should be a valid base64 try: base64.decodestring(key_string.encode('ascii')) except base64.binascii.Error: return False # 3) The first part, the type, should be one of below return key_type in ( 'ecdsa-sha2-nistp256', 'ssh-dss', 'ssh-rsa', 'ssh-ed25519' )
def upload_report(self, cr, uid, ids, context=None): from base_report_designer import openerp_sxw2rml import StringIO data=self.read(cr,uid,ids)[0] sxwval = StringIO.StringIO(base64.decodestring(data['file_sxw_upload'])) fp = tools.file_open('normalized_oo2rml.xsl',subdir='addons/base_report_designer/openerp_sxw2rml') newrmlcontent = str(openerp_sxw2rml.sxw2rml(sxwval, xsl=fp.read())) report = self.pool.get('ir.actions.report.xml').write(cr, uid, [data['report_id']], { 'report_sxw_content': base64.decodestring(data['file_sxw_upload']), 'report_rml_content': newrmlcontent }) cr.commit() data_obj = self.pool.get('ir.model.data') id2 = data_obj._get_id(cr, uid, 'base_report_designer', 'view_base_report_file_rml') report = self.pool.get('ir.actions.report.xml').browse(cr, uid, data['report_id'], context=context) if id2: id2 = data_obj.browse(cr, uid, id2, context=context).res_id return { 'view_type': 'form', 'view_mode': 'form', 'res_model': 'base.report.rml.save', 'views': [(id2, 'form')], 'view_id': False, 'type': 'ir.actions.act_window', 'target': 'new', }
def get(self): response = urlfetch.fetch('http://www.bizizaragoza.com/localizaciones/station_map.php').content self.response.headers['Content-Type'] = 'text/plain' response = response.replace('\r', ' ') response = response.replace('\n', ' ') response = response.replace('\t', ' ') #regex = 'GLatLng\((-?\d+\.\d+),(-?\d+\.\d+).+?idStation="\+(\d+)\+\"&addressnew=([a-zA-Z0-9]+)' regex = 'GLatLng\((-?\d+\.\d+),(-?\d+\.\d+).+?idStation=(\d+)&addressnew=([a-zA-Z0-9]+)' matchobjects = re.finditer(regex, response) regex2 = 'idStation="\+(\d+)\+\"&addressnew=([a-zA-Z0-9]+)' matchobjects2 = re.finditer(regex2, response) print matchobjects2 result = [] import base64 for match in matchobjects: s = match.group(4) id = match.group(3) title = "Parada %s" % (id, ) try: subtitle = base64.decodestring(s + '=' * (4 - len(s) % 4)).decode('iso-8859-1') except: lendec = len(s) - (len(s) % 4 if len(s) % 4 else 0) subtitle = base64.decodestring(s[:lendec]) result.append({"name": title, "title": title, "subtitle": subtitle, "lat": float(match.group(1)), "lon": float(match.group(2)), "id": id}) #self.render_json(json.dumps(result)) self.create_service("bizi", result)
def create_key(keytype, key): if keytype == 'ssh-rsa': return paramiko.rsakey.RSAKey(data=base64.decodestring(key)) elif keytype == 'ssh-dss': return paramiko.dsskey.DSSKey(data=base64.decodestring(key)) else: raise ValueError('keytype must be ssh-rsa or ssh-dsa')
def moo(moosic, arglist, opts): print base64.decodestring('''\ ICAgICAgICAoX19fKSAgIChfX18pICAoX19fKSAoX19fKSAgICAgIChfX18pICAgKF9fXykgICAo X19fKSAoX19fKSAgICAgCiAgICAgICAgKG8gbyhfX18pbyBvKShfX18pbykgKG8gbykgKF9fXyko byBvKF9fXylvIG8pKF9fXykgbykgKG8gbykoX19fKQogICAgICAgICBcIC8obyBvKVwgLyAobyBv KS8gKF9fXykgIChvIG8pIFwgLyhvIG8pXCAvIChvIG8pIC8oX19fKS8gKG8gbykKICAgICAgICAg IE8gIFwgLyAgTyAgIFwgL08gIChvIG8pICAgXCAvICAgTyAgXCAvICBPICAgXCAvIE8gKG8gbykg ICBcIC8gCiAgICAgICAgKF9fKSAgTyAoPT0pICAgTyhfXykgXCAvKHx8KSBPICAoX18pICBPIChf XykgICAgKCAgKSBcIC8oX18pIE8gIAogICAgICAgIChvbykoX18pKG9vKShfXykob28pKF9fKShv bykoX18pKG9vKShfXykoIyMpKF9fKShvbykoX18pKG9vKShfXykKICAgICAgICAgXC8gKG9vKSBc LyAob28pIFwvICgsLCkgXC8gKG9vKSBcLyAob28pIFwvIChvbykgXC8gKC0tKSBcLyAoT08pCiAg ICAgICAgKF9fKSBcLyAoX18pIFwvIChfXykgXC8gKF9fKSBcLyAoX18pIFwvIChfXykgXC8gKCws KSBcLyAoX18pIFwvIAogICAgICAgICgqKikoX18pKC0tKShfXykob28pKF9fKSgwMCkoX18pKG9v KShfXykob28pKF9fKShvbykoX18pKG9vKShfXykKICAgICAgICAgXC8gKG9vKSBcLyAob28pIFwv IChvbykgXC8gKG9vKSBcLyAoKiopIFwvIChPTykgXC8gKD8/KSBcLyAob28pCiAgICAgICAgKF9f KSBcLyAoX18pIFwvIChfXykgXC8gKF9fKSBcLyAoX18pIFwvIChfXykgXC8gKF9fKSBcLyAoX18p IFwvIAogICAgICAgIChvbykoX18pKG9vKShfXykoQEApKF9fKShvbykoX18pKG9vKShfXykob28p KF9fKSgtMCkoLCwpKG9vKShfXykKICAgICAgICAgXC8gKG9fKSBcLyAob28pIFwvIChvbykgXC8g KG8jKSBcLyAob28pIFwvIChvbykgXC8gKG9vKSBcLyAob28pCiAgICAgICAgICAgICBcLyAgICAg IFwvICAgICAgXC8gICAgICBcLyAgICAgIFwvICAgICAgXC8gICAgICBcLyAgICAgIFwvIAogICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAoX18pICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAs Jy0wMCAgICAgICAgICAgICAgICAgICAgICAgVGhlIExvY2FsIE1vb3NpY2FsIFNvY2lldHkgICAg ICAKICAgICAgICAgICAvIC9cX3wgICAgICAvICAgICAgICAgICAgICAgICAgICAgICBpbiBDb25j ZXJ0ICAgICAgICAgICAgICAgCiAgICAgICAgICAvICB8ICAgICAgIF8vX19fX19fX19fX19fX19f X19fICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICB8ICAgXD09PV5fX3wg ICAgICAgICAgICAgICAgIF9ffCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAg ICBffF9fXyAvXCAgfF9fX19fX19fX19fX19fX19fX198ICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgCiAgICAgICAgfD09PT09fCB8ICAgSSAgICAgICAgICAgICAgSSAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICpJICAgSXwgfCAgIEkgICAgICAgICAg ICAgIEkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgSSAgIEle IF4gICBJICAgICAgICAgICAgICBJICAgICAgICAgICAgICAgICAgICAgLWNmYmQt''')
def get_metadata(self, name=None): if not name: name = self.get_device_name() request_url = self.bigip.icr_url + '/cm/device/~Common~' request_url += name + '?$select=name,description' response = self.bigip.icr_session.get(request_url, timeout=const.CONNECTION_TIMEOUT) str_comment = None if response.status_code < 400: response_obj = json.loads(response.text) if response_obj['name'] == name: if 'description' in response_obj: str_comment = response_obj['description'] elif response.status_code != 404: Log.error('device', response.text) raise exceptions.DeviceQueryException(response.text) if str_comment: try: return json.loads(base64.decodestring(str_comment)) except: try: return base64.decodestring(str_comment) except: return str_comment return None
def _handle_display_data(self, msg): """ Overridden to handle rich data types, like SVG. """ if not self._hidden and self._is_from_this_session(msg): self.flush_clearoutput() source = msg['content']['source'] data = msg['content']['data'] metadata = msg['content']['metadata'] # Try to use the svg or html representations. # FIXME: Is this the right ordering of things to try? if 'image/svg+xml' in data: self.log.debug("display: %s", msg.get('content', '')) svg = data['image/svg+xml'] self._append_svg(svg, True) elif 'image/png' in data: self.log.debug("display: %s", msg.get('content', '')) # PNG data is base64 encoded as it passes over the network # in a JSON structure so we decode it. png = decodestring(data['image/png'].encode('ascii')) self._append_png(png, True, metadata=metadata.get('image/png', None)) elif 'image/jpeg' in data and self._jpg_supported: self.log.debug("display: %s", msg.get('content', '')) jpg = decodestring(data['image/jpeg'].encode('ascii')) self._append_jpg(jpg, True, metadata=metadata.get('image/jpeg', None)) else: # Default back to the plain text representation. return super(RichIPythonWidget, self)._handle_display_data(msg)
def _handle_display_data(self, msg): """Overridden to handle rich data types, like SVG.""" self.log.debug("display_data: %s", msg.get('content', '')) if self.include_output(msg): self.flush_clearoutput() data = msg['content']['data'] metadata = msg['content']['metadata'] # Try to use the svg or html representations. # FIXME: Is this the right ordering of things to try? self.log.debug("display: %s", msg.get('content', '')) if 'image/svg+xml' in data: svg = data['image/svg+xml'] self._append_svg(svg, True) elif 'image/png' in data: # PNG data is base64 encoded as it passes over the network # in a JSON structure so we decode it. png = decodestring(data['image/png'].encode('ascii')) self._append_png(png, True, metadata=metadata.get('image/png', None)) elif 'image/jpeg' in data and self._jpg_supported: jpg = decodestring(data['image/jpeg'].encode('ascii')) self._append_jpg(jpg, True, metadata=metadata.get('image/jpeg', None)) elif 'text/latex' in data and latex_to_png: try: self._append_latex(data['text/latex'], True) except Exception: self.log.error("Failed to render latex: '%s'", data['text/latex'], exc_info=True) return super(RichJupyterWidget, self)._handle_display_data(msg) else: # Default back to the plain text representation. return super(RichJupyterWidget, self)._handle_display_data(msg)
def parse_eml_string(path): textflag = False base64flag = False linelst = [] # with codecs.open(path, 'r', encoding='gbk') as file: with open(path, 'r') as file: lines = file.readlines() for line in lines: if textflag and base64flag: if 'NextPart' not in line: linelst.append(line) else: break if 'Content-Type' in line: if 'text/plain' in line: textflag = True else: textflag = False continue if 'Content-Transfer-Encoding' in line and 'base64' in line: if textflag: base64flag = True pdb.set_trace() strings = ''.join(map(lambda st:st.replace('\n', ''), linelst)) print base64.decodestring(strings)
def _handle_execute_result(self, msg): """Overridden to handle rich data types, like SVG.""" self.log.debug("execute_result: %s", msg.get('content', '')) if self.include_output(msg): self.flush_clearoutput() content = msg['content'] prompt_number = content.get('execution_count', 0) data = content['data'] metadata = msg['content']['metadata'] if 'image/svg+xml' in data: self._pre_image_append(msg, prompt_number) self._append_svg(data['image/svg+xml'], True) self._append_html(self.output_sep2, True) elif 'image/png' in data: self._pre_image_append(msg, prompt_number) png = decodestring(data['image/png'].encode('ascii')) self._append_png(png, True, metadata=metadata.get('image/png', None)) self._append_html(self.output_sep2, True) elif 'image/jpeg' in data and self._jpg_supported: self._pre_image_append(msg, prompt_number) jpg = decodestring(data['image/jpeg'].encode('ascii')) self._append_jpg(jpg, True, metadata=metadata.get('image/jpeg', None)) self._append_html(self.output_sep2, True) elif 'text/latex' in data: self._pre_image_append(msg, prompt_number) try: self._append_latex(data['text/latex'], True) except Exception: self.log.error("Failed to render latex: '%s'", data['text/latex'], exc_info=True) return super(RichJupyterWidget, self)._handle_execute_result(msg) self._append_html(self.output_sep2, True) else: # Default back to the plain text representation. return super(RichJupyterWidget, self)._handle_execute_result(msg)
def strtoprivkey(data, passphrase): kind = data[0][11:14] if data[1].startswith("Proc-Type: 4,ENCRYPTED"): # encrypted key ivdata = data[2].split(",")[1][:-1] iv = "".join([chr(int(ivdata[i : i + 2], 16)) for i in range(0, len(ivdata), 2)]) if not passphrase: raise BadKeyError, "encrypted key with no passphrase" ba = md5(passphrase + iv).digest() bb = md5(ba + passphrase + iv).digest() decKey = (ba + bb)[:24] b64Data = base64.decodestring("".join(data[4:-1])) keyData = DES3.new(decKey, DES3.MODE_CBC, iv).decrypt(b64Data) removeLen = ord(keyData[-1]) keyData = keyData[:-removeLen] else: keyData = base64.decodestring("".join(data[1:-1])) decodedKey = asn1parse(keyData) if type(decodedKey[0]) == type([]): decodedKey = decodedKey[0] # this happens with encrypted keys if kind == "RSA": n, e, d, p, q = decodedKey[1:6] return RSA.construct((n, e, d, p, q)) elif kind == "DSA": p, q, g, y, x = decodedKey[1:6] return DSA.construct((y, g, p, q, x))
def strtoprivkey(data, password): kind = data[0][11: 14] if data[1].startswith('Proc-Type: 4,ENCRYPTED'): # encrypted key if not password: raise BadKeyPassword("password required") enc_type, salt = data[2].split(": ")[1].split(",") salt = unhexlify(salt.strip()) b64Data = base64.decodestring(''.join(data[4:-1])) if enc_type == "DES-EDE3-CBC": key = get_key_data(salt, password, 24) keyData = DES3.new(key, DES3.MODE_CBC, salt).decrypt(b64Data) elif enc_type == "AES-128-CBC": key = get_key_data(salt, password, 16) keyData = AES.new(key, AES.MODE_CBC, salt).decrypt(b64Data) else: raise BadKeyError("unknown encryption") removeLen = ord(keyData[-1]) keyData = keyData[:-removeLen] else: keyData = base64.decodestring(''.join(data[1:-1])) decodedKey = asn1parse(keyData) if isinstance(decodedKey[0], list): decodedKey = decodedKey[0] # this happens with encrypted keys if kind == 'RSA': n, e, d, p, q = decodedKey[1:6] return RSA.construct((n, e, d, p, q)) elif kind == 'DSA': p, q, g, y, x = decodedKey[1: 6] return DSA.construct((y, g, p, q, x))
def _handle_pyout(self, msg): """ Overridden to handle rich data types, like SVG. """ if not self._hidden and self._is_from_this_session(msg): self.flush_clearoutput() content = msg['content'] prompt_number = content.get('execution_count', 0) data = content['data'] metadata = msg['content']['metadata'] if 'image/svg+xml' in data: self._pre_image_append(msg, prompt_number) self._append_svg(data['image/svg+xml'], True) self._append_html(self.output_sep2, True) elif 'image/png' in data: self._pre_image_append(msg, prompt_number) png = decodestring(data['image/png'].encode('ascii')) self._append_png(png, True, metadata=metadata.get('image/png', None)) self._append_html(self.output_sep2, True) elif 'image/jpeg' in data and self._jpg_supported: self._pre_image_append(msg, prompt_number) jpg = decodestring(data['image/jpeg'].encode('ascii')) self._append_jpg(jpg, True, metadata=metadata.get('image/jpeg', None)) self._append_html(self.output_sep2, True) else: # Default back to the plain text representation. return super(RichIPythonWidget, self)._handle_pyout(msg)
def get_old_torrents(self, personal_channel_only=False, batch_size=BATCH_SIZE, offset=0, sign=False): connection = sqlite3.connect(self.tribler_db) cursor = connection.cursor() personal_channel_filter = "" if self.personal_channel_id: personal_channel_filter = " AND ct.channel_id " + \ (" == " if personal_channel_only else " != ") + \ (" %i " % self.personal_channel_id) torrents = [] for tracker_url, channel_id, name, infohash, length, creation_date, torrent_id, category, num_seeders, \ num_leechers, last_tracker_check in \ cursor.execute( self.select_full + personal_channel_filter + " group by infohash" + (" LIMIT " + str(batch_size) + " OFFSET " + str(offset))): # check if name is valid unicode data try: name = text_type(name) except UnicodeDecodeError: continue try: if len(base64.decodestring(infohash)) != 20: continue if not torrent_id or int(torrent_id) == 0: continue infohash = base64.decodestring(infohash) torrent_dict = { "status": NEW, "infohash": infohash, "size": int(length or 0), "torrent_date": datetime.datetime.utcfromtimestamp(creation_date or 0), "title": name or '', "tags": category or '', "origin_id": 0, "tracker_info": tracker_url or '', "xxx": int(category == u'xxx')} if not sign: torrent_dict.update({ "id_": torrent_id, "timestamp": int(torrent_id), "status": LEGACY_ENTRY, "public_key": dispesy_cid_to_pk(channel_id), "signature": pseudo_signature(), "skip_key_check": True}) health_dict = { "seeders": int(num_seeders or 0), "leechers": int(num_leechers or 0), "last_check": int(last_tracker_check or 0)} torrents.append((torrent_dict, health_dict)) except: continue connection.close() return torrents
def decode_flashget(link): try: l = base64.decodestring(link[11:len(link)-7].encode()).decode() except ValueError: logger.warn(traceback.format_exc()) l = base64.decodestring(link[11:len(link)-7].encode()).decode('gbk') return l[10:len(l)-10]
def action(gid=None): """ Send tar of account data on each enviroment """ import CloudscalerLibcloud import capnp agentcontroller = j.clients.agentcontroller.get() cbcl = j.clients.osis.getNamespace("cloudbroker") jobs = list() capnp.remove_import_hook() schemapath = os.path.join(os.path.dirname(CloudscalerLibcloud.__file__), 'schemas') resources_capnp = capnp.load( os.path.join(schemapath, 'resourcemonitoring.capnp')) # schedule command for location in cbcl.location.search({})[1:]: jobs.append( agentcontroller.scheduleCmd(cmdcategory="greenitglobe", cmdname="collect_account_data", nid=None, timeout=60, roles=['controller'], gid=location["gid"], wait=True)) # get return from each job. accounts = dict() for job in jobs: result = agentcontroller.waitJumpscript(job=job) # read the tar. c = io.BytesIO() if result['state'] != 'OK': raise RuntimeError("Failed to collect account data from grid %s" % (job['gid'])) result_decoded = base64.decodestring(result['result']) c.write(result_decoded) c.seek(0) tar = tarfile.open(mode="r", fileobj=c) members = tar.getmembers() for member in members: if member.name.endswith(".bin"): accountid, year, month, day, hour = re.findall( "opt/jumpscale7/var/resourcetracking/active/([\d]+)/([\d]+)/([\d]+)/([\d]+)/([\d]+)/", member.name)[0] datekey = (year, month, day, hour) accounts.setdefault(accountid, { datekey: [] }).setdefault(datekey, []).append(member) for account_id, dates in accounts.iteritems(): for date, members in dates.iteritems(): account = resources_capnp.Account.new_message() year, month, day, hour = date account.accountId = int(account_id) cloudspaces = account.init("cloudspaces", len(members)) for i, member in enumerate(members): # read the capnp file obj. binary_content = tar.extractfile(member).read() cloudspace_obj = resources_capnp.CloudSpace.from_bytes( binary_content) cloudspaces[i] = cloudspace_obj filepath = '/opt/jumpscale7/var/resourcetracking/%s/' % os.path.join( account_id, year, month, day, hour) try: os.makedirs(filepath) except OSError as err: if err.errno != 17: raise with open(os.path.join(filepath, "account_capnp.bin"), 'w+b') as f: account.write(f)
# -*- coding:utf-8 -*- """ @desc: @author: wuchongxiang @site: @software: PyCharm @file: 20181130.py @time: 2018/11/30 16:17 """ import base64, os code = '''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''' # code = '''UEsDBBQACAgIAEE/fk0AAAAAAAAAAAAAAAARAAAAUGFja2FnZUxhYmVscy5wZGatV2tUE9cWVl7mUouIggoiB0ELUphnZhJEJISHEVQw+KgxtiEZQhASSAYK4qMIllQkYn3gW1C07bpUvT7Qi7UoYBWxVqyKFatYquCrpdZqrcW5ZwIWLN51/9yslTVn9tnn2/vs8+3vJOPiIqICsSDScdwPbd9860gCFBgSUxxDQhCpIdVglKer1AwSwWTp1Ey0UZWDyDMT2Zx0BpGlqbQMMoXRaZNZgONIlC6VZYyIVCpLSIhSZUcwaoOGQRJ417kzElMYNYt02+JUxjRTN3xmmt4ERBQy0/C+iceIAYFYaCgyR6dhk3l7LKPXwhEhpJBwHWuKY4xSQ1q6Qc/oWQAdTayRUaU5jt+5pslzaJPZYu6oT1vT5OWzKRsOV48Z5Tkygq355Zark8AltboozNxxiuNO2shAhpNgtWDs1raC4YkjOM5tZbq5XRBgF13Yeqbd6lBkX1y63D65vJXj/nzHc+gtQXltUElYgfchgaXObxn3Z3lt+FBPy8QwiwhMBeZOjvslXfJepbO36pLUrnwox70QuBwtjP1p1r+lBZWTuRe1diPH/ixRuW6rgtHuSqQC7/1huwTDBhM1HHdNEGz3j7HiVWDncp8dHCfDt7pWrPTMTYIgbzuPd15zaZ5ddMQi77I81yEc91RQftI+MW/4bSfngrxlXNc68enR4+Na86LQSKfhCAxr2SXaHxvg5BzgEM1xv+cHmR9dd44/+uFJm+GCNo67ZZM9CeRFupp9V77P71OS/2mRz3eeEhuJOcwymeP2r3xQ3tr83krj1jkc13khPmz5BdbFcfXNzoEDnB0Zvaan3HDEE0TYS5Seo49KVbFMz7n3nBxNE38dU/bWJbO+Nn6LOt846PWB7Vvflw3O8G2senBj3tRg9kMn7z0Py0tjt1RM9yj07dI6BM3PGan/YsCQE0Xpt+vXGbqGHfvo6+TUfRWXny45Ni+GWDjxwGj/Ve1FHZc+3rl7ScOV+2fuzSNI/3XJ/t4r2txbXIMH1zfY7bp+xydGXHX/jdvVIZ+sD5TeKnp2wj1RbCtKHHL+WHGY5WgDNrph5LCYTeAIUrmAqhm9ae61y1Xte4MrBuiTPbIyVi3MHf/zgZg9Fdu9bv2TdFsB8FEhHtMqswZJt5s/LDPf2XBoEspk1NwMHNb5xcHjh4cWY2htncU8+6TrqMrlgyR7JkaXVmVUDHZPavF8qz0oJ5T7/XFX49obXi4VYyyF34/y8H3ybqfdA7cxxUlrvTOeH7yQILiwd1FE08ztbqdm72MkK6oTXELcjF3P/7hfvji7+mzJvsFfjK2NG/SbfOs11zhNhvzx+T8aOiq9ij7XLF5v3nZ0x/XT7fkZi+nj1ZFaclpUUXZx85BUpaT9zAO0KC1yC1Yc3+QRXDbm+FniWZ7L5jtPvN9MlpTuz3pvSYGw/vrW6R54a2GOw9T0SKfNg8zTqw8NWBy95PH5uw43j40XHXZo/tS8IDF1x5PODcNbf2maV0b/+LEedD52H1joZZs1YEreofnhXk/d7OtTMhu5DbE/Nx/RHh5Xd3+DvfyiIW9p7Jx1l4L8sv51oCxaG7fxgl/XV8++urw6eErR1LVtV2qRI984ebpembH+XO6Jhz4xGWeJ/OQ1Z2vORf90ctIH4zoEPrbBEq+8psh7n3XWTSWDqCd33t14eLp8eNnnXV9tXpjrX1F1Rb57YeTBm8G/t+zPrQ6p+7Xr14D2BYtqD3jsyN10clCN2U1QI21xntCxceH8eI/vhNmmpfb3lgxjPrkYvCzmtMczh09jHa40e24m4jsezW/RGEZEH072enP91U0r9bNyL7/1Q2Pd1aUbLLNPJV19ZHPh2pFJQ+wbRwzoGP3RiVFO+Rc3zHS/GjtyRtT9VTFD9jSW7mF3b1uw/bLdFvDru2MWR6YsuUn/1jz1220XD78YKJMW5PTvI7qv4OpZKG0mwPfWzG7tjONVdiZjMmQa1Qwvm3FGg1rOsECBQOEGSAKTzYJuMQ7veUp7njIlEgUR+QbFAG6FjMIBwQ+gyPaIMpydm4QBzDqtS9NigOx2gC5QqXmlpaxz0xiNThVuyFag8JXCcECLcWVo6Mtt4L3beHlD8Plj3bvg80DCVSbGOpjCpGYxrE6tQiL1UC10ei2UfL1Eb9K9fO/FFfXiRjAmNZ9PIIajiFSV3nP3iEQoImeZtNlATPRG452NunTWYNUlrQlQ0CknleErqNIbTIzfQHsbG7sB3R9/uFt+VTjcIFAE4kIAvyTAUBTl8bsLOV2VxiDyBLlBrw2M5UMjMlaVqlNL9NpUBqCIpDs96N+bvrhP+nOseH+VRyqL4FH5jFH+RZ5jgruQ6ZMM1hqmp6cyaTweCY9fq4OkyfGTQEzGH5lh1DBGWCW/6HCMz/w1JX4lzVfrAUTW85wDFJgCR2mlGKYFCBrullDghAgOhcD6JEglRgNYC5LCAU7zk0qCVFAiEggpyAGxENCEWEmIFUIMU5K4gsDgKgxXkpRCJKYALRQpSThJkkohriApoVJIKmghAWgMA2IaBxRJKylKQWLwIVKQOA2EuBiQGIxPkYAkYRyIiJOQvQQKSBgPx0VKGkLitFIETwaDC0ggwhVClIT58jlTMFOIAyFFIgUlxJViVEEKcUDCnfahK/F6uqL/q5aBs/S66PDAWVI5Hjill76vWLt5qlHpWX65ScFzYGaf2Fj/2FEGY9rrrtFXfj5NU7FGHaQnvx61dqyVmMY03gtg/zeVsPZ++MtWx2g6iAIiKLyU8uW1jouFfa719euOT69HnQtyJ6+IST5nWXYlS+ZrcfcPsZkDmjpf2I9QBlXhLSUT3B9aapSr3/5y0KzVZV+6cc9vJ555Xxbesnvx84my4nH1B13XpaSAQMfcU/mJNvLxRZc2OZt91hdSlz19W+Kfb81O3kUPiw4VRWmHJgWsaZ/w4z7j3vj88AZlwDcJb67cnN12uNOSoq1xuBEfENt87Z27pwNXnd++ae/C1gX5di45d0tqF5ect7WNmvDBOW9bp50NhGNMQ9mq71Ju7P5cVepS5/tGUgHrcrDzfMlarHXKvbez6kyaTLfijWVk29jKM+HFWlufKjkjvLg8pd5+/erP2mTPStnMxnsLgjq/3jencEvQmNDTJReT9i3typhRetv19qMvwyb/8Umq1/Zmw9Oq6skPW9542F/4qV4axOg0JgVtpUmv6pvgfZDJ/9BFZAlzE/zwICyI9u/DIrR3vXWNVAXVyKDtXtst2n28+5BumkETASnmFxGMo5gIwwgUha2K4vP8ESlMkNUZ9P9tHtJKk6lmjH46K6OsOYHEHIAlEHMT+iSXbWSSHCF3cEf0rw+ghEJCCJJAjw32NVQi64z+pQ2jUPrvNhwXk3+3QU9hP5uQ6oeHi4l+eBiJviauuB8eJhJRf7cR/Fs/G9nHjzWqdKmMka8zL+UA675ZZRFAEcIQKI5pVHQiRVJqQq3CSZVYw9BJajJRpUZxVWgIzuAorkY1jJokKDJJzYjFYhLFRUKaQRkNg4Uq4X8lAwushz8TkesWwcbHYd1NrMrIWqtOYELacdy4yBlRjv8BUEsHCNKHT35yCgAA2w0AAFBLAQIUABQACAgIAEE/fk3Sh09+cgoAANsNAAARAAAAAAAAAAAAAAAAAAAAAABQYWNrYWdlTGFiZWxzLnBkZlBLBQYAAAAAAQABAD8AAACxCgAAAAA=''' # code = '''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''' code = '''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''' with open(os.path.expanduser('~/Desktop/test4.zip'), 'wb') as fout: fout.write(base64.decodestring(code))
def process_request(self, req, resp): # http basic auth if self.config['server'].get('enable_basic_auth'): hdr_auth = req.get_header('AUTHORIZATION') if not hdr_auth: raise falcon.HTTPUnauthorized('Access denied', 'No auth header', []) auth = re.sub('^Basic ', '', hdr_auth) usr, pwd = decodestring(auth).split(':') if not equals(self.basic_auth.get(usr, ''), pwd): logger.warning('basic auth failure: %s', usr) raise falcon.HTTPUnauthorized('Access denied', 'Basic auth failure', []) segments = req.path.strip('/').split('/') if segments[0] == 'api': if len(segments) >= 3: # twilio validation if segments[2] == 'twilio': sig = req.get_header('X_TWILIO_SIGNATURE') if sig is None: logger.warning("no twilio signature found!") raise falcon.HTTPUnauthorized('Access denied', 'No Twilio signature', []) uri = [ req.protocol, '://', req.get_header('HOST'), self.config['server'].get('lb_routing_path', ''), req.path ] if req.query_string: uri.append('?') uri.append(req.query_string) post_body = req.context['body'] expected_sigs = [ compute_signature(t, ''.join(uri), post_body) for t in self.twilio_auth_token ] if sig not in expected_sigs: logger.warning( 'twilio validation failure: %s not in possible sigs: %s', sig, expected_sigs) raise falcon.HTTPUnauthorized('Access denied', 'Twilio auth failure', []) return elif self.mobile and segments[2] == 'mobile': # Only allow refresh tokens for /refresh, only access for all else table = 'refresh_token' if segments[ 3] == 'refresh' else 'access_token' key_query = '''SELECT `key`, `target`.`name` FROM `%s` JOIN `target` ON `user_id` = `target`.`id` WHERE `%s`.`id` = %%s AND `expiration` > %%s''' % (table, table) method = req.method auth = req.get_header('Authorization', required=True) items = urllib2.parse_http_list(auth) parts = urllib2.parse_keqv_list(items) if 'signature' not in parts or 'keyId' not in parts or 'timestamp' not in parts: raise falcon.HTTPUnauthorized( 'Authentication failure: invalid header') try: window = int(parts['timestamp']) time_diff = abs(time.time() - window) except ValueError: raise falcon.HTTPUnauthorized( 'Authentication failure: invalid header') client_digest = parts['signature'] key_id = parts['keyId'] body = req.context['body'] path = req.env['PATH_INFO'] qs = req.env['QUERY_STRING'] if qs: path = path + '?' + qs text = '%s %s %s %s' % (window, method, path, body) conn = db.connect() cursor = conn.cursor() cursor.execute(key_query, (key_id, time.time())) row = cursor.fetchone() conn.close() # make sure that there exists a row for the corresponding username if row is None: raise falcon.HTTPUnauthorized( 'Authentication failure: server') key = self.fernet.decrypt(str(row[0])) req.context['user'] = row[1] HMAC = hmac.new(key, text, hashlib.sha512) digest = urlsafe_b64encode(HMAC.digest()) if hmac.compare_digest( client_digest, digest) and time_diff < self.time_window: return else: raise falcon.HTTPUnauthorized( 'Authentication failure: server') elif segments[2] == 'gmail' or segments[ 2] == 'gmail-oneclick' or segments[2] == 'slack': return elif len(segments) == 1: if segments[0] == 'health' or segments[0] == 'healthcheck': return elif segments[0] == self.config['gmail'].get('verification_code'): return elif segments[0] == 'saml': return raise falcon.HTTPUnauthorized('Access denied', 'Authentication failed', [])
def bin_to_python(node): return binary(base64.decodestring(node.text or ''))
def split_mail(msg, fail_on_empty=False): """Deconstruct an email.Message object into a sequence of words; returns an iterator for this sequence. If fail_on_empty is true, then ValueError is raised if no parseable message parts could be found. This function can only handle text parts, and does not attempt to extract meaningful data from other content types. """ coll = set() results = [coll] for tag, hdr in (('from', 'from'), ('from', 'sender'), ('rcpt', 'to'), ('rcpt', 'cc'), ('rcpt', 'bcc')): for name, addr in getaddresses(msg.get_all(hdr, ())): addr = addr.split('@', 1) coll.add('%s:@%s' % (tag, addr[-1].lower())) if len(addr) > 1: coll.add('%s:%s' % (tag, addr[0].lower())) proc = compose(unfold_entities, word_split, lowercase, remove_stopwords, dropwhile(lambda s: s in ('re', 'fwd')), add_prefix('subj', ':')) results.append(proc(msg.get('subject', ''))) found = 0 for part in msg.walk(): if part.get_content_maintype() != 'text': continue # skip non-text parts enc = part.get('content-transfer-encoding') if enc is None: text = part.get_payload() elif enc.lower() == 'quoted-printable': text = quopri.decodestring(part.get_payload()) elif enc.lower() == 'base64': text = base64.decodestring(part.get_payload()) elif enc.lower() in (None, '7bit', '8bit', 'binary'): text = part.get_payload() else: continue # unknown encoding method # Since the content may be encoded with some weird character # set, we'll try to get it back to Unicode so the XML parser # doesn't choke too hard. for cs in part.get_charsets(): if not cs: continue try: text = text.decode(cs) break except UnicodeDecodeError: continue else: # If we can't decode it some other way, try ISO 8859-1, # which subsubmes US ASCII anyway. text = text.decode('latin1') proc = compose(unfold_entities, word_split, lowercase, remove_stopwords, crush_urls, limit_length(100)) sub = part.get_content_subtype() if sub == 'html': proc = compose(strip_html, proc) elif sub not in ('plain', 'enriched'): continue # unknown text type results.append(proc(text)) found += 1 if found == 0 and fail_on_empty: raise ValueError("No parseable content found") return itertools.chain(*results)
def decode(self, data): import base64 self.data = base64.decodestring(data)
def check_store_key(hex_fingerprint): data = 'AAAAB3NzaC1yc2EAAAADAQABAAABAQDJOtsej4dNSKTdMBnD8v6L0lZ1Tk+WTMlxsFf2+pvkdoAu3EB3RZ/frpyV6//bJNTDysyvwgOvANT/K8u5fzrOI2qDZqVU7dtDSwUedM3YSWcSjjuUiec7uNZeimqhEwzYGDcUSSXe7GNH9YsVZuoWEf1du6OLtuXi7iJY4HabU0N49zorXtxmlXcPeGPuJwCiEu8DG/uKQeruI2eQS9zMhy73Jx2O3ii3PMikZt3g/RvxzqIlst7a4fEotcYENtsJF1ZrEm7B3qOBZ+k5N8D3CkDiHPmHwXyMRYIQJnyZp2y03+1nXT16h75cer/7MZMm+AfWSATdp09/meBt6swD' key = paramiko.RSAKey(data=base64.decodestring(data)) if hex_key(key) == hex_fingerprint: return True return False
def serial_number_to_string(value): sval = base64.decodestring(value) unique = [elem.encode("hex") for elem in sval[4:8]] return '{}{}{}{}{}'.format(sval[:4], unique[0], unique[1], unique[2], unique[3]).upper()
# Grotty heuristic to distinguish known_hosts from known_hosts2: # is second field entirely decimal digits? if re.match (r"\d*$", fields[1]): # Treat as SSH-1-type host key. # Format: hostpat bits10 exp10 mod10 comment... # (PuTTY doesn't store the number of bits.) magicnumbers = map (long, fields[2:4]) keytype = "rsa" else: # Treat as SSH-2-type host key. # Format: hostpat keytype keyblob64 comment... sshkeytype, blob = fields[1], base64.decodestring (fields[2]) # 'blob' consists of a number of # uint32 N (big-endian) # uint8[N] field_data subfields = [] while blob: sizefmt = ">L" (size,) = struct.unpack (sizefmt, blob[0:4]) size = int(size) # req'd for slicage (data,) = struct.unpack (">%lus" % size, blob[4:size+4]) subfields.append(data) blob = blob [struct.calcsize(sizefmt) + size : ] # The first field is keytype again, and the rest we can treat as # an opaque list of bignums (same numbers and order as stored
def base64_bytes(x): # type: (AnyStr) -> bytes """Turn base64 into bytes""" if six.PY2: return base64.decodestring(x) # type: ignore return base64.decodebytes(bytes_encode(x))
def get_local(self): return bz2.decompress(base64.decodestring(self.local))
#-*- coding: utf-8 -*- ''' Created on 2013-9-10 @author: nzk @modified by: jackieyang9 ''' import math, zlib, base64 from PIL import Image data = 'eJztWsmOFUcQ/JW5zWUOXWCw8Q2zWd5k2YAxozmAV9kCeZF38e9Qgx6vKjMiMqvfa6bHM9IcICO7OzMisrq6X/93eOXw/YPj43J0MPV/ryLl5OjgeHLItEVK/1fBipTdkeY6IGyRbbhDuvAWseGuU1sh5WASyCvo8J0NsYn6W/rHQCSZudQY2LIwAGIiJEtSeEDCAFj5v97zHxHl7A2NIkFtJAumh22yoO2JXjMF+lYmABKGCLeV//ca/u3RlsUc/8Ng61WpeRb0/u/FmcO/lDXBP6q28v/BKf/gUOU11MswIq/jRoHXlqhAkkyQySKcA0jsbUJs1JxsMW8o5anIc2eNy/ojATL2bWS6y2QiR5Oi9xzOGO3tVNKHK2MfNoytzDgOx395/Kzrn4lXmT5yG8vGN5dhEZaTV0C4nY5PxHRkHh8uDpKfylNiPxtYdnwKusB8vLiUYdykkLHuTjcDb908Ey8xvrl+lenz/e4nx/ZsEVFju7n1zEwl9gtBbEQvvQCRx4s/E0/Kr3BOUITblHn9bVNS/r/Pt/2RBxscF7gt8xLfAa8yPZR3k9IpIVLkW55pNMVn9ebcZ0obdlOy55Q3YEInL9Wj1I0fMhwpIOmXrEV8JMggTOx0fln/TvxI/qtMj8XCpzd9UlQplxQqYXxOXgoBnCyw8X265BPFZEmChaAXy654JOASCK+AV+06rcR+i3564e4bQNprNUik/QqJ5VWTTiux38N3+uh0aJDQTpzFyDCvI1ap+HHh1wGR2YnCCztpYaQS+5P/3c6t8W5Udcb5C3CZp40BnzsDXljL/NJT0fV3gW59e1h1Ukil/DdPufYtPOdbCtSC/+TrNRepH1EwNEdsyzgAtnjP1a6gdUgIVqL+JkQRInijpMtMoXgbQpD+GDAbujbSaaXi3xk/IXL7cPkjbVF7ekxFgShcm70650OwzRkTXUsEKcXV7UB6ttlbfWAHzp2uuhJ7bfbzMxCWS55E0EDJttZL7LvLv5goARVjrywKQJwY4IAjuipkEOAIgVRib5BPt9DRSDN7AAC5QyLQn1Y8z3aqmla45KGZOxIkiLxLb2Eb/m+SX/iJ7rmUru/FUkwVvGswAPkUrHTAPUnh8kI84dcmpap5i3+IOoGukXmBtnQmGklodWcLkmplnxFDhNvK/5113n+d0Tiy3wrStUXvr+9JY4feDuxdLD5quIVxR9BMvOUnwkfM/8b/H+snX9rmNgLw7r8Wt+cawkGh1odSJnl8rr6ovwQ/CX4bmatMn/bLFDQkmUuctXCi57GLL5xoQTs1yya2lJR9JQpvfImezdFkcMMJH4owqJ9sX8l2lDw5iTCYMtEl4qQy9mDH130XCwR+DR/yvAda/r8SbxFhUK2xJL2w2l2Ev4ct2fSpSbfBeekwCxx3Fum0CbzjoJGF06vTvl7RV0QRbgYGdQ0KOW+4/TuV6Yl4p0TXGvSWxYkSyYXOhhBoNrJ37BH7h++cp0il4htGBamPrNPjd/M5YXdJUiBqpzb7HWqWi46uPOFmHTWEMRReqNkfyD4NmULqKwteEkEV8Kq9rD2CrgPHmV9H/eJXKf9Zf+8r99kzQOdSi9AlA53Wnl8+hiWPjK4ZVRv12ahZ+X8mPkPxEdCDdY8aC3r26An9MpfI9ytZnuVMrnDF6mvjVctOkcf3i1TKf4c3CXTLQnOLpgLtN1CzaCN3Yh65Hbmc1tcL8B/B9yLnCEHulhNhlP0LUWHFiq6eSiw4sZh64T/Wlei76p2KWZE2x4lVoH/+nx+BAU/gZ86ZYBkFAYkaPHnxEiqAO44=' chars = '23456789ABCDEFGHJKLMNPRSTUVWXYZabcdefghjkmnpqrsuvwxyz' charims = eval(zlib.decompress(base64.decodestring(data))) def identify(filepath): img=Image.open(filepath) (width,height)=img.size imarr = [] for i in range(0, height): imarr.append([]) for j in range(0, width): (a,b,c) = img.getpixel((j,i)); imarr[i].append(0 if a < 127 else 1) s = '' for i in range(0, height): for j in range(0, width): if imarr[i][j] == 0: black = 0.0 cnt = 0 for k in range(-3, 3): for l in range(-3, 3): if (k != 0 or l != 0) and i + k >= 0 and i + k < height and j + l >= 0 and j + l < width: cnt += 1.0 / math.exp(math.sqrt(k * k + l * l))
class OpaqueMessage(ProtocolBuffer.ProtocolMessage): def __init__(self, contents=None): pass if contents is not None: self.MergeFromString(contents) def MergeFrom(self, x): assert x is not self if _net_proto___parse__python is not None: def _CMergeFromString(self, s): _net_proto___parse__python.MergeFromString(self, 'OpaqueMessage', s) if _net_proto___parse__python is not None: def _CEncode(self): return _net_proto___parse__python.Encode(self, 'OpaqueMessage') if _net_proto___parse__python is not None: def _CEncodePartial(self): return _net_proto___parse__python.EncodePartial(self, 'OpaqueMessage') if _net_proto___parse__python is not None: def _CToASCII(self, output_format): return _net_proto___parse__python.ToASCII(self, 'OpaqueMessage', output_format) if _net_proto___parse__python is not None: def ParseASCII(self, s): _net_proto___parse__python.ParseASCII(self, 'OpaqueMessage', s) if _net_proto___parse__python is not None: def ParseASCIIIgnoreUnknown(self, s): _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'OpaqueMessage', s) def Equals(self, x): if x is self: return 1 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 return initialized def ByteSize(self): n = 0 return n def ByteSizePartial(self): n = 0 return n def Clear(self): pass def OutputUnchecked(self, out): pass def OutputPartial(self, out): pass def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() # tag 0 is special: it's used to indicate an error. # so if we see it we raise an exception. if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", }, 0) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, }, 0, ProtocolBuffer.Encoder.MAX_TYPE) # stylesheet for XML output _STYLE = \ """""" _STYLE_CONTENT_TYPE = \ """""" _PROTO_DESCRIPTOR_NAME = 'OpaqueMessage' _SERIALIZED_DESCRIPTOR = array.array('B') _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("Wh1uZXQvcHJvdG8vb3BhcXVlbWVzc2FnZS5wcm90bwoNT3BhcXVlTWVzc2FnZboBVgodbmV0L3Byb3RvL29wYXF1ZW1lc3NhZ2UucHJvdG8iDwoNT3BhcXVlTWVzc2FnZUIkChxjb20uZ29vZ2xlLmlvLnByb3RvY29sLnByb3RvEAEgASgB")) if _net_proto___parse__python is not None: _net_proto___parse__python.RegisterType( _SERIALIZED_DESCRIPTOR.tostring())
def i_generate_verification_pic(user, res_obj, debug=False): """ There two types response, HTTP status 421 or SIPResponse code 421, the former response body contains verification node, the latter contains reason note only. """ body_dom = minidom.parseString(res_obj.body) veri_nodes = body_dom.getElementsByTagName("verification") if veri_nodes: veri_node = veri_nodes[0] attr = veri_node.getAttribute algorithm = attr("algorithm") _type = attr("type") text = attr("text") tips = attr("tips") else: reason_node = body_dom.getElementsByTagName("reason")[0] w_val = res_obj.headers.get_field_value("W") algorithm = strip2(w_val, 'algorithm="', '",') _type = strip2(w_val, 'type="', '"') text = reason_node.getAttribute("text") tips = "" veri = Verification(algorithm=algorithm, _type=_type, text=text, tips=tips) ssi_cookie = user.get_ssi_cookie() or "" host = "nav.fetion.com.cn" headers = dict({ 'Cookie': 'ssic=%s' % ssi_cookie, "Connection": "close", "User-Agent": "IIC2.0/PC %s" % PROTOCOL_VERSION, }) httplib.HTTPConnection.response_class = HTTPResponse conn = httplib.HTTPConnection(host) if debug: debuglevel = 1 else: debuglevel = 0 conn.set_debuglevel(debuglevel) if veri.algorithm: algorithm = veri.algorithm else: algorithm = "" url = '/nav/GetPicCodeV4.aspx?algorithm=%s' % algorithm conn.request("GET", url, headers=headers) res_obj = conn.getresponse() assert httplib.OK == res_obj.status body_dom = minidom.parseString(res_obj.body) conn.close() pic_cert_node = body_dom.getElementsByTagName("pic-certificate")[0] attr = pic_cert_node.getAttribute veri.pid = attr("id") pic_base64 = attr("pic") pic_save_path = os.path.join(get_user_config_path(), "%s" % user.sid, "verify_code.jpeg") with open(pic_save_path, "wb") as f: f.write(base64.decodestring(pic_base64)) veri.picture_path = pic_save_path return veri
def action_send_eletronic_invoice(self): self.state = 'error' self.data_emissao = datetime.now() super(InvoiceEletronic, self).action_send_eletronic_invoice() if self.model not in ('55', '65'): return nfe_values = self._prepare_eletronic_invoice_values() lote = self._prepare_lote(self.id, nfe_values) cert = self.company_id.with_context({'bin_size': False}).nfe_a1_file cert_pfx = base64.decodestring(cert) certificado = Certificado(cert_pfx, self.company_id.nfe_a1_password) resposta_recibo = None resposta = autorizar_nfe(certificado, **lote) retorno = resposta['object'].Body.nfeAutorizacaoLoteResult retorno = retorno.getchildren()[0] if retorno.cStat == 103: obj = { 'estado': self.company_id.partner_id.state_id.ibge_code, 'ambiente': 1 if self.ambiente == 'producao' else 2, 'obj': { 'ambiente': 1 if self.ambiente == 'producao' else 2, 'numero_recibo': retorno.infRec.nRec } } self.recibo_nfe = obj['obj']['numero_recibo'] import time while True: time.sleep(2) resposta_recibo = retorno_autorizar_nfe(certificado, **obj) retorno = resposta_recibo['object'].Body.\ nfeRetAutorizacaoLoteResult.retConsReciNFe if retorno.cStat != 105: break if retorno.cStat != 104: self.codigo_retorno = retorno.cStat self.mensagem_retorno = retorno.xMotivo else: self.codigo_retorno = retorno.protNFe.infProt.cStat self.mensagem_retorno = retorno.protNFe.infProt.xMotivo if self.codigo_retorno == '100': self.write({ 'state': 'done', 'nfe_exception': False, 'protocolo_nfe': retorno.protNFe.infProt.nProt, 'data_autorizacao': retorno.protNFe.infProt.dhRecbto }) # Duplicidade de NF-e significa que a nota já está emitida # TODO Buscar o protocolo de autorização, por hora só finalizar if self.codigo_retorno == '204': self.write({ 'state': 'done', 'codigo_retorno': '100', 'nfe_exception': False, 'mensagem_retorno': 'Autorizado o uso da NF-e' }) # Denegada e nota já está denegada if self.codigo_retorno in ('302', '205'): self.write({'state': 'denied', 'nfe_exception': True}) self.env['invoice.eletronic.event'].create({ 'code': self.codigo_retorno, 'name': self.mensagem_retorno, 'invoice_eletronic_id': self.id, }) self._create_attachment('nfe-envio', self, resposta['sent_xml']) self._create_attachment('nfe-ret', self, resposta['received_xml']) recibo_xml = resposta['received_xml'] if resposta_recibo: self._create_attachment('rec', self, resposta_recibo['sent_xml']) self._create_attachment('rec-ret', self, resposta_recibo['received_xml']) recibo_xml = resposta_recibo['received_xml'] if self.codigo_retorno == '100': nfe_proc = gerar_nfeproc(resposta['sent_xml'], recibo_xml) self.nfe_processada = base64.encodestring(nfe_proc) self.nfe_processada_name = "NFe%08d.xml" % self.numero
def create_risk(risk, parent_id=None, number="1"): risk_template = u"""--- layout: risk fid: {id} classes: {classes} number: "{number}" parent_id: {parent_id} title: "{title}" problem_description: "{problem_description}" description: "{description}" legal_reference: "{legal_reference}" evaluation_method: {evaluation_method} measures_in_place: {measures_in_place} {image_information} solutions: solution_1: description: "Visual inspection of work areas." action_plan: "Make sure a visual inspection of work areas is carried out in order to identify the potential hazards of falls and slips. Check that the anti-fall fittings and protective measures are present and in good condition." --- {body} """.format title = risk.find("title").text id = str2filename(title) problem_description = _r(risk.find("problem-description").text) description = unescape(_r(risk.find("description").text)) legal_reference_node = risk.find("legal-reference") legal_reference = ( legal_reference_node and unescape(_r(legal_reference_node.text)) or "" ) global risk_counter if risk_counter < len(EVALUATION_TYPES): evaluation_method = EVALUATION_TYPES[risk_counter] state = "answered" risk_class = "risk" print(u"Risk {0} with method {1}".format(title, evaluation_method)) else: evaluation_method = random.choice(EVALUATION_TYPES) state = random.choice(STATES) risk_class = state == "answered" and random.choice(["risk", ""]) or "" classes = "{} {}".format(state, risk_class) # solutions = risk.find("solutions").text # xxx handle the sub solutions risk_counter += 1 images = risk.findAll("image") image_data = [] image_info = u"" for image in images: image_path = os.path.join(media_path, image["filename"]) image_filename = os.path.join(dir_path, image_path) with open(image_filename, "w") as img_file: img_file.write(base64.decodestring(image.contents[0])) image_data.append( dict(url=u"/{0}".format(image_path), caption=image.get("caption", "")) ) if image_data: image_info = u"images:\n" for entry in image_data: image_info += u" - url: {0}\n".format(entry["url"]) image_info += u" caption: {0}\n".format(entry["caption"]) mip = "" existing_measures = _r(risk.find("existing_measures").text) if existing_measures: # import pdb; pdb.set_trace( ) for measure in existing_measures.split("\n"): if measure.strip(): mip += u' - label: "%s"\n state: checked\n' % ( measure.replace(" ", "") ) fields = { "id": id, "title": title, "classes": classes.strip(), "number": number, "parent_id": parent_id, "module": "\nmodule: {}".format(parent_id) if parent_id else "", "description": description, "problem_description": problem_description, "legal_reference": legal_reference, "evaluation_method": evaluation_method, "body": html2text(description), "measures_in_place": mip, "image_information": image_info, } content = risk_template(**fields) write_md(id, content)
def upload_crash_file(self, system_id, crash, crash_file): self.auth_system(system_id) self._check_crash_reporting_setting() required_keys = ['filename', 'path', 'filesize', 'filecontent', 'content-encoding'] for k in required_keys: if not (crash_file.has_key(k)): log_debug(1, self.server_id, "The crash file data is invalid or incomplete: %s" % crash_file) raise rhnFault(5001, "Missing or invalid key: %s" % k) log_debug(1, self.server_id, crash, crash_file['filename']) server_org_id = self.server.server['org_id'] server_crash_dir = get_crash_path(str(server_org_id), str(self.server_id), crash) if not server_crash_dir: log_debug(1, self.server_id, "Error composing crash directory path") raise rhnFault(5002) server_filename = get_crashfile_path(str(server_org_id), str(self.server_id), crash, crash_file['filename']) if not server_filename: log_debug(1, self.server_id, "Error composing crash file path") raise rhnFault(5003) if not crash_file['content-encoding'] == 'base64': log_debug(1, self.server_id, "Invalid content encoding: %s" % crash_file['content-encoding']) raise rhnFault(5004, "Invalid content encodig: %s" % crash_file['content-encoding']) crash_id = self._get_crash_id(self.server_id, crash) if not crash_id: log_debug(1, self.server_id, "No record for crash: %s" % crash) raise rhnFault(5005, "Invalid crash name: %s" % crash) # Create or update the crash file record in DB self._create_or_update_crash_file(self.server_id, crash_id, crash_file['filename'], crash_file['path'], crash_file['filesize']) rhnSQL.commit() # Create the file on filer if not self._is_crashfile_uploading_enabled(server_org_id): return 1 filecontent = base64.decodestring(crash_file['filecontent']) claimed_filesize = crash_file['filesize'] filesize = len(filecontent) sizelimit = self._get_crashfile_sizelimit() if (claimed_filesize > sizelimit or filesize > sizelimit) and sizelimit != 0: if filesize == 0: filesize = claimed_filesize log_debug(1, "The file [%s] size (%s bytes) is more than allowed (%s bytes), skipping." % (crash_file['path'], filesize, sizelimit)) return 0 absolute_dir = os.path.join(CFG.MOUNT_POINT, server_crash_dir) absolute_file = os.path.join(absolute_dir, crash_file['filename']) if not os.path.exists(absolute_dir): log_debug(1, self.server_id, "Creating crash directory: %s" % absolute_dir) os.makedirs(absolute_dir) mode = stat.S_IRWXU | stat.S_IRWXG | stat.S_IROTH | stat.S_IXOTH os.chmod(absolute_dir, mode) os.chmod(os.path.dirname(os.path.normpath(absolute_dir)), mode) log_debug(1, self.server_id, "Creating crash file: %s" % absolute_file) f = open(absolute_file, 'w+') f.write(filecontent) f.close() self._set_crashfile_upload_flag(self.server_id, crash_id, crash_file['filename'], crash_file['path'], crash_file['filesize']) if crash_file['filename'] in self.watched_items: # 'username' contains an extra '\n' at the end if crash_file['filename'] == 'username': filecontent = filecontent.strip() st = rhnSQL.Statement(_query_update_watched_items % crash_file['filename']) h = rhnSQL.prepare(st) h.execute(filecontent=filecontent, crash_id=crash_id) rhnSQL.commit() return 1
def action_cancel_document(self, context=None, justificativa=None): if self.model not in ('55', '65'): return super( InvoiceEletronic, self).action_cancel_document(justificativa=justificativa) if not justificativa: return { 'name': 'Cancelamento NFe', 'type': 'ir.actions.act_window', 'res_model': 'wizard.cancel.nfe', 'view_type': 'form', 'view_mode': 'form', 'target': 'new', 'context': { 'default_edoc_id': self.id } } cert = self.company_id.with_context({'bin_size': False}).nfe_a1_file cert_pfx = base64.decodestring(cert) certificado = Certificado(cert_pfx, self.company_id.nfe_a1_password) id_canc = "ID110111%s%02d" % (self.chave_nfe, self.sequencial_evento) cancelamento = { 'idLote': self.id, 'estado': self.company_id.state_id.ibge_code, 'ambiente': 2 if self.ambiente == 'homologacao' else 1, 'eventos': [{ 'Id': id_canc, 'cOrgao': self.company_id.state_id.ibge_code, 'tpAmb': 2 if self.ambiente == 'homologacao' else 1, 'CNPJ': re.sub('[^0-9]', '', self.company_id.cnpj_cpf), 'chNFe': self.chave_nfe, 'dhEvento': datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%S-00:00'), 'nSeqEvento': self.sequencial_evento, 'nProt': self.protocolo_nfe, 'xJust': justificativa }] } resp = recepcao_evento_cancelamento(certificado, **cancelamento) resposta = resp['object'].Body.nfeRecepcaoEventoResult.retEnvEvento if resposta.cStat == 128 and \ resposta.retEvento.infEvento.cStat in (135, 136, 155): self.state = 'cancel' self.codigo_retorno = resposta.retEvento.infEvento.cStat self.mensagem_retorno = resposta.retEvento.infEvento.xMotivo self.sequencial_evento += 1 else: if resposta.cStat == 128: self.codigo_retorno = resposta.retEvento.infEvento.cStat self.mensagem_retorno = resposta.retEvento.infEvento.xMotivo else: self.codigo_retorno = resposta.cStat self.mensagem_retorno = resposta.xMotivo self.env['invoice.eletronic.event'].create({ 'code': self.codigo_retorno, 'name': self.mensagem_retorno, 'invoice_eletronic_id': self.id, }) self._create_attachment('canc', self, resp['sent_xml']) self._create_attachment('canc-ret', self, resp['received_xml'])
def ADencrypt(self, data, iv): key = '9dbb5e376e65a64324e9269775dafd5b83c38f1d8819d5f1dc4ec2083c081bdb' cbc = common.AES_CBC(binascii.unhexlify(key)) encdata = cbc.encrypt(data, base64.decodestring(iv)) return base64.encodestring(encdata).replace('\n', '')
def write(self, vals): f = vals.get('file') if f: vals.update({'content': base64.decodestring(f), 'file': False}) return super(DocumentTemplate, self).write(vals)
def merge_attachment(self): filename = 'Print Shipping Labels.pdf' picking_obj = self.env['stock.picking'] picking = picking_obj.browse(self._context.get('active_ids')) lst =[] writer = PdfWriter() for pick in picking: pick.shipping_label_print_bool = True ship_name = 'Shipping labels' "%s" %pick.name if not pick.ship_label_bool : attachments = self.env['ir.attachment'].search([('res_id','=',pick.id)]) else: attachments = self.env['ir.attachment'].search([('res_id','=',pick.id),('name','=',ship_name)]) for att in attachments: lst.append(att) # writer = PdfFileWriter() # inpfn, = sys.argv[1:] # outfn = '4up.' + os.path.basename(inpfn) # pages = PdfReader(inpfn).pages def get4(srcpages): if not pick.ship_label_bool: scale = 0.35 srcpages = PageMerge() + srcpages x_increment, y_increment = (scale * i for i in srcpages.xobj_box[2:]) for i, page in enumerate(srcpages): page.scale(scale) page.x = x_increment if i & 1 else 0 page.y = 0 if i & 2 else y_increment return srcpages.render() if pick.ship_label_bool: scale = 0.88 srcpages = PageMerge() + srcpages x_increment, y_increment = (scale * i for i in srcpages.xobj_box[2:]) for i, page in enumerate(srcpages): page.scale(scale) # page.x = x_increment if i & 1 else 0 # page.y = 0 if i & 2 else y_increment # print "parrrrrrrrrrrrrrrrrrrrrr",page.x,page.y return srcpages.render() def get4_fedex(srcpages): scale = 0.88 srcpages = PageMerge() + srcpages x_increment, y_increment = (scale * i for i in srcpages.xobj_box[2:]) for i, page in enumerate(srcpages): page.scale(scale) # page.x = x_increment if i & 1 else 0 # page.y = 0 if i & 2 else y_increment # print "parrrrrrrrrrrrrrrrrrrrrr",page.x,page.y return srcpages.render() for pdf in lst: pages = PdfReader(BytesIO(base64.decodestring(pdf.datas))).pages pick1 = picking_obj.browse(pdf.res_id) for index in range(0, len(pages), 1): if pick1.carrier_id.delivery_type =='ups': writer.addpage(get4(pages[index:index + 1])) if pick1.carrier_id.delivery_type =='fedex': writer.addpage(get4_fedex(pages[index:index + 1])) # Return merged PDF s = BytesIO() writer.write(s) reader = PdfFileReader(s) writer = PdfFileWriter() for page in range(0, reader.getNumPages()): p=reader.getPage(page) if pick1.carrier_id.delivery_type =='fedex' and not pick1.ship_label_bool : p.mediaBox.lowerRight = (900, 145) p.mediaBox.lowerLeft = (-600, 390) p.mediaBox.upperLeft = (99, 500) p.mediaBox.upperRight = (530, 680) if pick1.carrier_id.delivery_type =='ups' and not pick1.ship_label_bool: p.mediaBox.lowerRight = (450, 145) p.mediaBox.upperRight = (425, 600) p.mediaBox.lowerLeft = (-150, 275) p.mediaBox.upperLeft = (-5, 565) writer.addPage(p) s = BytesIO() writer.write(s) out = base64.b64encode(s.getvalue()) view_report_status_id=self.env['view.report'].create({'file_name':out,'datas_fname':filename}) return { 'res_id' :view_report_status_id.id, 'name' :'Print Shipping Labels', 'view_type':'form', 'view_mode':'form', 'res_model':'view.report', 'view_id' : False , 'type' :'ir.actions.act_window', }
def ADdecrypt(self, data): key = '9d489e6c3adfb6a00a23eb7afc8944affd180546c719db5393e2d4177e40c77d' bindata = base64.decodestring(data)[1:] cbc = common.AES_CBC(binascii.unhexlify(key)) return cbc.decrypt(bindata)
#print(decode_str(value)) #print(decode_header(value)) #print(parseaddr(value)) if __name__ == '__main__': #email= input('Email:') email="*****@*****.**" email_ext=email.split('@')[-1] #email="*****@*****.**" #password=input('Password:'******'anBoa3lpaXFncWhkYmZmYQ==\n' STR163=b'd2FuZ3hpYTM0NjExOTE=\n' password=base64.decodestring(STR163).decode('utf-8') #password="******" #pop3_server=input('POP3 server:') #pop3_server="pop.qq.com" pop3_server="pop.163.com" ##connect to POP3 server server=poplib.POP3_SSL(pop3_server,'995') #enable debug info #server.set_debuglevel(1) #welcome banner print(server.getwelcome().decode('utf-8')) # identity authorization server.user(email) server.pass_(password)
def main(): global IS_CW global JIRA_ID if APP_IDS != None: for APP_ID in APP_IDS.split(','): APP_V = get_latest_version(APP_ID) if (APP_V == "###"): print "Any version of the app", APP_ID, "is not available on 1sot" else: print "For app:", APP_ID print "latest version on 1sot is:", APP_V if query_yes_no("Change the version?", "yes"): sys.stdout.write("Enter the version: ") choice = raw_input() APP_V = choice APP_VS[APP_ID] = APP_V print "" APP_IDSS.append(APP_ID) print "*+Pre-checks for stack+*" print " - stack: ", STACK content = "" try: urllib3.contrib.pyopenssl.inject_into_urllib3() urllib3.disable_warnings() user_agent = {'user-agent': 'Mozilla/5.0 (Windows NT 6.3; rv:36.0) ..'} http = urllib3.PoolManager(10, headers=user_agent) url = 'https://api.github.com/repos/SplunkStorm/stax/contents/' + STACK + '.json?access_token=' + TOKEN result = http.request("GET", url) if result.status == 200: req = json.loads(result.data) content = base64.decodestring(req['content']) j = json.loads(content) print " - Splunk Account: ", j['attributes']['cloud_vendor'][ 'account'] print " - Splunk Version: ", j['attributes']['splunkwhisper'][ 'splunk_version'] print " - Is the stack CloudWorks: *No*" IS_CW = 0 elif result.status == 404: adhoc_sh = dns.resolver.query(STACK + '.splunkcloud.com', 'CNAME')[0].target[0] sh_id = dns.resolver.query( adhoc_sh + '.' + STACK + '.splunkcloud.com', 'CNAME')[0].target.__str__() if "sh" in sh_id: IS_CW = 1 print " - Is the stack CloudWorks: *Yes*" else: print "*Stack is not available*" else: print "Github Error with response code :*" + result.status.__str__( ) + "*" except: print "Github Error: *Run the script with sudo* or invalid stack name or check the token value in variables.py" if PASSWORD != "###": sf, rf = check_SF_RF() print " - Search Factor: ", sf print " - Replication Factor: ", rf if sf == "False" or rf == "False": ERROR.append("SF/RF") stack_available = 1 try: answers = dns.resolver.query(STACK + '.splunkcloud.com', 'CNAME') if "shc" not in answers[0].target[0]: print " - adhoc sh: ", answers[0].target SHs['adhoc SH'] = answers[0].target[0] else: print "*" + STACK + '.splunkcloud.com ' + "is pointing to SHC*" except: print "*" + STACK + '.splunkcloud.com ' + "DNS is not available*" ERROR.append("STACK") stack_available = 0 if stack_available == 1: try: answers = dns.resolver.query('es-' + STACK + '.splunkcloud.com', 'CNAME') print " - es sh: ", answers[0].target SHs['es SH'] = answers[0].target[0] except: print " - es sh: *DNS not available*" try: answers = dns.resolver.query('itsi-' + STACK + '.splunkcloud.com', 'CNAME') print " - itsi sh: ", answers[0].target SHs['itsi SH'] = answers[0].target[0] except: print " - itsi sh: *DNS not available*" try: answers = dns.resolver.query( 'vmware-' + STACK + '.splunkcloud.com', 'CNAME') print " - vmware sh:", answers[0].target SHs['vmware SH'] = answers[0].target[0] except: print " - vmware sh: *DNS not available*" try: answers = dns.resolver.query('pci-' + STACK + '.splunkcloud.com', 'CNAME') print " - pci sh:", answers[0].target SHs['pci SH'] = answers[0].target[0] except: print " - pci sh: *DNS not available*" try: answers = dns.resolver.query( 'exchange-' + STACK + '.splunkcloud.com', 'CNAME') print " - exchange sh:", answers[0].target SHs['exchange SH'] = answers[0].target[0] except: print " - exchange sh: *DNS not available*" print "" if APP_IDS != None: appcert_flg = 0 checked_app_ids = [] for APP_ID in APP_IDSS: APP_V = APP_VS[APP_ID] print "*+Pre-checks for " + APP_ID + " v" + APP_V + "+*" tmp = check_on_1sot(APP_ID, APP_V) if tmp != "not": print " - 1sot: ", APP_ID + "_" + APP_V + tmp else: print " - The app " + APP_ID + " v" + APP_V + " is not available on 1sot" ERROR.append("1SOT") appcert_f = 0 options = {'server': jira_server, 'verify': False} jira = JIRA(options=options, basic_auth=(jira_user, jira_password)) query = 'project = APPCERT AND status = Closed AND resolution = "Fixed" AND text ~ "' + APP_ID + ' v' + APP_V + '"' issues = jira.search_issues(query) if len(issues) != 0: for issue in issues: print " - APPCERT: ", issue.__str__( ) + ", status: " + issue.fields.status.__str__( ) + ", resolution: ", issue.fields.resolution.__str__() appcert_f = 1 if appcert_f == 0: print "*Automation failed to find APPCERT JIRA*" ERROR.append("APPCERT") appcert_flg = 1 splunkbase = check_on_splunkbase(APP_ID, APP_V) if splunkbase != "ERROR_404": print " - Splunk-Base: available" print " - Supported Splunk versions: ", splunkbase else: print " - The app " + APP_ID + " v" + APP_V + " is not available on Splunk-Base" folder_name, _status = self_service_check(APP_ID) if "ERROR" not in _status: if _status == "appmgmt_phase": print " - *The app supports self-service installation*" elif _status == "assisted": print " - self-service installation: No" elif _status == "unknown": print " - *This app is not yet vetted to install on Splunk Cloud*" elif _status == "rejected": print " - *This app is not yet vetted to install on Splunk Cloud*" if PASSWORD != "###": #folder_name = get_app_folder_name(APP_ID+"_"+APP_V+tmp) if "ERROR" not in folder_name: print " - App directory name: ", folder_name for key, value in SHs.iteritems(): installed, restart_req, current_ver, install_method = get_install_status( folder_name, value) if installed == "yes": print " - *The app " + APP_ID + " is already installed on " + key + " with " + current_ver + " version.*" print " - need Splunk restart after upgrade?: " + restart_req if install_method == "True": print " - This app has been installed via self-service. *Do not upgrade on " + key + "*" else: print " - This app has been installed by Ops." else: print " - Is it already installed on " + key + " SH: No" url = CONFLUENCE_URL api = Api(url, jira_user, jira_password) text = api.getpagecontent("Splunk Cloud Apps Information List", "CLOUDOPS") soup = BeautifulSoup(text.encode("utf-8"), "html.parser") ids = "" if len(soup.findAll("span")) != 0: for span_tag in soup.findAll("span"): if span_tag != None and span_tag.find(text=True) != None: tmp = span_tag.find(text=True) span_tag.replace_with(tmp) if len(soup.findAll("p")) != 0: for span_tag in soup.findAll("p"): if span_tag != None and span_tag.find(text=True) != None: tmp = span_tag.find(text=True) span_tag.replace_with(tmp) if len(soup.findAll("br")) != 0: for span_tag in soup.findAll("br"): if span_tag != None and span_tag.find(text=True) != None: tmp = span_tag.find(text=True) span_tag.replace_with(tmp) if len(soup.findAll("td", text=APP_ID)) != 0: for nodes in soup.findAll("td", text=APP_ID): allnodes = nodes.parent.findAll(recursive=False) if allnodes[0].find(text=True) == APP_ID: print " - APP DETAILS" print "\tApp-ID: ", allnodes[0].find( text=True).replace(" ", "") sys.stdout.write("\tcan be installed on: ") if allnodes[4].find( text=True ) != None and "true" in allnodes[4].find( text=True).replace(" ", "").lower(): sys.stdout.write("sh ") if allnodes[5].find( text=True ) != None and "true" in allnodes[5].find( text=True).replace(" ", "").lower(): sys.stdout.write("c0m1 ") if allnodes[6].find( text=True ) != None and "true" in allnodes[6].find( text=True).replace(" ", "").lower(): sys.stdout.write("hfw ") if allnodes[7].find( text=True ) != None and "true" in allnodes[7].find( text=True).replace(" ", "").lower(): sys.stdout.write("ufw ") print "" if allnodes[12].find( text=True) != None and allnodes[12].find( text=True).replace(" ", "").strip().replace( " ", "") != "": print "\tdependent apps: ", allnodes[12].find( text=True).replace(" ", "") if allnodes[12].find(text=True) != None: ids = allnodes[12].find(text=True).replace( " ", "") else: print "*App is not available on confluence page*" ids = ids.split('|') for _id in ids: if _id not in APP_IDSS: _id = ''.join(c for c in _id if c.isdigit()) if len(soup.findAll("td", text=_id)) != 0: for nodes in soup.findAll("td", text=_id): allnodes = nodes.parent.findAll(recursive=False) if allnodes[0].find(text=True) == _id: print " - APP DETAILS for dependent app ", _id print "\tApp-ID: ", allnodes[0].find( text=True).replace(" ", "") sys.stdout.write("\tcan be installed on: ") if allnodes[4].find( text=True ) != None and "true" in allnodes[4].find( text=True).replace(" ", "").lower(): sys.stdout.write("sh ") if allnodes[5].find( text=True ) != None and "true" in allnodes[5].find( text=True).replace(" ", "").lower(): sys.stdout.write("c0m1 ") if allnodes[6].find( text=True ) != None and "true" in allnodes[6].find( text=True).replace(" ", "").lower(): sys.stdout.write("hfw ") if allnodes[7].find( text=True ) != None and "true" in allnodes[7].find( text=True).replace(" ", "").lower(): sys.stdout.write("ufw ") print "" if allnodes[12].find( text=True) != None and allnodes[ 12].find(text=True).replace( " ", "").strip().replace( " ", "") != "": print "\tdependent apps: ", allnodes[ 12].find(text=True).replace( " ", "") _v = get_latest_version(_id) print "\tlatest version: " + _v splunkbase = check_on_splunkbase(_id, _v) if splunkbase != "ERROR_404": print "\tSplunk-Base: available" print "\tSupported Splunk versions: ", splunkbase else: print "\tThe app " + _id + " v" + _v + " is not available on Splunk-Base" tmp = check_on_1sot(_id, _v) if tmp != "not": print "\t1sot: ", _id + "_" + _v + tmp else: print "\tThe app " + _id + " v" + _v + " is not available on 1sot" if PASSWORD != "###": folder_name, _status = self_service_check( _id) if "ERROR" not in _status: if _status == "appmgmt_phase": print "\t*The app supports self-service installation*" elif _status == "assisted": print "\tself-service installation: No" elif _status == "unknown": print "\t*This app is not yet vetted to install on Splunk Cloud*" elif _status == "rejected": print "\t*This app is not yet vetted to install on Splunk Cloud*" if "ERROR" not in folder_name: print "\tApp directory name: ", folder_name for key, value in SHs.iteritems(): installed, restart_req, current_ver, install_method = get_install_status( folder_name, value) if installed == "yes": print "\t*The app " + _id + " is already installed on " + key + " SH with " + current_ver + " version.*" print "\tneed Splunk restart after upgrade: " + restart_req if install_method == "True": print "\tThis app has been installed via self-service. *Do not upgrade on " + key + "*" else: print "\tThis app has been installed by Ops." else: print "\tIs it already installed on " + key + " SH: No" appcert_f = 0 options = {'server': jira_server} jira = JIRA(options=options, basic_auth=(jira_user, jira_password)) query = 'project = APPCERT AND status = Closed AND resolution = "Fixed" AND text ~ "' + _id + ' v' + _v + '"' issues = jira.search_issues(query) if len(issues) != 0: for issue in issues: print "\tAPPCERT: ", issue.__str__( ) + ", status: " + issue.fields.status.__str__( ) + ", resolution: ", issue.fields.resolution.__str__( ) appcert_f = 1 if appcert_f == 0: print "\t*Automation failed to find APPCERT JIRA for dependent app", _id + "*" else: print "*dependent app is not available on confluence page*" print "" if appcert_flg == 1: print "Gone through below JIRA to get the remaining APPCERT JIRA" sys.stdout.write("Enter the app install JIRA ID (CO-12345): ") JIRA_ID = raw_input() issue = jira.issue(JIRA_ID) for link in issue.fields.issuelinks: #print link.key if hasattr(link, "outwardIssue"): outwardIssue = link.outwardIssue print "\t", outwardIssue.key + " " + outwardIssue.fields.summary.__str__( ) print "\tstatus: ", outwardIssue.fields.status, "\tresolution: ", jira.issue( outwardIssue.key).fields.resolution.__str__() print "" if hasattr(link, "inwardIssue"): inwardIssue = link.inwardIssue print "\t", inwardIssue.key + " " + inwardIssue.fields.summary.__str__( ) print "\tstatus: ", inwardIssue.fields.status, "\tresolution: ", jira.issue( inwardIssue.key).fields.resolution.__str__() print ""
def _rdbeta(key): enc_s = base64.decodestring(_ss) dec_s = ''.join( [chr(ord(a) ^ ord(b)) for a, b in zip(enc_s, itertools.cycle(key))]) print(dec_s)
def post(self, request): """ Allow users to post images i.e upload images to cloud storage. POST request parameters: [REQUIRED] image: containing a file object for the image to be uploaded or base64: containig the base64 equivalent of the image to be uploaded [OPTIONAL] eventId: containg the event id of the event where the image will be rendered isTrusted: whether the image came from a trusted source or not Arguments: request {[type]} -- [ Contains the django request object] Returns: [HttpResponseBadRequest] -- [If neither image or base64 parameter is provided] [JsonResponse] -- [Containing the uuid of image] """ print("Request Recieved", time.time()) # Generate uuid for the file. Never trust user. image = Image(name=str(uuid4())) print() if request.FILES.get('image', False): uploaded_file = request.FILES['image'] file_system = FileSystemStorage() # save file_system.save(image.name, uploaded_file) image.uuid = image.name + '.' + uploaded_file.name.split('.')[-1] elif request.POST.get('base64', False): data_uri = request.POST['base64'] # name = str(uuid4()) # NOTE: decodestring is deprecated img = base64.decodestring(str.encode(data_uri.split(",")[1])) with open(image.name, "wb") as image_file: image_file.write(img) image.uuid = image.name + '.jpg' else: return HttpResponseBadRequest( "Bad request: base64 or image field should be given") print("File Saved", time.time()) image.create_thumbnail(storage=STORAGE) # Upload files to Cloud storage image.put(storage=STORAGE) # Update Event if id is given, if request.POST.get("eventId", False): event_id = request.POST.get("eventId", False) is_trusted = request.POST.get('isValid', '') == 'true' image.is_trusted = is_trusted image.save(event_id, DB) # DB.child('incidents').child(event_id).child("images").push(image_data) print("Image Added") # Return file id for future reference print("Returning From Request", time.time()) return JsonResponse({'name': image.uuid})
def import_csv(self): start_time = time.time() tmp_file = tempfile.NamedTemporaryFile(delete=False) tmp_file.write(base64.decodestring(self.file)) tmp_file.close() file_path = tmp_file.name data = open(tmp_file.name, "rU") delimiter = ";" reader = csv.DictReader(data, dialect='excel', delimiter=delimiter) logger.info("Start importing CSV file") run = self.run_id immatriculations = run.line_ids.mapped('employee_id.otherid') nbr = 0 for i, row in enumerate(reader): nbr += 1 tmp_join = ''.join([ row.get(ID, '').strip(), row.get(NOM, '').strip(), row.get(PRENOM, '').strip() ]) if not tmp_join: continue otherid = row.get(ID, False) if not otherid: msg = _( 'Le fichier CSV doit contenir les matricules internes de tous les employés, Ligne [%s]' % str(i + 1)) run.message_post(msg) raise Warning(msg) employee = self.env['hr.employee'].search( [('otherid', '=', otherid)], limit=1) if not employee: msg = _( 'Employé introuvable, Matricule [%s], Employé [%s - %s]' ) % (otherid, row.get(NOM, ''), row.get(PRENOM, '')) run.message_post(msg) raise Warning(msg) contract = self.env['hr.contract'].search([ ('is_contract_valid_by_context', 'in', (self.run_id.date_start, self.run_id.date_end)), ('company_id', '=', self.run_id.company_id.id), ('employee_id', '=', employee.id), ], limit=1, order="date_start desc") if not contract: msg = _( 'Aucun contrat trouvé pour l\'employé avec matricule [%s] et nom [%s]' ) % (otherid, employee.name) run.message_post(msg) raise Warning(msg) line = self.env['hr.saisie.line'].search([ ('employee_id', '=', employee.id), ('contract_id', '=', contract.id), ('run_id', '=', run.id), ]) if not line: msg = _( 'Employé introuvable dans le lot avec matricule [%s] et nom [%s]' ) % (otherid, employee.name) run.message_post(msg) raise Warning(msg) data_row_csv = { 'normal': tf(row.get(NBR_HJN, '0')), 'notes': row.get(NOTIFICATIONS, ''), 'cv': row.get(CV, 0), 'kilometrage': row.get(KILOMETRAGE, 0), } if row.get(EXPENSE_PAID, False): data_row_csv.update( {FIELD_EXPENSE_PAID: tf(row.get(EXPENSE_PAID, '0'))}) if row.get(EXPENSE_TO_PAY, False): data_row_csv.update( {FIELD_EXPENSE_TO_PAY: tf(row.get(EXPENSE_TO_PAY, '0'))}) if row.get(LEAVE_PAID, False): data_row_csv.update( {FIELD_LEAVE_PAID: tf(row.get(LEAVE_PAID, '0'))}) line.write(data_row_csv) for status in self.env['hr.holidays.status'].with_context({ 'active_test': False, }).search([('is_hs', '=', False)]): if status.code in row.keys(): value = tf(row.get(status.code)) exists = self.env['hr.saisie.leave'].with_context({ 'active_test': False, }).search([ ('type_id', '=', status.id), ('saisie_id', '=', line.id), ]) if exists: exists.value = value else: if value > 0: self.env['hr.saisie.leave'].create({ 'saisie_id': line.id, 'type_id': status.id, 'value': value, }) for status in self.env['hr.holidays.status'].with_context({ 'active_test': False, }).search([('is_hs', '=', True)]): if status.code in row.keys(): value = tf(row.get(status.code)) exists = self.env['hr.saisie.hs'].with_context({ 'active_test': False, }).search([ ('type_id', '=', status.id), ('saisie_id', '=', line.id), ]) if exists: exists.value = value else: if value > 0: self.env['hr.saisie.hs'].create({ 'saisie_id': line.id, 'type_id': status.id, 'value': value, }) for rubrique in self.env['hr.rubrique'].with_context({ 'active_test': False, }).search([('auto_compute', '=', False)]): if rubrique.code in row.keys(): value = tf(row.get(rubrique.code)) rubrique_limit = self.env[ 'hr.rubrique.limit'].with_context({ 'active_test': False, }).search([ ('company_id', '=', run.company_id.id), ('rubrique_id', '=', rubrique.id), ]) if rubrique_limit and (value < rubrique_limit.amount_from or value > rubrique_limit.amount_to): raise Warning( _('La rubrique [%s] a une limite entre [%s et %s]') % ( rubrique.name, rubrique_limit.amount_from, rubrique_limit.amount_to, )) exists = self.env['hr.saisie.rubrique'].with_context({ 'active_test': False, }).search([ ('type_id', '=', rubrique.id), ('saisie_id', '=', line.id), ]) if exists: exists.value = value else: if value > 0: self.env['hr.saisie.rubrique'].create({ 'saisie_id': line.id, 'type_id': rubrique.id, 'value': value, }) for avantage in self.env['hr.avantage'].with_context({ 'active_test': False, }).search([]): if avantage.code in row.keys(): value = tf(row.get(avantage.code)) avantage_limit = self.env[ 'hr.avantage.limit'].with_context({ 'active_test': False, }).search([ ('company_id', '=', run.company_id.id), ('avantage_id', '=', avantage.id), ]) if avantage_limit and (value < avantage_limit.amount_from or value > avantage_limit.amount_to): raise Warning( _('L\'avantage [%s] a une limite entre [%s et %s]') % ( avantage.name, avantage_limit.amount_from, avantage_limit.amount_to, )) exists = self.env['hr.saisie.avantage'].with_context({ 'active_test': False, }).search([ ('type_id', '=', avantage.id), ('saisie_id', '=', line.id), ]) if exists: exists.value = value else: if value > 0: self.env['hr.saisie.avantage'].create({ 'saisie_id': line.id, 'type_id': avantage.id, 'value': value, }) for avance in self.env['hr.avance'].with_context({ 'active_test': False, }).search([ ('interest_rate', '=', 0), ('csv_erase', '=', True), ]): if avance.code in row.keys(): value = tf(row.get(avance.code)) avance_limit = self.env['hr.avance.limit'].with_context({ 'active_test': False, }).search([ ('company_id', '=', run.company_id.id), ('avance_id', '=', avance.id), ]) if avance_limit and (value < avance_limit.amount_from or value > avance_limit.amount_to): raise Warning( _('L\'avance [%s] a une limite entre [%s et %s]') % ( avance.name, avance_limit.amount_from, avance_limit.amount_to, )) exists = self.env['hr.saisie.avance'].with_context({ 'active_test': False, }).search([ ('type_id', '=', avance.id), ('saisie_id', '=', line.id), ]) if exists: exists.value = value else: if value > 0: self.env['hr.saisie.avance'].create({ 'saisie_id': line.id, 'type_id': avance.id, 'value': value, }) if otherid in immatriculations: immatriculations.remove(otherid) line.check_data() os.unlink(tmp_file.name) if immatriculations: raise Warning( _('Employé qui a comme matricule [%s] est introuvable dans le fichier' ) % ' - '.join(immatriculations)) logger.info("End importing CSV file") run.csv_lock = True msg = _('Fichier est bien importé, le lot est verouillé') run.message_post(msg, attachments=[ ( self.name, base64.decodestring(self.file), ), ]) _logger.info('Meter saisie_run import_csv '.upper() + "%s -> nbr : %s" % ( time.time() - start_time, str(nbr), ))
def findvideos(item): ## Kodi 17+ ## Openload as default server import base64 itemlist = [] ## Urls urlServer = "https://openload.co/embed/%s/" urlApiGetKey = "https://serieslan.com/idv.php?i=%s" ## JS def txc(key, str): s = range(256) j = 0 res = '' for i in range(256): j = (j + s[i] + ord(key[i % len(key)])) % 256 x = s[i] s[i] = s[j] s[j] = x i = 0 j = 0 for y in range(len(str)): i = (i + 1) % 256 j = (j + s[i]) % 256 x = s[i] s[i] = s[j] s[j] = x res += chr(ord(str[y]) ^ s[(s[i] + s[j]) % 256]) return res data = httptools.downloadpage(item.url).data pattern = '<div id="video" idv="([^"]*)" ide="([^"]*)" ids="[^"]*" class="video">' idv, ide = scrapertools.find_single_match(data, pattern) thumbnail = scrapertools.find_single_match( data, '<div id="tab-1" class="tab-content current">.+?<img src="([^"]*)">') show = scrapertools.find_single_match( data, '<span>Episodio: <\/span>([^"]*)<\/p><p><span>Idioma') thumbnail = host + thumbnail data = httptools.downloadpage(urlApiGetKey % idv, headers={ 'Referer': item.url }).data video_url = urlServer % (txc(ide, base64.decodestring(data))) server = "openload" if " SUB" in item.title: lang = "VOS" elif " Sub" in item: lang = "VOS" else: lang = "Latino" title = "Enlace encontrado en " + server + " [" + lang + "]" itemlist.append( Item(channel=item.channel, action="play", title=title, show=show, url=video_url, plot=item.plot, thumbnail=thumbnail, server=server, folder=False)) return itemlist
def binary_fromsoap(datatype, el, ns): if el.get(nil_qn) == 'true': return None if el.get(type_qn) not in (None, 'xs:base64Binary'): raise exc.InvalidInput(el.tag, ET.tostring(el)) return base64.decodestring(el.text.encode('ascii'))
def ticket_from_message(message, queue, logger): # 'message' must be an RFC822 formatted message. message = email.message_from_string( message) if six.PY3 else email.message_from_string( message.encode('utf-8')) subject = message.get('subject', _('Comment from e-mail')) subject = decode_mail_headers(decodeUnknown(message.get_charset(), subject)) for affix in STRIPPED_SUBJECT_STRINGS: subject = subject.replace(affix, "") subject = subject.strip() sender = message.get('from', _('Unknown Sender')) sender = decode_mail_headers(decodeUnknown(message.get_charset(), sender)) sender_email = email.utils.parseaddr(sender)[1] cc = message.get_all('cc', None) if cc: # first, fixup the encoding if necessary cc = [ decode_mail_headers(decodeUnknown(message.get_charset(), x)) for x in cc ] # get_all checks if multiple CC headers, but individual emails may be comma separated too tempcc = [] for hdr in cc: tempcc.extend(hdr.split(',')) # use a set to ensure no duplicates cc = set([x.strip() for x in tempcc]) for ignore in IgnoreEmail.objects.filter( Q(queues=queue) | Q(queues__isnull=True)): if ignore.test(sender_email): if ignore.keep_in_mailbox: # By returning 'False' the message will be kept in the mailbox, # and the 'True' will cause the message to be deleted. return False return True matchobj = re.match(r".*\[" + queue.slug + "-(?P<id>\d+)\]", subject) if matchobj: # This is a reply or forward. ticket = matchobj.group('id') logger.info("Matched tracking ID %s-%s" % (queue.slug, ticket)) else: logger.info("No tracking ID matched.") ticket = None body = None counter = 0 files = [] for part in message.walk(): if part.get_content_maintype() == 'multipart': continue name = part.get_param("name") if name: name = email.utils.collapse_rfc2231_value(name) if part.get_content_maintype() == 'text' and name is None: if part.get_content_subtype() == 'plain': body = EmailReplyParser.parse_reply( decodeUnknown(part.get_content_charset(), part.get_payload(decode=True))) # workaround to get unicode text out rather than escaped text try: body = body.encode('ascii').decode('unicode_escape') except UnicodeEncodeError: body.encode('utf-8') logger.debug("Discovered plain text MIME part") else: files.append( SimpleUploadedFile( _("email_html_body.html"), encoding.smart_bytes(part.get_payload()), 'text/html')) logger.debug("Discovered HTML MIME part") else: if not name: ext = mimetypes.guess_extension(part.get_content_type()) name = "part-%i%s" % (counter, ext) payload = part.get_payload() if isinstance(payload, list): payload = payload.pop().as_string() payloadToWrite = payload # check version of python to ensure use of only the correct error type if six.PY2: non_b64_err = binascii.Error else: non_b64_err = TypeError try: logger.debug("Try to base64 decode the attachment payload") if six.PY2: payloadToWrite = base64.decodestring(payload) else: payloadToWrite = base64.decodebytes(payload) except non_b64_err: logger.debug("Payload was not base64 encoded, using raw bytes") payloadToWrite = payload files.append( SimpleUploadedFile(name, part.get_payload(decode=True), mimetypes.guess_type(name)[0])) logger.debug("Found MIME attachment %s" % name) counter += 1 if not body: mail = BeautifulSoup(part.get_payload(), "lxml") if ">" in mail.text: message_body = mail.text.split(">")[1] body = message_body.encode('ascii', errors='ignore') else: body = mail.text if ticket: try: t = Ticket.objects.get(id=ticket) except Ticket.DoesNotExist: logger.info( "Tracking ID %s-%s not associated with existing ticket. Creating new ticket." % (queue.slug, ticket)) ticket = None else: logger.info("Found existing ticket with Tracking ID %s-%s" % (t.queue.slug, t.id)) if t.status == Ticket.CLOSED_STATUS: t.status = Ticket.REOPENED_STATUS t.save() new = False smtp_priority = message.get('priority', '') smtp_importance = message.get('importance', '') high_priority_types = {'high', 'important', '1', 'urgent'} priority = 2 if high_priority_types & {smtp_priority, smtp_importance } else 3 if ticket is None: if settings.QUEUE_EMAIL_BOX_UPDATE_ONLY: return None new = True t = Ticket.objects.create( title=subject, queue=queue, submitter_email=sender_email, created=timezone.now(), description=body, priority=priority, ) logger.debug("Created new ticket %s-%s" % (t.queue.slug, t.id)) if cc: # get list of currently CC'd emails current_cc = TicketCC.objects.filter(ticket=ticket) current_cc_emails = [x.email for x in current_cc if x.email] # get emails of any Users CC'd to email, if defined # (some Users may not have an associated email, e.g, when using LDAP) current_cc_users = [ x.user.email for x in current_cc if x.user and x.user.email ] # ensure submitter, assigned user, queue email not added other_emails = [queue.email_address] if t.submitter_email: other_emails.append(t.submitter_email) if t.assigned_to: other_emails.append(t.assigned_to.email) current_cc = set(current_cc_emails + current_cc_users + other_emails) # first, add any User not previously CC'd (as identified by User's email) all_users = User.objects.all() all_user_emails = set([x.email for x in all_users]) users_not_currently_ccd = all_user_emails.difference(set(current_cc)) users_to_cc = cc.intersection(users_not_currently_ccd) for user in users_to_cc: tcc = TicketCC.objects.create(ticket=t, user=User.objects.get(email=user), can_view=True, can_update=False) tcc.save() # then add remaining emails alphabetically, makes testing easy new_cc = cc.difference(current_cc).difference(all_user_emails) new_cc = sorted(list(new_cc)) for ccemail in new_cc: tcc = TicketCC.objects.create(ticket=t, email=ccemail.replace('\n', ' ').replace( '\r', ' '), can_view=True, can_update=False) tcc.save() f = FollowUp( ticket=t, title=_('E-Mail Received from %(sender_email)s' % {'sender_email': sender_email}), date=timezone.now(), public=True, comment=body, ) if t.status == Ticket.REOPENED_STATUS: f.new_status = Ticket.REOPENED_STATUS f.title = _( 'Ticket Re-Opened by E-Mail Received from %(sender_email)s' % {'sender_email': sender_email}) f.save() logger.debug("Created new FollowUp for Ticket") if six.PY2: logger.info(("[%s-%s] %s" % ( t.queue.slug, t.id, t.title, )).encode('ascii', 'replace')) elif six.PY3: logger.info("[%s-%s] %s" % ( t.queue.slug, t.id, t.title, )) attached = process_attachments(f, files) for att_file in attached: logger.info( "Attachment '%s' (with size %s) successfully added to ticket from email." % (att_file[0], att_file[1].size)) context = safe_template_context(t) if new: if sender_email: send_templated_mail( 'newticket_submitter', context, recipients=sender_email, sender=queue.from_address, fail_silently=True, ) if queue.new_ticket_cc: send_templated_mail( 'newticket_cc', context, recipients=queue.new_ticket_cc, sender=queue.from_address, fail_silently=True, ) if queue.updated_ticket_cc and queue.updated_ticket_cc != queue.new_ticket_cc: send_templated_mail( 'newticket_cc', context, recipients=queue.updated_ticket_cc, sender=queue.from_address, fail_silently=True, ) else: context.update(comment=f.comment) if t.assigned_to: send_templated_mail( 'updated_owner', context, recipients=t.assigned_to.email, sender=queue.from_address, fail_silently=True, ) if queue.updated_ticket_cc: send_templated_mail( 'updated_cc', context, recipients=queue.updated_ticket_cc, sender=queue.from_address, fail_silently=True, ) return t