def upload_attachment(self, file_path): __, file_name = os.path.split(file_path) mime = MimeTypes() url = urllib.pathname2url(file_path) mime_type, __ = mime.guess_type(url) data = { 'file_name': file_name, 'file_type': mime_type } url = urljoin(self.api_url, 'attachment/upload') response = self.post(url, data=data) with open(file_path) as fh: file_data = fh.read() upload_response = requests.put( response['upload_url'], data=file_data, headers={'content-type': mime_type}, params={'file': file_path} ) upload_response.raise_for_status() return { 'file_url': response['file_url'], 'file_type': mime_type, }
def get_mime_type(path): mime = MimeTypes() mime_type = mime.guess_type(path)[0] if not mime_type: mime_type = "text/{0}".format(os.path.splitext(path)[1]) return mime_type
def getMimeType(self,buffre,url,mtype): if '?' in url: url = url.split('?')[0] mime = MimeTypes() ext = os.path.splitext(url)[1] if mtype == 'text/html' and ext == '': if url[-1] == '/': l = len(url)-1 url = url[0:-1] url = url+'/index.html' ext = '.html' #ext1 = mime.guess_extension(mtype,True) #print ext1 mime_type = mime.guess_type(url) #print url if ext: #print url u = urlparse.urlparse(url) #print u.netloc,u.path print self.host if self.host: root_dir = self.root_dir+"/"+self.host file_path = os.path.join(root_dir,u.netloc+u.path) print file_path #if not os.path.isfile(file_path): makeDir(os.path.dirname(file_path)) f = open(file_path,"wb") f.write(buffre)
def update_community(self, properties): pc = api.portal.get_tool('portal_catalog') brain = pc.unrestrictedSearchResults(portal_type='ulearn.community', community_hash=self.params['community']) if not brain: brain = pc.unrestrictedSearchResults(portal_type='ulearn.community', gwuuid=self.params['community']) if brain: community = brain[0].getObject() if properties['title'] is not None: community.title = properties['title'] if properties['description'] is not None: community.description = properties['description'] if properties['image'] is not None: imageObj = '' mime = MimeTypes() mime_type = mime.guess_type(properties['image']) imgName = (properties['image'].split('/')[-1]).decode('utf-8') imgData = requests.get(properties['image']).content imageObj = NamedBlobImage(data=imgData, filename=imgName, contentType=mime_type[0]) community.image = imageObj if properties['activity_view'] is not None: community.activity_view = properties['activity_view'] if properties['twitter_hashtag'] is not None: community.twitter_hashtag = properties['twitter_hashtag'] if properties['notify_activity_via_push'] is not None: community.notify_activity_via_push = True if properties['notify_activity_via_push'] == 'True' else None if properties['notify_activity_via_push_comments_too'] is not None: community.notify_activity_via_push_comments_too = True if properties['notify_activity_via_push_comments_too'] == 'True' else None community.reindexObject() return True else: return False
def download(request, filename): #down_file = File.objects.get(name = filename) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) DOWNLOAD_URL = BASE_DIR+"/download/" file_path = DOWNLOAD_URL + filename file_name = filename fp = open(file_path, 'rb') response = HttpResponse(fp.read()) fp.close() mime = MimeTypes() type, encoding = mime.guess_type(file_name) if type is None: type = 'application/octet-stream' response['Content-Type'] = type response['Content-Length'] = str(os.stat(file_path).st_size) if encoding is not None: response['Content-Encoding'] = encoding if u'WebKit' in request.META['HTTP_USER_AGENT']: filename_header = 'filename=%s' % file_name.encode('utf-8') elif u'MSIE' in request.META['HTTP_USER_AGENT']: filename_header = '' else: filename_header = 'filename*=UTF-8\'\'%s' % urllib.quote(file_name.encode('utf-8')) response['Content-Disposition'] = 'attachment; ' + filename_header # 記錄系統事件 if is_event_open(request) : log = Log(user_id=request.user.id, event=u'下載檔案<'+filename+'>') log.save() return response
def mime_type(self): m = MimeTypes() m.read(LIASIS_DIR+MIME_TYPES) if m.guess_type(self.tfile): return m.guess_type(self.tfile)[0] else: return "text/plain"
def GetRFC(rfc_id,file_name,peer_ip,peer_port): global LRFCdata global Server s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(None) peer_ipaddr=peer_ip s.connect((peer_ipaddr,int(peer_port))) message = ["GETRFC",str(rfc_id),"P2P-DI/1.0","Host: ",IP,"Port: ",PORT,"Title: ",file_name,"Client ID: ",str(self_id)] s.send(pickle.dumps(message)) os.chdir(os.getcwd()) filename=file_name+".pdf" file1=open(filename,'wb') q=s.recv(4096) q=pickle.loads(q) if 'FILE NOT FOUND' in q: code = '404' phrase = 'FILE NOT FOUND' reply = ["P2P-DI/1.0 ",str(code),str(phrase)] PrintResponse(reply,'FILERESPN') else: if 'FILE FOUND' in q: last_modified = q[2] message = ["OK"] s.send(pickle.dumps(message)) while True: q=s.recv(4096) if q: file1.write(q) else: code = '200' phrase = 'OK' mime = MimeTypes() filesize = os.stat(filename).st_size mime_type = mime.guess_type(filename) reply = ["P2P-DI/1.0 ",str(code),str(phrase),"Last-Modified: ",str(last_modified),"Content-Length: ",str(filesize),"Content-Type: ",str(mime_type[0])] PrintResponse(reply,'FILESENT') file1.close() break serverIP = Server[0] serverPort = Server[1] message=["PQUERY","P2P-DI/1.0 ",str(self_id),"Host: ",IP,"Port: ",str(PORT)] reply = client(message,serverIP,serverPort) PrintResponse(reply,'PQUERY') LocalRFC = LocalRFCRecord(rfc_id,file_name) LRFCdata.append(LocalRFC.getLocalRFC()) Local_linked_list.append(LocalRFC.getLocalRFC()) active_list = reply[4] active_list=RFCStore(active_list,[[rfc_id,file_name]]) s.close()
def export_warc(self): # by using select_for_update and checking for existence of this file, # we make sure that we won't accidentally try to create the file multiple # times in parallel. asset = self.assets.select_for_update().first() if not asset: return # this is not an old-style Link if default_storage.exists(self.warc_storage_file()): return guid = self.guid out = self.open_warc_for_writing() def write_resource_record(file_path, url, content_type): self.write_warc_resource_record( default_storage.open(file_path), url.encode('utf8'), content_type, default_storage.created_time(file_path), out) def write_metadata_record(metadata, target_headers): concurrent_to = (v for k, v in target_headers if k == warctools.WarcRecord.ID).next() warc_date = (v for k, v in target_headers if k == warctools.WarcRecord.DATE).next() url = (v for k, v in target_headers if k == warctools.WarcRecord.URL).next() self.write_warc_metadata_record(metadata, url, concurrent_to, warc_date, out) # write PDF capture if asset.pdf_capture and ('cap' in asset.pdf_capture or 'upload' in asset.pdf_capture): file_path = os.path.join(asset.base_storage_path, asset.pdf_capture) headers = write_resource_record(file_path, "file:///%s/%s" % (guid, asset.pdf_capture), 'application/pdf') #write_metadata_record({'role':'primary', 'user_upload':asset.user_upload}, headers) # write image capture (if it's not a PDF thumbnail) elif (asset.image_capture and ('cap' in asset.image_capture or 'upload' in asset.image_capture)): file_path = os.path.join(asset.base_storage_path, asset.image_capture) mime_type = get_mime_type(asset.image_capture) write_resource_record(file_path, "file:///%s/%s" % (guid, asset.image_capture), mime_type) if asset.warc_capture: # write WARC capture if asset.warc_capture == 'archive.warc.gz': file_path = os.path.join(asset.base_storage_path, asset.warc_capture) self.write_warc_raw_data(default_storage.open(file_path), out) # write wget capture elif asset.warc_capture == 'source/index.html': mime = MimeTypes() for root, dirs, files in default_storage.walk(os.path.join(asset.base_storage_path, 'source')): rel_path = root.split(asset.base_storage_path, 1)[-1] for file_name in files: mime_type = mime.guess_type(file_name)[0] write_resource_record(os.path.join(root, file_name), "file:///%s%s/%s" % (guid, rel_path, file_name), mime_type) self.close_warc_after_writing(out) # regenerate CDX index self.cdx_lines.all().delete()
def searchImages(rootDir): imageList = [] mime = MimeTypes() for root, subFolders, files in os.walk(rootDir): for file in files: mt = mime.guess_type(file)[0] if mt and mt.startswith('image/'): imageList = imageList + [os.path.join(root,file)] return imageList
def configure_mimetypes(extra_types): """ Add additional mimetypes to a local MimeTypes instance to avoid polluting global registery """ mimetypes = MimeTypes() for content_type, extension in extra_types: mimetypes.add_type(content_type, extension) return mimetypes
def get_extension(url): from mimetypes import MimeTypes mime_types = MimeTypes() (type, encoding) = mime_types.guess_type(url) extensions = mime_types.guess_all_extensions(type) extension = extensions[-1] return extension
def add_documents(request, category_id): if request.is_ajax(): files = request.GET.getlist('files', False) cat = Category.objects.get(id=category_id) l_doc = [] l_pdf = [] cmds = [] paths = [] for f in list(files): mime = MimeTypes() path = os.path.join(settings.MEDIA_ROOT, settings.UPLOAD_DIR, f) m = mime.guess_type(path)[0] d = Document(name=f.encode('ascii', 'ignore'), owner=request.user, refer_category=cat) d.save() cat.add_doc(d) if m == 'application/pdf': l_pdf.append(([cat], path, f, [d])) elif m in ['image/png', 'image/jpeg', 'image/bmp']: im = Image.open(path) w, h = im.size new_filename = str(d.id) + '_' + f new_path = os.path.join(cat.get_absolute_path(), new_filename) shutil.copy2(path, new_path) d.add_page(d.get_npages() + 1, new_filename, w, h) for fu in FileUpload.objects.all(): if fu.file.path == path: fu.delete() d.complete = True d.save() remove_fileupload([path]) elif m in ['application/msword', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document']: p = re.compile(r'.[Dd][Oo][Cc][xX]?$') new_f = p.sub('.pdf', f) new_path = path.replace(f, new_f) cmd = 'soffice --headless --convert-to pdf %s --outdir %s/upload' % (path, settings.MEDIA_ROOT) cmds.append(cmd) paths.append(path) l_doc.append(([cat], new_path, new_f, [d])) elif m in ['application/vnd.ms-excel', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet']: p = re.compile(r'.[Xx][Ll][Ss][xX]?$') new_f = p.sub('.pdf', f) new_path = path.replace(f, new_f) cmd = 'soffice --headless --convert-to pdf %s --outdir %s/upload' % (path, settings.MEDIA_ROOT) cmds.append(cmd) paths.append(path) l_doc.append(([cat], new_path, new_f, [d])) else: print 'ERREUR FORMAT FICHIER' if len(l_doc): thread1 = Timer(0, manage_convert_doc_to_pdf, (cmds, paths, l_doc,)) thread1.start() if len(l_pdf): thread = Timer(0, manage_convert_pdf_to_jpg, (l_pdf,)) thread.start() results = {'doc_list': [d.as_json() for d in cat.get_docs()], 'n': cat.count_docs()} return HttpResponse(json.dumps(results))
def mime(self): if self.mMimeType is not None: return self.mMimeType mime = MimeTypes() url = urllib.pathname2url(self.mFullPathName) self.mMimeType = mime.guess_type(url)[0] if self.mMimeType is None: self.mMimeType = "Unkown/None" return self.mMimeType
def showfile(file): mime = MimeTypes() mime_type = mime.guess_type(file) if mime_type[0] is not None and mime_type[0].startswith("image"): return render_template("image.html", title="pyle :: preview", filepath="/data/" + file, filename=os.path.basename(file)) else: return readfile(file)
def show_media(self, url, title = "", desc ="", loop = 0): mime = MimeTypes() mime_type = mime.guess_type(url) payload = { "target": url, "title":title, "description":desc, "mimeType": mime_type[0], "iconSrc":"", "loop":loop} command = '{"id":"images","type":"request","uri":"ssap://media.viewer/open","payload":'+ json.dumps(payload)+'}' self.send_command(command)
def transform_import_values(self, value): ''' # TODO: Following commented code can be used if user does not already have file in final location using django ORM: request = HttpRequest() # request.FILES['file-list_' + str(nodeid)] = None files = [] # request_list = [] for val in value.split(','): val_dict = {} val_dict['content'] = val val_dict['name'] = val.split('/')[-1].split('.')[0] val_dict['url'] = None # val_dict['size'] = None # val_dict['width'] = None # val_dict['height'] = None files.append(val_dict) f = open(val, 'rb') django_file = InMemoryUploadedFile(f,'file',val.split('/')[-1].split('.')[0],None,None,None) request.FILES.appendlist('file-list_' + str(nodeid), django_file) print request.FILES value = files ''' mime = MimeTypes() tile_data = [] for file_path in value.split(','): try: file_stats = os.stat(file_path) tile_file['lastModified'] = file_stats.st_mtime tile_file['size'] = file_stats.st_size except: pass tile_file = {} tile_file['file_id'] = str(uuid.uuid4()) tile_file['status'] = "" tile_file['name'] = file_path.split('/')[-1] tile_file['url'] = settings.MEDIA_URL + 'uploadedfiles/' + str(tile_file['name']) # tile_file['index'] = 0 # tile_file['height'] = 960 # tile_file['content'] = None # tile_file['width'] = 1280 # tile_file['accepted'] = True tile_file['type'] = mime.guess_type(file_path)[0] tile_file['type'] = '' if tile_file['type'] == None else tile_file['type'] tile_data.append(tile_file) file_path = 'uploadedfiles/' + str(tile_file['name']) fileid = tile_file['file_id'] models.File.objects.get_or_create(fileid=fileid, path=file_path) result = json.loads(json.dumps(tile_data)) return result
def get_mime_type(self, file_path): #Get mime type try: mime = MimeTypes() murl = urllib.pathname2url(file_path) mime_type = mime.guess_type(murl)[0] if mime_type == None: mime_type = 'text/plain' except: mime_type = 'text/plain' return mime_type
def addFileOutput(self, name, filepath): data = open(filepath).read() filename = os.path.basename(filepath) mime = MimeTypes() mime_guess = mime.guess_type(filename)[0] self.result[name] = { "filename": filename, "content-type": mime_guess, "data": base64.b64encode(data) } return self
def update_data(self, data, content_type, size): """ """ if not data: # still index self.index_object() return passed, virus_name = DataVirusCheckAdapter(data).process() if not passed: log.warn('found virus %s, rejecting file' % virus_name) raise XWFFileError('found virus %s, rejecting file' % virus_name) # this isn't necessarily an error, on init we get called without data base_files_dir = self._base_files_dir self.size = size self.set_modificationTime() if base_files_dir: fileId = os.path.join(base_files_dir, self.getId()) f = file(fileId, 'wb+') if hasattr(data, '__class__') and data.__class__ is Pdata: while data is not None: f.write(data.data) data = data.next else: f.write(data) f.close() # fix the title title = to_unicode_or_bust(self.title) title = removePathsFromFilenames(title) self.title = title if content_type is not None: self.content_type = content_type else: mtypes = MimeTypes() mime_type = mtypes.guess_type(title) if mime_type: self.content_type = mime_type self.ZCacheable_invalidate() self.ZCacheable_set(None) self.http__refreshEtag() # index ourselves into the catalog self.index_object()
def get_base64_image(url): template_image = '' mime = MimeTypes() mime_type = mime.guess_type(url)[0] # Steam the image from the url request = requests.get(url) image_buffer = StringIO(request.content) if image_buffer: template_image = image_buffer.getvalue().encode('base64') template_image = u'data:%s;base64,%s' % (mime_type, template_image) return template_image
def batch_upload_response(self, request): output_fields = flatten_fieldsets(self.fieldsets) media_file_name = get_media_file_name(self, self.model) #Disabling exception handling here @olivierdalang's feedback: # try: latest_log_entry = LogEntry.objects.filter(action_flag=ADDITION).order_by('-action_time')[0] ct = ContentType.objects.get_for_id(latest_log_entry.content_type_id) obj = ct.get_object_for_this_type(pk=latest_log_entry.object_id) if obj: object_data = {} mime = MimeTypes() media_file = get_media_file(self, self.model, obj) media_file_url = media_file.url #urllib.pathname2url(media_file.url) #Not sure why i had this, but it's escaping the URL mime_type = mime.guess_type(media_file_url) edit_url = reverse('admin:%s_%s_change' %(obj._meta.app_label, obj._meta.model_name), args=[obj.id] ) object_data['media_file_url'] = media_file_url object_data['media_file_size'] = media_file.size object_data['media_file_type'] = mime_type[0] object_data['edit_url'] = mark_safe(edit_url) field_values = {} for output_field in output_fields: value = str(self.get_field_contents(output_field, obj)) label = str(label_for_field(output_field, self.model, self)) field_values[output_field] = { 'label':label, 'value':value } object_data['field_values'] = field_values data = { "success":True, "files":[ object_data ] } json_dumped = json.dumps(data) return HttpResponse(json_dumped, content_type='application/json')
def filetype(file): name= '' mime = MimeTypes() mime_type = mime.guess_type(file) #print(mime_type) if "application/x-zip-compressed" in mime_type: name= "zip" elif "gzip" in mime_type: name= "gzip" elif "application/x-tar" in mime_type: name= "tar" return name
def upload(self, filepath): filename = filepath.split("/")[-1] mime = MimeTypes() mime_type = mime.guess_type(filename) data = {"filename": filename, "mime_type": mime_type} response = self.session.post("%s/files/" % self.url, data=json.dumps(data), headers=HEADERS) if response.status_code == requests.codes.created: f = File(self, response.json()) with open(filepath, "rb") as localfile: response = requests.put(f.upload_url, data=localfile) return f else: print(response.text)
def mimes(self): """ Returns extended MimeTypes. """ _mimes = MimeTypes(strict=False) _mimes.suffix_map.update({".tbz2": ".tar.bz2"}) _mimes.encodings_map.update({".bz2": "bzip2"}) if cfg["CFG_BIBDOCFILE_ADDITIONAL_KNOWN_MIMETYPES"]: for key, value in iteritems(cfg["CFG_BIBDOCFILE_ADDITIONAL_KNOWN_MIMETYPES"]): _mimes.add_type(key, value) del key, value return _mimes
def write(self, filename, contents, encoding='utf8'): """ Write a file to the data store. """ mime = MimeTypes() mime.add_type('text/x-yaml', '.yaml') content_type, _ = mime.guess_type(filename) key = self.bucket.new_key(self._path(filename)) key.set_contents_from_string(contents.encode(encoding), { 'Content-Type': content_type or 'text/plain', 'Content-Encoding': encoding, }) if self.public: key.set_canned_acl('public-read')
def _getExtension( episode ): # get extension from url urlExt = os.path.splitext( episode.url )[ 1 ] # get extension from media type mime = MimeTypes() mimeExtList = mime.guess_all_extensions( episode.type ) # check if url extension matches any item in list if urlExt in mimeExtList: # yep, then url extension is good return urlExt # otherwise, use recommendation from MimeTypes, as default we use .mp3 mimeExt = mime.guess_extension( episode.type ) if mimeExt == None: mimeExt = ".mp3" return mimeExt
def Email(subject, body, path=0): msg = Message(subject, sender="*****@*****.**", recipients=["*****@*****.**"]) msg.body = body if path!=0: mim=MimeTypes() for fn in os.listdir(path): mimty=mim.guess_type(fn) with app.open_resource(path+"\\"+fn) as fp: msg.attach(fn,mimty[0], fp.read()) shutil.rmtree(path) mail.send(msg)
def POST(self): params = {} params['nom'] = self.params.pop('title') params['community_type'] = self.params.pop('community_type') params['description'] = self.params.pop('description', None) params['image'] = self.params.pop('image', None) params['activity_view'] = self.params.pop('activity_view', None) params['twitter_hashtag'] = self.params.pop('twitter_hashtag', None) params['notify_activity_via_push'] = self.params.pop('notify_activity_via_push', None) params['notify_activity_via_push_comments_too'] = self.params.pop('notify_activity_via_push_comments_too', None) pc = api.portal.get_tool('portal_catalog') nom = safe_unicode(params['nom']) util = queryUtility(IIDNormalizer) id_normalized = util.normalize(nom, max_length=500) result = pc.unrestrictedSearchResults(portal_type='ulearn.community', id=id_normalized) imageObj = '' if params['image']: mime = MimeTypes() mime_type = mime.guess_type(params['image']) imgName = (params['image'].split('/')[-1]).decode('utf-8') imgData = requests.get(params['image']).content imageObj = NamedBlobImage(data=imgData, filename=imgName, contentType=mime_type[0]) if result: # community = result[0].getObject() success_response = 'Community already exists.' status = 200 else: new_community_id = self.context.invokeFactory('ulearn.community', id_normalized, title=params['nom'], description=params['description'], image=imageObj, community_type=params['community_type'], activity_view=params['activity_view'], twitter_hashtag=params['twitter_hashtag'], notify_activity_via_push=True if params['notify_activity_via_push'] == 'True' else None, notify_activity_via_push_comments_too=True if params['notify_activity_via_push_comments_too'] == 'True' else None, checkConstraints=False) new_community = self.context[new_community_id] success_response = 'Created community "{}" with hash "{}".'.format(new_community.absolute_url(), sha1(new_community.absolute_url()).hexdigest()) status = 201 logger.info(success_response) return ApiResponse.from_string(success_response, code=status)
def __init__(self): self.classes = {} self.mimetypes = MimeTypes() mimedata = get_data('scrapy', 'mime.types') self.mimetypes.readfp(StringIO(mimedata)) for mimetype, cls in self.CLASSES.iteritems(): self.classes[mimetype] = load_object(cls)
def post_media(self, user_id, file_path, sent_by_maker=False): role = "appUser" if sent_by_maker: role = "appMaker" data = {"role": role} mime = MimeTypes() mime_type, _ = mime.guess_type(file_path) file_name = os.path.basename(file_path) files = {'source': (file_name, open(file_path, 'rb'), mime_type)} url = 'appusers/{0}/conversation/images'.format(user_id) return self.ask(url, data, 'post', files)
def run_campaign(campaign, domain='demo.django-crm.io', protocol='https'): try: campaign = Campaign.objects.get(id=campaign) attachments = [] if campaign.attachment: file_path = campaign.attachment.path file_name = file_path.split("/")[-1] content = open(file_path, 'rb').read() mime = MimeTypes() mime_type = mime.guess_type(file_path) attachments.append((file_name, content, mime_type[0])) subject = campaign.subject contacts = Contact.objects.filter(contact_list__in=[ each_list for each_list in campaign.contact_lists.all() ]) default_html = campaign.html_processed for each_contact in contacts: html = default_html campaign_log = CampaignLog.objects.create(contact=each_contact, campaign=campaign) if campaign.reply_to_email: reply_to_email = campaign.reply_to_email else: message_id = get_campaign_message_id(campaign_log) campaign_log.message_id = message_id campaign_log.save() domain_name = 'django-crm.com' if campaign.from_email is not None: from_email = campaign.from_email else: from_email = campaign.created_by.email reply_to_email = str(from_email) + ' <' + \ str(message_id + '@' + domain_name + '') + '>' if not (each_contact.is_bounced or each_contact.is_unsubscribed): # domain_url = settings.URL_FOR_LINKS domain_url = protocol + '://' + domain img_src_url = domain_url + reverse( 'marketing:campaign_open', kwargs={ 'campaign_log_id': campaign_log.id, 'email_id': each_contact.id }) # images can only be accessed over https link = '<img src={img_src_url} alt="company_logo" title="company_logo" height="1" width="1" />'.format( img_src_url=img_src_url) # link = '<img src="' + domain_url + '/m/cm/track-email/' + \ # str(campaign_log.id) + '/contact/' + \ # str(each_contact.id) + '/" height="1" width="1" alt="company_logo" + \ # title="company_logo"/>' unsubscribe_from_campaign_url = reverse( 'marketing:unsubscribe_from_campaign', kwargs={ 'contact_id': each_contact.id, 'campaign_id': campaign.id }) unsubscribe_from_campaign_html = "<br><br/><a href={}>Unsubscribe</a>".format( domain_url + unsubscribe_from_campaign_url) names_dict = { 'company_name': each_contact.company_name if each_contact.company_name else '', 'last_name': each_contact.last_name if each_contact.last_name else '', 'city': each_contact.city if each_contact.city else '', 'state': each_contact.state if each_contact.state else '', 'first_name': each_contact.name, 'email': each_contact.email, 'email_id': each_contact.id, 'name': each_contact.name + ' ' + each_contact.last_name if each_contact.last_name else '', 'unsubscribe_from_campaign_url': unsubscribe_from_campaign_url } html = Template(html).render(Context(names_dict)) mail_html = html + link + unsubscribe_from_campaign_html from_email = str(campaign.from_name) + "<" + \ str(campaign.from_email) + '>' to_email = [each_contact.email] send_campaign_mail(subject, mail_html, from_email, to_email, [], [reply_to_email], attachments) except Exception as e: print(e) pass
def run(self, path): if path == "/": f = open(os.path.join(config.get_runtime_path(), "platformcode", "template", "page.html"), "rb") self.handler.send_response(200) self.handler.send_header('Content-type', 'text/html') self.handler.end_headers() respuesta = f.read() self.handler.wfile.write(respuesta) f.close() elif path.startswith("/local/"): import base64 import urllib Path = path.replace("/local/", "").split("/")[0] Path = base64.b64decode(urllib.unquote_plus(Path)) Size = int(os.path.getsize(Path.decode("utf8"))) f = open(Path.decode("utf8"), "rb") if not self.handler.headers.get("range") == None: if "=" in str(self.handler.headers.get("range")) and "-" in str(self.handler.headers.get("range")): Inicio = int(self.handler.headers.get("range").split("=")[1].split("-")[0]) if self.handler.headers.get("range").split("=")[1].split("-")[1] <> "": Fin = int(self.handler.headers.get("range").split("=")[1].split("-")[1]) else: Fin = Size - 1 else: Inicio = 0 Fin = Size - 1 if not Fin > Inicio: Fin = Size - 1 if self.handler.headers.get("range") == None: logger.info("-------------------------------------------------------") logger.info("Solicitando archivo local: " + Path) logger.info("-------------------------------------------------------") self.handler.send_response(200) self.handler.send_header("Content-Disposition", "attachment; filename=video.mp4") self.handler.send_header('Accept-Ranges', 'bytes') self.handler.send_header('Content-Length', str(Size)) self.handler.send_header("Connection", "close") self.handler.end_headers() while True: time.sleep(0.2) buffer = f.read(1024 * 250) if not buffer: break self.handler.wfile.write(buffer) self.handler.wfile.close() f.close() else: logger.info("-------------------------------------------------------") logger.info("Solicitando archivo local: " + Path) logger.info("Rango: " + str(Inicio) + "-" + str(Fin) + "/" + str(Size)) logger.info("-------------------------------------------------------") f.seek(Inicio) self.handler.send_response(206) self.handler.send_header("Content-Disposition", "attachment; filename=video.mp4") self.handler.send_header('Accept-Ranges', 'bytes') self.handler.send_header('Content-Length', str(Fin - Inicio)) self.handler.send_header('Content-Range', str(Inicio) + "-" + str(Fin) + "/" + str(Size)) self.handler.send_header("Connection", "close") self.handler.end_headers() while True: time.sleep(0.2) buffer = f.read(1024 * 250) if not buffer: break self.handler.wfile.write(buffer) self.handler.wfile.close() f.close() elif path.startswith("/media/"): file = os.path.join(config.get_runtime_path(), "platformcode", "template", path[7:]) from mimetypes import MimeTypes mime = MimeTypes() mime_type = mime.guess_type(file) try: mim = mime_type[0] except: mim = "" f = open(file, "rb") self.handler.send_response(200) self.handler.send_header('Content-type', mim) self.handler.end_headers() self.handler.wfile.write(f.read()) f.close()
content = content.replace("font-size", "nope").replace("size=\"", "sizeIs=\"").replace( "color=\"", "coolor=\"") # put head code right after the head tag content = re.sub("<head(.*>)", "<head \\1" + head_html, content, re.I | re.M) # put upper body code right after the body tag content = re.sub("<body(.*>)", "<body \\1" + upper_html, content, re.I | re.M) # put lower body code right before the closing of body tag content = re.sub("</body(.*>)", lower_html + "</body \\1", content, re.I | re.M) # base64 include all external files mime = MimeTypes() while True: result = re.search('(<img)(.*src=")(.*?)(".*?>)', content, re.I | re.M) if result is None or result.groups()[2].endswith('base64-ed '): break external_file = join(temp_dir, basename(unquote(result.groups()[2]))) if not isfile(external_file): pass file_url = pathname2url(external_file) mime_type = mime.guess_type(file_url)[0] if mime_type is None: mime_type = 'unknown/unknown' print('WRONG MIME', mime.guess_type(file_url), file_url, external_file) b64_data = "data:" + mime_type + ";base64,"
def send_campaign_email_to_admin_contact(campaign, domain='demo.django-crm.io', protocol='https'): try: campaign = Campaign.objects.get(id=campaign) attachments = [] if campaign.attachment: file_path = campaign.attachment.path file_name = file_path.split("/")[-1] content = open(file_path, 'rb').read() mime = MimeTypes() mime_type = mime.guess_type(file_path) attachments.append((file_name, content, mime_type[0])) subject = campaign.subject contacts = ContactEmailCampaign.objects.all() default_html = campaign.html_processed for each_contact in contacts: html = default_html if campaign.reply_to_email: reply_to_email = campaign.reply_to_email else: domain_name = 'django-crm.com' if campaign.from_email is not None: from_email = campaign.from_email else: from_email = campaign.created_by.email reply_to_email = str(from_email) + ' <' + \ str(settings.EMAIL_HOST_USER + '@' + domain_name + '') + '>' # domain_url = settings.URL_FOR_LINKS domain_url = protocol + '://' + domain # img_src_url = domain_url + reverse('marketing:campaign_open', kwargs={ # 'campaign_log_id': campaign_log.id, 'email_id': each_contact.id}) # # images can only be accessed over https # link = '<img src={img_src_url} alt="company_logo" title="company_logo" height="1" width="1" />'.format( # img_src_url=img_src_url) # link = '<img src="' + domain_url + '/m/cm/track-email/' + \ # str(campaign_log.id) + '/contact/' + \ # str(each_contact.id) + '/" height="1" width="1" alt="company_logo" + \ # title="company_logo"/>' # unsubscribe_from_campaign_url = reverse( # 'marketing:unsubscribe_from_campaign', kwargs={'contact_id': each_contact.id, # 'campaign_id': campaign.id}) # unsubscribe_from_campaign_html = "<br><br/><a href={}>Unsubscribe</a>".format( # domain_url + unsubscribe_from_campaign_url) # names_dict = {'company_name': '', 'city': '', 'state': '', # 'last_name': each_contact.last_name if each_contact.last_name else '', # 'email': each_contact.email, 'email_id': each_contact.id, # 'name': each_contact.name + ' ' + each_contact.last_name if each_contact.last_name else '', # } # mail_html = html + link + unsubscribe_from_campaign_html html = Template(html).render(Context({'email_id': each_contact.id})) mail_html = html from_email = str(campaign.from_name) + "<" + \ str(campaign.from_email) + '>' to_email = [each_contact.email] send_campaign_mail(subject, mail_html, from_email, to_email, [], [reply_to_email], attachments) except Exception as e: print(e) pass