예제 #1
17
파일: tests.py 프로젝트: alexhayes/django
class ContentFileTestCase(unittest.TestCase):
    def setUp(self):
        self.storage_dir = tempfile.mkdtemp()
        self.storage = FileSystemStorage(self.storage_dir)

    def tearDown(self):
        shutil.rmtree(self.storage_dir)

    def test_content_file_default_name(self):
        self.assertEqual(ContentFile(b"content").name, None)

    def test_content_file_custom_name(self):
        """
        Test that the constructor of ContentFile accepts 'name' (#16590).
        """
        name = "I can have a name too!"
        self.assertEqual(ContentFile(b"content", name=name).name, name)

    def test_content_file_input_type(self):
        """
        Test that ContentFile can accept both bytes and unicode and that the
        retrieved content is of the same type.
        """
        self.assertTrue(isinstance(ContentFile(b"content").read(), bytes))
        if six.PY3:
            self.assertTrue(isinstance(ContentFile("español").read(), six.text_type))
        else:
            self.assertTrue(isinstance(ContentFile("español").read(), bytes))

    def test_content_saving(self):
        """
        Test that ContentFile can be saved correctly with the filesystem storage,
        both if it was initialized with string or unicode content"""
        self.storage.save("bytes.txt", ContentFile(b"content"))
        self.storage.save("unicode.txt", ContentFile("español"))
예제 #2
0
파일: tests.py 프로젝트: GeyseR/django
class FileLikeObjectTestCase(LiveServerTestCase):
    """
    Test file-like objects (#15644).
    """

    available_apps = []

    def setUp(self):
        self.temp_dir = tempfile.mkdtemp()
        self.storage = FileSystemStorage(location=self.temp_dir)

    def tearDown(self):
        shutil.rmtree(self.temp_dir)

    def test_urllib_request_urlopen(self):
        """
        Test the File storage API with a file-like object coming from
        urllib.request.urlopen().
        """
        file_like_object = urlopen(self.live_server_url + '/')
        f = File(file_like_object)
        stored_filename = self.storage.save("remote_file.html", f)

        remote_file = urlopen(self.live_server_url + '/')
        with self.storage.open(stored_filename) as stored_file:
            self.assertEqual(stored_file.read(), remote_file.read())
예제 #3
0
파일: tasks.py 프로젝트: abziegler/perma
def get_screencap(url, file_name):
    """
    This func helps monitor our Celery/Selenium/PhantomJS image
    creation process. We'll use this to coarsely keep tabs on the availability
    of our "create new archive" service.

    Returns the image (png) capture

    NOTE: This func does not permanently store anything. It should only be used
    for monitoring purposes.

    TODO: this should replicate everything that happens in proxy_capture, flesh
    this out.
    """

    # We don't want to mix this monitoring stuff with our user generated media (archives)
    monitor_storage = FileSystemStorage(location=getattr(settings, 'MONITOR_ROOT'))

    driver = webdriver.PhantomJS(executable_path=getattr(settings, 'PHANTOMJS_BINARY', 'phantomjs'),)
    driver.get(url)

    file_object = BytesIO(driver.get_screenshot_as_png())
    file = File(file_object)

    driver.quit

    monitor_storage.save(file_name, file)
예제 #4
0
파일: tests.py 프로젝트: GeyseR/django
 def test_lazy_base_url_init(self):
     """
     FileSystemStorage.__init__() shouldn't evaluate base_url.
     """
     storage = FileSystemStorage(base_url=reverse_lazy('app:url'))
     with self.assertRaises(NoReverseMatch):
         storage.url(storage.base_url)
예제 #5
0
def getAudio(request, book_id, para_id): 
    #Should be served by nginx-gridfs
    #response = HttpResponse(mimetype = "audio/x-wav")
    '''
    image = Image.open(os.path.dirname(settings.BASE_DIR) + "/" + "wastore/hindi.jpg") 
    image.save(response, 'png')
    image = Image.open(settings.BASE_DIR) 
    '''
    #response=HttpResponse()	
    path_to_save = "documents/"+str(book_id) + "_" + str(para_id) + "_sound.wav"
    #path_to_save = str(book_id) + "/chunks/" + str(para_id) + "/AudioFiles/1.wav"
    print(path_to_save)
    a = default_storage.open(path_to_save)
    local_fs = FileSystemStorage(location='/tmp/audio')
    local_fs.save(a.name,a)
    file = open("/tmp/audio/documents/"+str(book_id) + "_" + str(para_id) + "_sound.wav", "rb").read() 
    #response['Content-Disposition'] = 'attachment; filename=filename.mp3' 
    

    #audio = wave.open("/tmp/audio/"+a.name,'r')
    #--audio.save(response, 'wav')
    #data=audio.readframes(audio.getnframes())	
    #print len(data)
    #print type(data)
    #print data[9000:9002]	
    #--response.write(data)
    #response = HttpResponse(content=data, mimetype="audio/x-wav")
    #print response.content[9000:9002]	
    #audio.close()
    
    local_fs.delete(a.name)
    
    #return HttpResponse("hello")
    return HttpResponse(file, mimetype="audio/wav") 
예제 #6
0
파일: tests.py 프로젝트: GeyseR/django
class FileStoragePathParsing(SimpleTestCase):
    def setUp(self):
        self.storage_dir = tempfile.mkdtemp()
        self.storage = FileSystemStorage(self.storage_dir)

    def tearDown(self):
        shutil.rmtree(self.storage_dir)

    def test_directory_with_dot(self):
        """Regression test for #9610.

        If the directory name contains a dot and the file name doesn't, make
        sure we still mangle the file name instead of the directory name.
        """

        self.storage.save('dotted.path/test', ContentFile("1"))
        self.storage.save('dotted.path/test', ContentFile("2"))

        files = sorted(os.listdir(os.path.join(self.storage_dir, 'dotted.path')))
        self.assertFalse(os.path.exists(os.path.join(self.storage_dir, 'dotted_.path')))
        self.assertEqual(files[0], 'test')
        self.assertRegex(files[1], 'test_%s' % FILE_SUFFIX_REGEX)

    def test_first_character_dot(self):
        """
        File names with a dot as their first character don't have an extension,
        and the underscore should get added to the end.
        """
        self.storage.save('dotted.path/.test', ContentFile("1"))
        self.storage.save('dotted.path/.test', ContentFile("2"))

        files = sorted(os.listdir(os.path.join(self.storage_dir, 'dotted.path')))
        self.assertFalse(os.path.exists(os.path.join(self.storage_dir, 'dotted_.path')))
        self.assertEqual(files[0], '.test')
        self.assertRegex(files[1], '.test_%s' % FILE_SUFFIX_REGEX)
예제 #7
0
 def __init__(self, apps=None, *args, **kwargs):
     # List of locations with static files
     self.locations = []
     # Maps dir paths to an appropriate storage instance
     self.storages = SortedDict()
     if not isinstance(settings.STATICFILES_DIRS, (list, tuple)):
         raise ImproperlyConfigured(
             "Your STATICFILES_DIRS setting is not a tuple or list; "
             "perhaps you forgot a trailing comma?")
     for root in settings.STATICFILES_DIRS:
         if isinstance(root, (list, tuple)):
             prefix, root = root
         else:
             prefix = ''
         if settings.STATIC_ROOT and os.path.abspath(settings.STATIC_ROOT) == os.path.abspath(root):
             raise ImproperlyConfigured(
                 "The STATICFILES_DIRS setting should "
                 "not contain the STATIC_ROOT setting")
         if (prefix, root) not in self.locations:
             self.locations.append((prefix, root))
     for prefix, root in self.locations:
         filesystem_storage = FileSystemStorage(location=root)
         filesystem_storage.prefix = prefix
         self.storages[root] = filesystem_storage
     super(FileSystemFinder, self).__init__(*args, **kwargs)
예제 #8
0
    def save(self, page, language, data, change, extra_data=None):
        if 'delete' in extra_data:
            return super(ImagePlaceholderNode, self).save(
                page,
                language,
                "",
                change
            )
        filename = ''
        if change and data:
            # the image URL is posted if not changed
            if type(data) is unicode:
                return
            storage = FileSystemStorage()
            filename = os.path.join(
                settings.PAGE_UPLOAD_ROOT,
                'page_'+str(page.id),
                self.name + '-' + str(time.time())
            )

            m = re.search('\.[a-zA-Z]{1,4}$', str(data))
            if m is not None:
                filename += m.group(0).lower()

            filename = storage.save(filename, data)
            return super(ImagePlaceholderNode, self).save(
                page,
                language,
                filename,
                change
            )
예제 #9
0
파일: backends.py 프로젝트: rlugojr/portia
 def __init__(self, name, author=None, *args, **kwargs):
     self.author = author
     super(FsStorage, self).__init__(name, *args, **kwargs)
     FileSystemStorage.__init__(self, os.path.join(
         self.base_dir, self.name))
     if name:
         self.init_project()
 def setUpClass(cls):
     super(PhotoReviewTests, cls).setUpClass()
     storage = FileSystemStorage()
     desired_storage_path = join('queued-images', 'pilot.jpg')
     with open(cls.example_image_filename, 'rb') as f:
         cls.storage_filename = storage.save(desired_storage_path, f)
     mkdir_p(TEST_MEDIA_ROOT)
예제 #11
0
파일: views.py 프로젝트: frankpuppa/kerrini
def upload(request):
    if request.method == 'POST':
        form = UploadFileForm(request.POST, request.FILES)
        if form.is_valid():
            file=request.FILES['file']
            storage = FileSystemStorage(
                    location = '/tmp/django',
                    base_url = '/tmp/django'
                  )
            content = request.FILES['file']
            name = storage.save(None, content)
            url = storage.url(name)

            filetype = magic.from_file(url,mime=True).decode()
            myreg=re.compile(r'(mp4)|(ogg)|(webm)',re.I)
            ext=myreg.search(filetype)
            if ext:
                newfilename=move_file(url,ext.group(0).lower())
                dir=ext.group(0).lower()
                #data=dir + "/" + str(newfilename)
                data=dir #Check with the guys what they want
                try:
                     Video.create(video_id=newfilename, correctness=0, title=form.cleaned_data['title'], description=form.cleaned_data['description'], data=data, date_created=datetime.datetime.now(),video_codec=dir)
                except Video.DoesNotExist:
                     return HttpResponse("LWT failed")
        return render(request,'upload.html', {'form':form})
    else:
        form = UploadFileForm()
    return render (request,'upload.html', {'form': form})
예제 #12
0
class ThumbnailField:
    '''
    Instances of this class will be used to access data of the
    generated thumbnails
    '''
    def __init__(self, name):
        self.name = name
        self.storage = FileSystemStorage()

    def path(self):
        return self.storage.path(self.name)

    def url(self):
        return self.storage.url(self.name)

    def size(self):
        return self.storage.size(self.name)

    def is_landscape(self):
        return self.orientation() == 'landscape'

    def is_portrait(self):
        return self.orientation() == 'portrait'

    def orientation(self):
        w, h = get_image_dimensions(self.path())
        if w > h:
            return 'landscape'
        else:
            return 'portrait'
예제 #13
0
def ck_upload(request, upload_folder):
    error_message = 'Unable to upload'

    upload_location = os.path.join(settings.MEDIA_ROOT, upload_folder)
    upload_url = urlparse.urljoin(settings.MEDIA_URL, upload_folder)

    if request.method == "POST":
        filesystem = FileSystemStorage(location=upload_location,
                                       base_url=upload_url)
        try:
            uploaded_file = request.FILES['upload']
            saved_file = filesystem.save(uploaded_file.name, uploaded_file)
            saved_url = filesystem.url(saved_file)
        except Exception:
            return HttpResponse(error_message)

        try:
            callback = request.GET['CKEditorFuncNum']
        except KeyError:
            callback = ''
    else:
        return HttpResponse(error_message)

    context = {
        'callback': callback,
        'saved_url': saved_url,
        }

    return direct_to_template(request, 'ckeditor/upload_result.html', context)
예제 #14
0
class VariationField(object):
    """Instances of this class will be used to access data of the generated variations."""

    def __init__(self, name):
        """

        :param name: str
        """
        self.name = name
        self.storage = FileSystemStorage()

    @property
    def path(self):
        """Return the abs. path of the image file."""
        return self.storage.path(self.name)

    @property
    def url(self):
        """Return the url of the image file."""
        return self.storage.url(self.name)

    @property
    def size(self):
        """Return the size of the image file, reported by os.stat()."""
        return self.storage.size(self.name)
예제 #15
0
 def __init__(self, **kwargs):
     options = kwargs.get("options", None)
     location = kwargs.get("location", None)
     base_url = kwargs.get("base_url", None)
     # TODO if django >= 1.6: file_permissions_mode
     ThumborStorage.__init__(self, options)
     FileSystemStorage.__init__(self, location=location, base_url=base_url)
예제 #16
0
class Command(collectstatic.Command):
    help = "Collects static files from apps and other locations into "\
           "`VERSIONED_STATIC_ROOT` with a versioned filename. (Used in "\
           "conjunction with the {% versionedstatic %} template tag.)"

    def __init__(self, *args, **kwargs):
        super(Command, self).__init__(*args, **kwargs)

        # Force storage to be a filesystem storage for VERSIONED_STATIC_ROOT.
        self.storage = FileSystemStorage(location=settings.VERSIONED_STATIC_ROOT)
        try:
            self.storage.path('')
        except NotImplementedError:
            self.local = False
        else:
            self.local = True

    def copy_file(self, path, prefixed_path, source_storage, **kwargs):
        version = get_file_version(path, source_storage)
        prefixed_path = get_versioned_path(prefixed_path, version)
        return super(Command, self).copy_file(path, prefixed_path,
            source_storage, **kwargs)

    def link_file(self, path, prefixed_path, source_storage, **kwargs):
        version = get_file_version(path, source_storage)
        prefixed_path = get_versioned_path(prefixed_path, version)
        return super(Command, self).link_file(path, prefixed_path,
            source_storage, **kwargs)
예제 #17
0
def new_image(request,menu_code="default"):
	menu,created=Menu.objects.get_or_create(code=menu_code)

	print request.REQUEST.items()
	frame = request.REQUEST['frame']
	try:
		original_name = request.REQUEST['original_name']
	except KeyError:
		original_name = frame

	original_name = original_name.replace("/","_");
	
	image_dir=menu.img_dir();
        print image_dir

        image=request.FILES['image']
        storage = FileSystemStorage(image_dir);
        path = storage.save(os.path.join(image_dir,original_name),image);

	base_pose = request.REQUEST.get('base_pose','')
	object_pose = request.REQUEST.get('object_pose','')

	mi=MenuItem(menu=menu, image_name=original_name,base_pose=base_pose,object_pose=object_pose);
	mi.save();

	return HttpResponse("ItemID: %d",mi.id)
예제 #18
0
class ExhibitStorage(FileSystemStorage):
    """
    Assume that incoming paths are of the form <username>/.../...
    """
    def __init__(self, *args, **kwargs): 
        self.__userdata_storage = FileSystemStorage(location=kwargs['location'], base_url=kwargs['base_url'])
        
    def _open(self, name, mode='rb'):
        return self.__userdata_storage._open(chunk_path(name) + name, mode)
        
    def _save(self, name, content):
        chunk = chunk_path(name)       
        fullname = chunk + name 
        if (self.__userdata_storage.exists(fullname)):
            self.__userdata_storage.delete(fullname)
        result = self.__userdata_storage._save(fullname, content)
        return result.partition(chunk)[2]
        
    def exists(self, name):
        return self.__userdata_storage.exists(chunk_path(name) + name)
    
    def path(self, name):
        return self.__userdata_storage.path(chunk_path(name) + name)
    
    def size(self, name):
        return self.__userdata_storage.size(chunk_path(name) + name)
    
    def delete(self, name):
        return self.__userdata_storage.delete(chunk_path(name) + name)
    
    def url(self, name):
        return self.__userdata_storage.url(name)
    def get_available_name(self, name):
        return self.__userdata_storage.get_available_n
예제 #19
0
class FileStoragePathParsing(unittest.TestCase):
    def setUp(self):
        self.storage_dir = tempfile.mkdtemp()
        self.storage = FileSystemStorage(self.storage_dir)

    def tearDown(self):
        shutil.rmtree(self.storage_dir)

    def test_directory_with_dot(self):
        """Regression test for #9610.

        If the directory name contains a dot and the file name doesn't, make
        sure we still mangle the file name instead of the directory name.
        """

        self.storage.save('dotted.path/test', ContentFile(b"1"))
        self.storage.save('dotted.path/test', ContentFile(b"2"))

        self.assertFalse(os.path.exists(os.path.join(self.storage_dir, 'dotted_.path')))
        self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/test')))
        self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/test_1')))

    def test_first_character_dot(self):
        """
        File names with a dot as their first character don't have an extension,
        and the underscore should get added to the end.
        """
        self.storage.save('dotted.path/.test', ContentFile(b"1"))
        self.storage.save('dotted.path/.test', ContentFile(b"2"))

        self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/.test')))
        self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/.test_1')))
예제 #20
0
파일: fields.py 프로젝트: hyliker/pingni
class ThumbnailField:
    '''
    Instances of this class will be used to access data of the
    generated thumbnails
    '''
    def __init__(self, name):
        self.name = name
        self.storage = FileSystemStorage()

    @property
    def path(self):
        return self.storage.path(self.name)

    @property
    def url(self):
        return self.storage.url(self.name)

    @property
    def size(self):
        return self.storage.size(self.name)

    @property
    def height(self):
        im = Image.open(self.path)
        return im.size[1]

    @property
    def width(self):
        im = Image.open(self.path)
        return im.size[0]
예제 #21
0
 def handle_mock(self, app, url_map, output_prefix, base_context,
                 **other_options):
     app_list = [app] if app else settings.INSTALLED_APPS
     if [a for a in app_list if a not in settings.INSTALLED_APPS]:
         raise CommandError('Invalid app specified. Only installed apps may '
                            'be used.')
     if url_map and not os.path.exists(url_map):
         raise CommandError('No such URL map at that path.')
     if base_context and not os.path.exists(base_context):
         raise CommandError('No such URL map at that path.')
     if '..' in output_prefix.split('/') or output_prefix.startswith('/'):
         raise CommandError('Treachery! No root paths or parent navigation '
                            'when specifying an output prefix, you clever '
                            'devil.')
     compiler.DjangoJadeCompiler.preempt_url_patterns(
         json.load(open(url_map)) if url_map else {})
     for app in app_list:
         self.handle_compile(app)
         compiler_obj = compiler.DjangoJadeCompiler(
             app,
             base_context=(json.load(open(base_context))
                           if base_context else {}))
         for tmpl_data in compiler_obj.find_compilable_jade_templates(standalone=False):
             logger.debug('Template data: %s', tmpl_data)
             html = compiler_obj.mock(**tmpl_data)
             faux_file = ContentFile(html)
             html_path = os.path.join(output_prefix,
                                      tmpl_data['template_path'],
                                      '%s.html' % tmpl_data['base_file_name'])
             logger.info('Saving HTML file %s', html_path)
             storage_obj = FileSystemStorage(location=settings.STATIC_ROOT)
             storage_obj.save(html_path, faux_file)
예제 #22
0
def upload(request):
    t = Template(SUCCESS_TEMPLATE)

    if hasattr(settings, "CK_FILE_PATH"):
        ck_file_path = settings.CK_FILE_PATH
    else:
        ck_file_path = ""

    FILE_PATH = os.path.join(settings.MEDIA_ROOT, ck_file_path)
    FILE_URL = urlparse.urljoin(settings.MEDIA_URL, ck_file_path)

    if request.method == "POST":
        filesystem = FileSystemStorage(location=FILE_PATH, base_url=FILE_URL)
        try:
            uploaded_file = request.FILES["upload"]
            filename = filesystem.save(uploaded_file.name, uploaded_file)
            ck_filename = filesystem.url(filename)
        except MultiValueDictKeyError:
            return HttpResponse(t.render())
        try:
            callback = request.GET["CKEditorFuncNum"]
        except:
            callback = ""
    else:
        return HttpResponse(t.render())

    rc = RequestContext(request, {"callback": callback, "filename": ck_filename})

    return HttpResponse(t.render(rc))
def enqueue_image(person, user, image_url):
    r = requests.get(
        image_url,
        headers={
            'User-Agent': USER_AGENT,
        },
        stream=True
    )
    if not r.status_code == 200:
        message = "HTTP status code {0} when downloading {1}"
        raise Exception(message.format(r.status_code, image_url))
    storage = FileSystemStorage()
    suggested_filename = \
        'queued_image/{d.year}/{d.month:02x}/{d.day:02x}/ci-upload'.format(
            d=date.today()
        )
    storage_filename = storage.save(suggested_filename, r.raw)
    QueuedImage.objects.create(
        why_allowed=QueuedImage.OTHER,
        justification_for_use="Downloaded from {0}".format(image_url),
        decision=QueuedImage.UNDECIDED,
        image=storage_filename,
        person_id=person.id,
        user=user
    )
예제 #24
0
def do_upload_image(request,session,form,uploaded_file):
	
	user = request.user;
        print form.cleaned_data
	print uploaded_file
        submission_rt=os.path.join(settings.DATASETS_ROOT,session.code);

        id = session.mthit_set.count()+1;
	rand_id=str(uuid.uuid4())+"-"+str(id)
	print dir(uploaded_file)
	original_name =uploaded_file.name
        storage = FileSystemStorage(submission_rt);
        fname=storage.save(os.path.join(submission_rt,rand_id+".jpg"),uploaded_file);

	params="image_url=/frames/"+session.code+"/"+rand_id+".jpg&frame="+rand_id+"&original_name="+original_name 
	print params
        hit=mturk.models.MTHit(session=session,ext_hitid=rand_id,int_hitid=id,parameters=params);
	hit.save();
	if form.cleaned_data["submit_for_annotation"]:
		(activated,msg)=mturk.views.activate_hit(session,hit);
	else:
		activated=False
		msg="submission disabled"

	return HttpResponse("done. Activated %d, %s" % (activated,msg))
예제 #25
0
파일: tests.py 프로젝트: alexhayes/django
class FileLikeObjectTestCase(LiveServerBase):
    """
    Test file-like objects (#15644).
    """

    def setUp(self):
        self.temp_dir = tempfile.mkdtemp()
        self.storage = FileSystemStorage(location=self.temp_dir)

    def tearDown(self):
        shutil.rmtree(self.temp_dir)

    def test_urllib2_urlopen(self):
        """
        Test the File storage API with a file like object coming from urllib2.urlopen()
        """

        file_like_object = self.urlopen("/example_view/")
        f = File(file_like_object)
        stored_filename = self.storage.save("remote_file.html", f)

        remote_file = self.urlopen("/example_view/")

        with self.storage.open(stored_filename) as stored_file:
            self.assertEqual(stored_file.read(), remote_file.read())
예제 #26
0
파일: views.py 프로젝트: deepakkt/aasaan
    def post(self, request, *args, **kwargs):
        msg_subject = request.POST.get('subject')
        message_body = request.POST.get('temp_message')
        sender = request.user.first_name + "|" + request.user.email
        to = get_email_list(request.POST.get('to'))
        cc = get_email_list(request.POST.get('cc'))
        bcc = get_email_list(request.POST.get('bcc'))
        bcc.append(request.user.email)
        files = request.FILES.getlist('attachments')
        _files = []
        for f in files:
            fs = FileSystemStorage()
            fs.location = join(settings.MEDIA_ROOT, "ipcaccounts/vouchers/email")
            filename = fs.save(f.name, f)
            _files.append(join(fs.location, filename))
            uploaded_file_url = fs.url(filename)

        stage_classic_notification("IPC Vouchers", sender, to, cc,
                                    msg_subject, message_body, _files)
        _dispatch_status = True

        if _dispatch_status:
            account_id = request.POST.get('account_id')
            account_master = RCOAccountsMaster.objects.get(id=account_id)
            account_master.email_sent = True
            account_master.save()
            return render(request, 'ipcaccounts/confirm.html')
        else:
            return render(request, 'ipcaccounts/error.html')
예제 #27
0
파일: ajax.py 프로젝트: fergalmoran/dss
def upload(request):
    # The assumption here is that jQuery File Upload
    # has been configured to send files one at a time.
    # If multiple files can be uploaded simultaneously,
    # 'file' may be a list of files.
    try:
        uid = request.POST['upload-hash']
        in_file = request.FILES['file'] if request.FILES else None
        file_name, extension = os.path.splitext(in_file.name)

        file_storage = FileSystemStorage(location=os.path.join(settings.CACHE_ROOT, "mixes"))
        cache_file = file_storage.save("%s%s" % (uid, extension), ContentFile(in_file.read()))
        response = ''

        try:
            create_waveform_task.delay(in_file=os.path.join(file_storage.base_location, cache_file), uid=uid)
        except:
            logger.debug("Unable to connect to celery")
            response = 'Unable to connect to waveform generation task, there may be a delay in getting your mix online'

        file_dict = {
            'response': response,
            'size': in_file.size,
            'uid': uid
        }

        return UploadResponse(request, file_dict)
    except Exception, ex:
        logger.exception(ex.message)
        raise
예제 #28
0
def do_upload_video(request,session,form,uploaded_file):
	
	user = request.user;
        print form.cleaned_data
	print uploaded_file
        submission_rt=os.path.join(settings.DATASETS_ROOT,session.code);

        id = session.mthit_set.count()+1;
	rand_id=str(uuid.uuid4())+"-"+str(id)
	print dir(uploaded_file)
	original_name =uploaded_file.name
        storage = FileSystemStorage(submission_rt);
        fname=storage.save(os.path.join(submission_rt,rand_id+".flv"),uploaded_file);

	params="video=/frames/"+session.code+"/"+rand_id+".flv&original_name="+original_name 
	print params
        hit=mturk.models.MTHit(session=session,ext_hitid=rand_id,int_hitid=id,parameters=params);
	hit.save();
	if form.cleaned_data["submit_for_annotation"]:
		(activated,id)=mturk.views.activate_hit(session,hit);
	else:
		activated=False

	return HttpResponse("done. Activated %d" % activated)
        #challenge=form.cleaned_data['challenge']
	#challenge = get_object_or_404(Challenge,name=challenge_name);
	"""
예제 #29
0
    def list(self, ignore_patterns):
        re_patterns = []

        for pattern in ignore_patterns:
            if pattern.startswith('*'):
                re_pattern = re.compile(pattern[1:].replace('.', '\\.') + '$')
            elif pattern.endswith('*'):
                re_pattern = re.compile('^' + pattern[:-1].replace('.', '\\.'))
            else:
                re_pattern = re.compile(pattern)

            if re_pattern is not None:
                re_patterns.append(re_pattern)

        for helio_static_dir in self.helio_static_dirs:
            storage = FileSystemStorage(location=helio_static_dir)
            for static_file in listdir(helio_static_dir):
                yield (static_file, storage)

        for component_base_dir in self.component_base_directories:
            for (dir_root, dir_list, file_list) in walk_component_base_dir(component_base_dir):
                for static_file in file_list:
                    if should_ignore_file(static_file, re_patterns):
                        continue

                    full_static_path = join(dir_root, static_file)

                    res = re.search(r'/(.*)/static', full_static_path)
                    if res is None:
                        continue

                    storage = FileSystemStorage(location=dir_root)
                    storage.prefix = res.group(1)
                    yield (static_file, storage)
예제 #30
0
def upload_files(request):
    files = request.FILES.getlist('images')

    for image_file in files:
        if image_file.content_type not in [u'image/jpeg', u'image/gif', u'image/pjpeg', u'image/png']:
            continue

        instance = Picture.objects.create(owner=request.user)

        data = {}
        file_info = []

        if image_file.__class__ is InMemoryUploadedFile:

            file_info.append(image_file.field_name)
            file_info.append(image_file.name)
            file_info.append(image_file.content_type)
            file_info.append(image_file.size)
            file_info.append(image_file.charset)

            #the actual data of the image, read into a string
            data['data'] = image_file.read()

            async_save_in_memory.delay(data, file_info, instance.pk)
        else:
            storage = FileSystemStorage()
            path = storage.save(u'uploaded/%s' % image_file.name, image_file)

            async_save_temporary.delay(instance.pk, path, image_file.name)

    return redirect(reverse('my_picture'))
예제 #31
0
파일: event.py 프로젝트: zephyrict/pretalx
class EventWizard(PermissionRequired, SensibleBackWizardMixin,
                  SessionWizardView):
    permission_required = 'orga.create_events'
    file_storage = FileSystemStorage(location=Path(settings.MEDIA_ROOT) /
                                     'new_event')
    form_list = [
        ('initial', EventWizardInitialForm),
        ('basics', EventWizardBasicsForm),
        ('timeline', EventWizardTimelineForm),
        ('display', EventWizardDisplayForm),
        ('copy', EventWizardCopyForm),
    ]
    condition_dict = {'copy': condition_copy}

    def get_template_names(self):
        return f'orga/event/wizard/{self.steps.current}.html'

    @context
    def has_organiser(self):
        return (
            self.request.user.teams.filter(can_create_events=True).exists()
            or self.request.user.is_administrator)

    @context
    def url_placeholder(self):
        return f'https://{self.request.host}/'

    @context
    def organiser(self):
        return (self.get_cleaned_data_for_step('initial').get('organiser')
                if self.steps.current != 'initial' else None)

    def render(self, form=None, **kwargs):
        if self.steps.current != 'initial':
            fdata = self.get_cleaned_data_for_step('initial')
            if fdata is None:
                return self.render_goto_step('initial')
        if self.steps.current == 'timeline':
            fdata = self.get_cleaned_data_for_step('basics')
            year = now().year % 100
            if fdata and not str(year) in fdata['slug'] and not str(
                    year + 1) in fdata['slug']:
                messages.warning(
                    self.request,
                    str(
                        _('Please consider including your event\'s year in the slug, e.g. myevent{number}.'
                          )).format(number=year))
        if self.steps.current == 'display':
            fdata = self.get_cleaned_data_for_step('timeline')
            if fdata and fdata.get('date_to') < now().date():
                messages.warning(
                    self.request,
                    _('Did you really mean to make your event take place in the past?'
                      ))
        return super().render(form, **kwargs)

    def get_form_kwargs(self, step=None):
        kwargs = {'user': self.request.user}
        if step != 'initial':
            fdata = self.get_cleaned_data_for_step('initial')
            kwargs.update(fdata or dict())
        return kwargs

    @transaction.atomic()
    def done(self, form_list, *args, **kwargs):
        steps = {
            step: self.get_cleaned_data_for_step(step)
            for step in ('initial', 'basics', 'timeline', 'display', 'copy')
        }

        with scopes_disabled():
            event = Event.objects.create(
                organiser=steps['initial']['organiser'],
                locale_array=','.join(steps['initial']['locales']),
                name=steps['basics']['name'],
                slug=steps['basics']['slug'],
                timezone=steps['basics']['timezone'],
                email=steps['basics']['email'],
                locale=steps['basics']['locale'],
                primary_color=steps['display']['primary_color'],
                logo=steps['display']['logo'],
                date_from=steps['timeline']['date_from'],
                date_to=steps['timeline']['date_to'],
            )
        with scope(event=event):
            deadline = steps['timeline'].get('deadline')
            if deadline:
                zone = timezone(event.timezone)
                event.cfp.deadline = zone.localize(
                    deadline.replace(tzinfo=None))
                event.cfp.save()
            for setting in [
                    'custom_domain', 'display_header_data', 'show_on_dashboard'
            ]:
                value = steps['display'].get(setting)
                if value:
                    event.settings.set(setting, value)

        has_control_rights = self.request.user.teams.filter(
            organiser=event.organiser,
            all_events=True,
            can_change_event_settings=True,
            can_change_submissions=True,
        ).exists()
        if not has_control_rights:
            t = Team.objects.create(
                organiser=event.organiser,
                name=_(f'Team {event.name}'),
                can_change_event_settings=True,
                can_change_submissions=True,
            )
            t.members.add(self.request.user)
            t.limit_events.add(event)

        logdata = {}
        for f in form_list:
            logdata.update({k: v for k, v in f.cleaned_data.items()})
        with scope(event=event):
            event.log_action('pretalx.event.create',
                             person=self.request.user,
                             data=logdata,
                             orga=True)

            if steps['copy'] and steps['copy']['copy_from_event']:
                event.copy_data_from(steps['copy']['copy_from_event'])

        return redirect(event.orga_urls.base + '?congratulations')
예제 #32
0
 def __init__(self):
     # type: () -> None
     super().__init__(FileSystemStorage())
예제 #33
0
파일: tests.py 프로젝트: hottwaj/django
 def setUp(self):
     self.storage_dir = tempfile.mkdtemp()
     self.storage = FileSystemStorage(self.storage_dir)
예제 #34
0
파일: tests.py 프로젝트: hottwaj/django
 def test_file_upload_directory_default_permissions(self):
     self.storage = FileSystemStorage(self.storage_dir)
     name = self.storage.save("the_directory/the_file", ContentFile("data"))
     dir_mode = os.stat(os.path.dirname(self.storage.path(name)))[0] & 0o777
     self.assertEqual(dir_mode, 0o777 & ~self.umask)
예제 #35
0
파일: tests.py 프로젝트: hottwaj/django
 def test_file_upload_default_permissions(self):
     self.storage = FileSystemStorage(self.storage_dir)
     fname = self.storage.save("some_file", ContentFile("data"))
     mode = os.stat(self.storage.path(fname))[0] & 0o777
     self.assertEqual(mode, 0o666 & ~self.umask)
예제 #36
0
파일: tests.py 프로젝트: hottwaj/django
 def test_file_upload_permissions(self):
     self.storage = FileSystemStorage(self.storage_dir)
     name = self.storage.save("the_file", ContentFile("data"))
     actual_mode = os.stat(self.storage.path(name))[0] & 0o777
     self.assertEqual(actual_mode, 0o654)
예제 #37
0
파일: tests.py 프로젝트: hottwaj/django
 def setUp(self):
     self.storage_dir = tempfile.mkdtemp()
     self.storage = FileSystemStorage(self.storage_dir)
     self.thread = threading.Thread(target=self.save_file,
                                    args=['conflict'])
def Upload(request):

    if request.method == 'POST':
        uploaded_file = request.FILES['dataset']
        arr = uploaded_file.name.split('.', 1)
        fName = arr[0]
        extension = arr[1]
        fullName = fName + '.' + extension

        # Validating the uploaded file
        if extension == 'csv':
            fs = FileSystemStorage()

            file_path1 = os.path.join(settings.MEDIA_ROOT,
                                      'original/' + fullName)
            file_path2 = os.path.join(settings.MEDIA_ROOT,
                                      'processed/' + fullName)

            if os.path.exists(file_path1 and file_path2):
                os.remove(file_path1)
                os.remove(file_path2)

            plt.clf()
            chart_path = os.path.join(settings.MEDIA_ROOT, 'static/charts/')
            boxplot_chart_path = os.path.join(settings.MEDIA_ROOT,
                                              'static/boxplotcharts/')

            if os.path.exists(chart_path):
                shutil.rmtree(chart_path,
                              ignore_errors=False,
                              onerror=handleRemoveReadonly)
                os.makedirs(chart_path)
            else:
                os.makedirs(chart_path)

            if os.path.exists(boxplot_chart_path):
                shutil.rmtree(boxplot_chart_path,
                              ignore_errors=False,
                              onerror=handleRemoveReadonly)
                os.makedirs(boxplot_chart_path)
            else:
                os.makedirs(boxplot_chart_path)

            fs.save('processed/' + fullName, uploaded_file)
            fs.save('original/' + fullName, uploaded_file)

            df = pd.read_csv(os.path.join(settings.MEDIA_ROOT,
                                          'processed/' + fName + '.csv'),
                             encoding='mbcs')
            df = df.replace(to_replace="?", value="nan")
            df.to_csv(os.path.join(settings.MEDIA_ROOT,
                                   'processed/' + fName + '.csv'),
                      index=False)

            context = Overview(fName)
            context['status'] = 'Success'
            context['message'] = 'Dataset Uploaded Successfully'
            return render(request, 'index.html', context)
        else:
            context = {
                'fName': fName,
                'status': 'Error',
                'message': 'Please upload .csv files'
            }
            return render(request, 'Upload.html', context)

    return render(request, 'Upload.html')
예제 #39
0
 def setUp(self):
     self.old_perms = settings.FILE_UPLOAD_PERMISSIONS
     settings.FILE_UPLOAD_PERMISSIONS = 0666
     self.storage_dir = tempfile.mkdtemp()
     self.storage = FileSystemStorage(self.storage_dir)
예제 #40
0
def cargaexcel(request):
    if request.method == 'POST':
        uploaded_file = request.FILES['document']
        fs = FileSystemStorage()
        name = fs.save(uploaded_file.name, uploaded_file)

        xls = pd.ExcelFile(BASE_DIR + fs.url(name))
        hojas = xls.sheet_names
        print(len(hojas))
        dc1 = Document()
        def mat(abcd):
            pri = 0
            val = 0
            aux = []
            for i in range(15):
                aux.append([])
                for j in range(5):
                    aux[i].append(None)

            for i in range(len(abcd)):
                sec = 0
                val = 0
                for j in range(len(abcd[i])):

                    if type(abcd[i][j]) is str:
                        val += 1
                        aux[pri][sec] = abcd[i][j]
                        sec += 1
                    else:
                        if type(abcd[i][j]) is int:
                            abcd[i][j] = str(abcd[i][j])
                            val += 1
                            aux[pri][sec] = abcd[i][j]
                            sec += 1
                        else:
                            if type(abcd[i][j]) is float:
                                if abcd[i][j]/abcd[i][j]==1:
                                    abcd[i][j] = str(abcd[i][j])
                                    val += 1
                                    aux[pri][sec] = abcd[i][j]
                                    sec += 1

                if val > 0:
                    pri += 1

            return aux
        aux=0

        for cont in range(len(hojas)-1):
            cont += 1
            df = xls.parse(hojas[cont])

            fich = df.__array__()

            real = mat(fich);
            fich = real
            print(fich)

            tit = fich[0][0]
            anio = str(fich[4][1])
            nota1 = str(fich[10][1])
            nota2 = str(fich[10][2])
            nota3 = str(fich[10][3])
            promedio = str(fich[11][1])

            dc1.add_heading(tit, 0)
            dc1.add_heading(fich[1][0], 2)
            p = dc1.add_paragraph()
            # p.add_run('\n')

            tbl1 = dc1.add_table(rows=0, cols=2)
            fila = tbl1.add_row().cells
            fila[0].text = fich[2][0]
            fila[1].text = fich[2][1]
            # p.add_run(fich[2][0] + ' \t').bold = True
            # p.add_run(fich[2][1])

            fila1 = tbl1.add_row().cells
            fila1[0].text = fich[3][0]
            fila1[1].text = fich[3][1]
            # p.add_run('\n\n')
            # p.add_run(fich[3][0] + ' \t').bold = True
            # p.add_run(fich[3][1])

            fila2 = tbl1.add_row().cells
            fila2[0].text = fich[4][0]
            fila2[1].text = anio
            # p.add_run('\n\n')
            # p.add_run(fich[4][0] + ' \t').bold = True
            # p.add_run(anio)

            dc1.add_heading(fich[5][0], 2)
            p1 = dc1.add_paragraph()
            # p1.add_run('\n')

            tbl2 = dc1.add_table(rows=0, cols=2)
            fila = tbl2.add_row().cells
            fila[0].text = fich[6][0]
            fila[1].text = fich[6][1]

            # p1.add_run(fich[6][0] + ' \t').bold = True
            # p1.add_run(fich[6][1])

            fila1 = tbl2.add_row().cells
            fila1[0].text = fich[7][0]
            fila1[1].text = fich[7][1]

            # p1.add_run('\n\n')
            # p1.add_run(fich[7][0] + ' \t').bold = True
            # p1.add_run(fich[7][1])

            dc1.add_heading(fich[8][0], 2)
            p2 = dc1.add_paragraph()
            # p2.add_run('\n')

            tbl3 = dc1.add_table(rows=0, cols=4)
            fila = tbl3.add_row().cells
            fila[0].text = fich[9][0]
            fila[1].text = fich[9][1]

            # p2.add_run(fich[9][0] + ' \t').bold = True
            # p2.add_run(fich[9][1])

            fila1 = tbl3.add_row().cells
            fila1[0].text = fich[10][0]
            fila1[1].text = nota1
            fila1[2].text = nota2
            fila1[3].text = nota3

            # p2.add_run('\n\n')
            # p2.add_run(fich[10][0] + ' \t').bold = True
            # p2.add_run(nota1+ ' \t'+nota2+ ' \t'+nota3+ ' \t')

            fila2 = tbl3.add_row().cells
            fila2[0].text = fich[11][0]
            fila2[1].text = promedio

            # p2.add_run('\n\n')
            # p2.add_run(fich[11][0] + ' \t').bold = True
            # p2.add_run(promedio)

            dc1.add_heading(fich[12][0], 2)
            p3 = dc1.add_paragraph()

            tbl4 = dc1.add_table(rows=0, cols=2)
            fila = tbl4.add_row().cells
            fila[0].text = fich[13][0]
            fila[1].text = fich[13][1]

            # p3.add_run('\n')
            # p3.add_run(fich[13][0] + ' \t').bold = True
            # p3.add_run(fich[13][1])

            fila1 = tbl4.add_row().cells
            fila1[0].text = fich[14][0]
            fila1[1].text = fich[14][1]

            # p3.add_run('\n\n')
            # p3.add_run(fich[14][0] + ' \t').bold = True
            # p3.add_run(fich[14][1])

            # dc1.add_picture('C:/Users/Angel/Desktop/prueba/excel/imgplot.png')



            """
            nombimg = 'img' + str(aux) + '.jpg'
            num = int(nota)
            nomb = str(fich[2][1])
            nombre = ("", nomb, "")
            posicion_y = np.arange(3)
            unidad = (0, num, 0)

            plt.barh(posicion_y, unidad, align="center")
            plt.yticks(posicion_y, nombre)
            plt.xlabel("NOTA")
            plt.title("NOTAS")
            plt.savefig(BASE_DIR+'/media/'+nombimg)



            dc1.add_picture(BASE_DIR+'/media/'+nombimg)

            os.remove(BASE_DIR+'/media/'+nombimg)
            """

            dc1.add_page_break()


        nombre_archivo = "Proyecto.docx"
        response = HttpResponse(content_type="application/msword")
        contenido = "attachment; filename= {0}".format(nombre_archivo)
        response["Content-Disposition"] = contenido
        dc1.save(response)

        return response
        #return render(request, 'word/index.html', {'url':fs.url(name)})

    return render(request, 'word/index.html')
예제 #41
0
파일: tests.py 프로젝트: hottwaj/django
 def setUp(self):
     self.temp_dir = tempfile.mkdtemp()
     self.storage = FileSystemStorage(location=self.temp_dir)
예제 #42
0
    def create(self, request, *args, **kwargs):
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid(raise_exception=True):
            file_name = serializer.validated_data['products_file'].name
            fs = FileSystemStorage('media/import_export/')
            file_extension = file_name.split('.')[1].lower()
            filename = fs.save(
                file_name.split('.')[0].lower() + '_' +
                str(str(uuid.uuid4())[-4:]) + '.' + file_extension,
                serializer.validated_data.get('products_file'))
            file_path = MEDIA_URL + 'import_export/' + filename
            cwd = os.getcwd()
            full_path = f"{cwd}/{file_path}"

            if file_extension == 'xls' or file_extension == 'xlsx':
                try:
                    book = xlrd.open_workbook(full_path)
                    sheet_obj = book.sheet_by_index(0)
                    max_rows = sheet_obj.nrows
                    products_list = list()
                    for rows_count in range(1, max_rows):
                        if len(str(sheet_obj.cell_value(rows_count, 0))) == 2:
                            digits = 2
                        elif len(str(sheet_obj.cell_value(rows_count,
                                                          0))) == 4:
                            digits = 4
                        elif len(str(sheet_obj.cell_value(rows_count,
                                                          0))) == 6:
                            digits = 6
                        elif len(str(sheet_obj.cell_value(rows_count,
                                                          0))) == 8:
                            digits = 8
                        else:
                            digits = None
                        products_list.append(
                            ProductMaster(hs_code=str(
                                sheet_obj.cell_value(rows_count, 0)),
                                          description=sheet_obj.cell_value(
                                              rows_count, 1),
                                          digits=digits,
                                          created_by=self.request.user))
                    ProductMaster.objects.bulk_create(products_list)
                    return Response(
                        {'msg': 'Product file gets successfully uploaded'},
                        status=status.HTTP_200_OK)

                except xlrd.biffh.XLRDError:
                    return Response(
                        {
                            'error':
                            'Could not process the uploaded file at this moment'
                        },
                        status=status.HTTP_400_BAD_REQUEST)
            else:
                return Response(
                    {
                        'error':
                        f"Only Files with 'xls' and 'xlsx are supported"
                    },
                    status=status.HTTP_400_BAD_REQUEST)
        else:
            return Response(serializer.errors,
                            status=status.HTTP_400_BAD_REQUEST)
예제 #43
0
class SubmitWizard(EventPageMixin, SensibleBackWizardMixin,
                   NamedUrlSessionWizardView):
    form_list = FORMS
    condition_dict = {'questions': show_questions_page, 'user': show_user_page}
    file_storage = FileSystemStorage(
        os.path.join(settings.MEDIA_ROOT, 'avatars'))

    def dispatch(self, request, *args, **kwargs):
        if not request.event.cfp.is_open:
            messages.error(request, phrases.cfp.submissions_closed)
            return redirect(
                reverse('cfp:event.start',
                        kwargs={'event': request.event.slug}))
        return super().dispatch(request, *args, **kwargs)

    def get_form_kwargs(self, step=None):
        kwargs = super().get_form_kwargs(step)
        if step in ['info', 'profile', 'questions']:
            kwargs['event'] = self.request.event
        if step == 'profile':
            user_data = self.get_cleaned_data_for_step('user') or dict()
            if user_data and user_data.get('user_id'):
                kwargs['user'] = User.objects.filter(
                    pk=user_data['user_id']).first()
            if not kwargs.get('user') and self.request.user.is_authenticated:
                kwargs['user'] = self.request.user
            user = kwargs.get('user')
            kwargs['name'] = user.name if user else user_data.get(
                'register_name')
            kwargs['read_only'] = False
            kwargs['essential_only'] = True
        if step == 'questions':
            kwargs['target'] = ''
            kwargs['track'] = (self.get_cleaned_data_for_step('info')
                               or dict()).get('track')
        return kwargs

    def get_form_initial(self, step):
        initial = super().get_form_initial(step)
        if step == 'info':
            for field, model in (('submission_type', SubmissionType), ('track',
                                                                       Track)):
                request_value = self.request.GET.get(field)
                if request_value:
                    with suppress(AttributeError, TypeError):
                        pk = int(request_value.split('-'))
                        obj = model.objects.filter(event=self.request.event,
                                                   pk=pk).first()
                        if obj:
                            initial[field] = obj
        return initial

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        step = kwargs.get('step')
        form = kwargs.get('form')
        step_list = []
        phase = 'done'
        for stp, form_class in self.get_form_list().items():
            if stp == step or isinstance(form, form_class):
                phase = 'current'
            step_list.append({
                'url': self.get_step_url(stp),
                'phase': phase,
                'label': FORM_DATA[stp]['label'],
                'icon': FORM_DATA[stp]['icon'],
            })
            if phase == 'current':
                phase = 'todo'
        step_list.append({
            'phase': 'todo',
            'label': _('Done!'),
            'icon': 'check'
        })
        context['step_list'] = step_list

        if step == 'profile':
            if hasattr(self.request.user, 'email'):
                email = self.request.user.email
            else:
                data = self.get_cleaned_data_for_step('user') or dict()
                email = data.get('register_email', '')
            context['gravatar_parameter'] = User(
                email=email).gravatar_parameter
        return context

    def get_template_names(self):
        return f'cfp/event/submission_{self.steps.current}.html'

    def get_prefix(self, request, *args, **kwargs):
        return super().get_prefix(request, *args, **
                                  kwargs) + ':' + kwargs.get('tmpid')

    def get_step_url(self, step):
        return reverse(
            self.url_name,
            kwargs={
                'step': step,
                'tmpid': self.kwargs.get('tmpid'),
                'event': self.kwargs.get('event'),
            },
        )

    def _handle_question_answer(self, sub, qid, value, user=None):
        question = self.request.event.questions.filter(pk=qid).first()
        if not question:
            return
        if question.target == QuestionTarget.SUBMISSION:
            answer = Answer(question=question, submission=sub)
        elif question.target == QuestionTarget.SPEAKER:
            answer = Answer(question=question, person=user)

        if question.variant == QuestionVariant.MULTIPLE:
            answstr = ', '.join([str(o) for o in value])
            answer.save()
            if value:
                answer.answer = answstr
                answer.options.add(*value)
        elif question.variant == QuestionVariant.CHOICES:
            answer.save()
            if value:
                answer.options.add(value)
                answer.answer = value.answer
        else:
            answer.answer = value or ''
        if answer.answer is not None:
            answer.save()

    def done(self, form_list, **kwargs):
        form_dict = kwargs.get('form_dict')
        if self.request.user.is_authenticated:
            user = self.request.user
        else:
            uid = form_dict['user'].save()
            user = User.objects.filter(pk=uid).first()
        if not user or not user.is_active:
            raise ValidationError(
                _('There was an error when logging in. Please contact the organiser for further help.'
                  ), )

        form_dict['info'].instance.event = self.request.event
        form_dict['info'].save()
        form_dict['info'].instance.speakers.add(user)
        sub = form_dict['info'].instance
        form_dict['profile'].user = user
        form_dict['profile'].save()
        if 'questions' in form_dict:
            for k, value in form_dict['questions'].cleaned_data.items():
                qid = k.split('_')[1]
                self._handle_question_answer(sub, qid, value, user=user)

        try:
            sub.event.ack_template.to_mail(
                user=user,
                event=self.request.event,
                context=template_context_from_submission(sub),
                skip_queue=True,
                locale=user.locale,
                submission=sub,
                full_submission_content=True,
            )
            if self.request.event.settings.mail_on_new_submission:
                MailTemplate(
                    event=self.request.event,
                    subject=_('New submission!').format(
                        event=self.request.event.slug),
                    text=self.request.event.settings.mail_text_new_submission,
                ).to_mail(
                    user=self.request.event.email,
                    event=self.request.event,
                    context=template_context_from_submission(sub),
                    skip_queue=True,
                    locale=self.request.event.locale,
                )
            additional_speaker = form_dict['info'].cleaned_data.get(
                'additional_speaker').strip()
            if additional_speaker:
                sub.send_invite(to=[additional_speaker], _from=user)
        except SendMailException as exception:
            logging.getLogger('').warning(str(exception))
            messages.warning(self.request, phrases.cfp.submission_email_fail)

        sub.log_action('pretalx.submission.create', person=user)
        messages.success(self.request, phrases.cfp.submission_success)
        login(self.request,
              user,
              backend='django.contrib.auth.backends.ModelBackend')
        return redirect(
            reverse('cfp:event.user.submissions',
                    kwargs={'event': self.request.event.slug}))
예제 #44
0
    def save(self):

        try:
            image = self.validated_data['image']
            title = self.validated_data['title']
            if len(title) < MIN_TITLE_LENGTH:
                raise serializers.ValidationError({
                    "response":
                    "Enter a title longer than " + str(MIN_TITLE_LENGTH) +
                    " characters."
                })

            body = self.validated_data['body']
            if len(body) < MIN_BODY_LENGTH:
                raise serializers.ValidationError({
                    "response":
                    "Enter a body longer than " + str(MIN_BODY_LENGTH) +
                    " characters."
                })

            blog_post = BlogPost(
                author=self.validated_data['author'],
                title=title,
                body=body,
                image=image,
            )

            url = os.path.join(settings.TEMP, str(image))
            storage = FileSystemStorage(location=url)

            with storage.open('', 'wb+') as destination:
                for chunk in image.chunks():
                    destination.write(chunk)
                destination.close()

            if sys.getsizeof(image.file) > IMAGE_SIZE_MAX_BYTES:
                os.remove(url)
                raise serializers.ValidationError({
                    "response":
                    "That image is too large. Images must be less than 2 MB. Try a different image."
                })

            img = cv2.imread(url)
            dimensions = img.shape  # gives: (height, width, ?)

            aspect_ratio = dimensions[1] / dimensions[0]  # divide w / h
            if aspect_ratio < 1:
                os.remove(url)
                raise serializers.ValidationError({
                    "response":
                    "Image height must not exceed image width. Try a different image."
                })

            os.remove(url)
            blog_post.save()
            return blog_post
        except KeyError:
            raise serializers.ValidationError({
                "response":
                "You must have a title, some content, and an image."
            })
예제 #45
0
def test_get_files(yarn_dir):
    storage = FileSystemStorage(location=str(yarn_dir))
    files = get_files(storage, match_patterns='*')
    assert any([True for _ in files])
예제 #46
0
import uuid
from django.db import models
from django.contrib.postgres.fields import JSONField
from django.core.files.storage import FileSystemStorage

# Create your models here.

FS = FileSystemStorage(location='')


class EventBasic(models.Model):
    uiqueidEVENTS = models.UUIDField(default=uuid.uuid4,
                                     editable=False,
                                     primary_key=True)
    title = models.CharField(max_length=50)
    startDate = models.DateField(max_length=10)
    endDate = models.DateField(max_length=10)
    registrationDeadline = models.DateField(max_length=10)
    description = models.TextField(max_length=500)
    banner = models.ImageField(storage=FS)
    audienceType = JSONField()
    venue = JSONField()
    venueCoordinate = JSONField()
    region = JSONField()
    maxAudience = JSONField()
    cuurency = JSONField()
    regisTrationFee = models.FloatField(max_length=10)

    def __str__(self):
        return self.title
예제 #47
0
    def post(self, request):

        severity_color = ""
        uploaded_poc_url = ""

        vuln_name = request.POST.get("vuln_name")
        severity = request.POST.get("vuln_severity")
        vuln_url = request.POST.get("vuln_instance")
        description = request.POST.get("vuln_description")
        solution = request.POST.get("vuln_solution")
        reference = request.POST.get("vuln_reference")
        scan_id = request.POST.get("scan_id")
        project_uu_id = request.POST.get("project_id")
        project_id = (ProjectDb.objects.filter(
            uu_id=project_uu_id).values("id").get()["id"])
        pentest_type = request.POST.get("pentest_type")
        poc = request.FILES.get("poc", False)
        poc_description = request.POST.get("poc_description")
        date_time = datetime.now()
        vuln_id = uuid.uuid4()

        fs = FileSystemStorage()
        if poc is not False:
            filename = fs.save(poc.name, poc)
            uploaded_poc_url = fs.url(filename)

        if severity == "High":
            severity_color = "danger"

        elif severity == "Medium":
            severity_color = "warning"

        elif severity == "Low":
            severity_color = "info"

        dump_data = PentestScanResultsDb(
            vuln_id=vuln_id,
            vuln_name=vuln_name,
            severity_color=severity_color,
            severity=severity,
            vuln_url=vuln_url,
            description=description,
            solution=solution,
            reference=reference,
            scan_id=scan_id,
            pentest_type=pentest_type,
            vuln_status="Open",
            project_id=project_id,
            Poc_Img=uploaded_poc_url,
            poc_description=poc_description,
        )
        dump_data.save()

        all_scan_data = PentestScanResultsDb.objects.filter(scan_id=scan_id)

        total_vuln = len(all_scan_data)
        total_high = len(all_scan_data.filter(severity="High"))
        total_medium = len(all_scan_data.filter(severity="Medium"))
        total_low = len(all_scan_data.filter(severity="Low"))

        PentestScanDb.objects.filter(scan_id=scan_id).update(
            date_time=date_time,
            total_vul=total_vuln,
            high_vul=total_high,
            medium_vul=total_medium,
            low_vul=total_low,
        )

        messages.success(request, "Pentest Vulnerability Created")

        return HttpResponseRedirect(reverse("pentest:list_scan"))
예제 #48
0
 def storage(self):
     return FileSystemStorage(location=self.chunks_dir)
예제 #49
0
class EmptyModel(models.Model):
    def __unicode__(self):
        return "Primary key = %s" % self.id


class EmptyModelAdmin(admin.ModelAdmin):
    def queryset(self, request):
        return super(EmptyModelAdmin, self).queryset(request).filter(pk__gt=1)


class OldSubscriberAdmin(admin.ModelAdmin):
    actions = None


temp_storage = FileSystemStorage(tempfile.mkdtemp())
UPLOAD_TO = os.path.join(temp_storage.location, 'test_upload')


class Gallery(models.Model):
    name = models.CharField(max_length=100)


class Picture(models.Model):
    name = models.CharField(max_length=100)
    image = models.FileField(storage=temp_storage, upload_to='test_upload')
    gallery = models.ForeignKey(Gallery, related_name="pictures")


class PictureInline(admin.TabularInline):
    model = Picture
예제 #50
0
파일: models.py 프로젝트: badrogger/vtattoo
    def popular():
        pass


class TattooManager(models.Manager):
    def new():
        pass

    def popular():
        pass


BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
TATTOO_IMG_PATH = os.path.join(MEDIA_ROOT, "tattooimg")
tattoofs = FileSystemStorage(TATTOO_IMG_PATH)


class Studio(models.Model):
    objects = StudioManager()
    name = models.CharField(default="", max_length=255)
    rating = models.IntegerField(default=0)
    lat = models.FloatField(default=0)
    lng = models.FloatField(default=0)
    temporary_price = models.FloatField(default=-1)
    colored_price = models.FloatField(default=-1)
    temp_col_price = models.FloatField(default=-1)
    regular_price = models.FloatField(default=10)


class Tattoo(models.Model):
예제 #51
0
def development_tracker_response(request):
    if request.method == "POST" and len(request.FILES) != 0:
        if request.FILES['file1']:
            myfile = request.FILES['file1']
            fs = FileSystemStorage()
            if fs.exists(request.user.username + "1.png"):
                fs.delete(request.user.username + "1.png")
            filename = fs.save(request.user.username + "1.png", myfile)
            uploaded_file_url = fs.url(filename)

            if myfile.name[len(myfile.name) - 3:len(myfile.name)] != "png":
                return render(request, 'label/qgis_support_app.html',
                              {'is_not_file_valid': True})

        if request.FILES['file2']:
            myfile = request.FILES['file2']
            fs = FileSystemStorage()
            if fs.exists(request.user.username + "2.png"):
                fs.delete(request.user.username + "2.png")
            filename = fs.save(request.user.username + "2.png", myfile)
            uploaded_file_url = fs.url(filename)

            if myfile.name[len(myfile.name) - 3:len(myfile.name)] != "png":
                return render(request, 'label/development_tracker_app.html',
                              {'is_not_file_valid': True})

            if (request.POST.get('type') == "road"):
                ps.save_image(
                    Unet_model_Road, graph_road,
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "1.png"),
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "1_mask.png"))
                ps.save_image(
                    Unet_model_Road, graph_road,
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "2.png"),
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "2_mask.png"))
                difference = ps.difference_analyzier(
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "1_mask.png"),
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "2_mask.png"))

            if (request.POST.get('type') == "building"):
                ps.save_image(
                    Unet_model_Building, graph_building,
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "1.png"),
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "1_mask.png"))
                ps.save_image(
                    Unet_model_Building, graph_building,
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "2.png"),
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "2_mask.png"))
                difference = ps.difference_analyzier(
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "1_mask.png"),
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "2_mask.png"))

            if (request.POST.get('type') == "car"):
                ps.save_image(
                    Unet_model_Car, graph_car,
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "1.png"),
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "1_mask.png"))
                ps.save_image(
                    Unet_model_Car, graph_car,
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "2.png"),
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "2_mask.png"))
                difference = ps.difference_analyzier(
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "1_mask.png"),
                    os.path.join(settings.MEDIA_ROOT,
                                 request.user.username + "2_mask.png"))

            return render(
                request, "label/development_tracker_response.html", {
                    'image_url1':
                    "/media/" + request.user.username + "1_mask.png",
                    'image_url2':
                    "/media/" + request.user.username + "2_mask.png",
                    'difference': difference
                })
    return redirect(request.META.get('HTTP_REFERER'))
예제 #52
0
def home(request):
    if request.user.is_authenticated:
        if request.method == 'POST' and request.FILES.get('sourcefile', False):
            time_stamp = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
            source_file = request.FILES['sourcefile']
            fs = FileSystemStorage()
            filename = fs.save(source_file.name, source_file)
            uploaded_file_url = fs.url(filename)
            filepath = os.path.join(settings.MEDIA_ROOT, filename)

            img = Image.open(filepath)
            img_width = img.size[0]
            img_height = img.size[1]

            (img_ldpi, img_mdpi, img_hdpi, img_xhdpi, img_xxhdpi,
             img_xxxhdpi) = get_images(img, img_width, img_height)

            (zip_ldpi, zip_mdpi, zip_hdpi, zip_xhdpi, zip_xxhdpi,
             zip_xxxhdpi) = get_folder_names()

            main_save_path = os.path.join(settings.MEDIA_ROOT, time_stamp)
            ldpi_save_path = os.path.join(main_save_path, zip_ldpi)
            mdpi_save_path = os.path.join(main_save_path, zip_mdpi)
            hdpi_save_path = os.path.join(main_save_path, zip_hdpi)
            xhdpi_save_path = os.path.join(main_save_path, zip_xhdpi)
            xxhdpi_save_path = os.path.join(main_save_path, zip_xxhdpi)
            xxxhdpi_save_path = os.path.join(main_save_path, zip_xxxhdpi)

            os.makedirs(ldpi_save_path, exist_ok=True)
            os.makedirs(mdpi_save_path, exist_ok=True)
            os.makedirs(hdpi_save_path, exist_ok=True)
            os.makedirs(xhdpi_save_path, exist_ok=True)
            os.makedirs(xxhdpi_save_path, exist_ok=True)
            os.makedirs(xxxhdpi_save_path, exist_ok=True)

            img_ldpi.save(os.path.join(ldpi_save_path, filename))
            img_mdpi.save(os.path.join(mdpi_save_path, filename))
            img_hdpi.save(os.path.join(hdpi_save_path, filename))
            img_xhdpi.save(os.path.join(xhdpi_save_path, filename))
            img_xxhdpi.save(os.path.join(xxhdpi_save_path, filename))
            img_xxxhdpi.save(os.path.join(xxxhdpi_save_path, filename))

            s = io.BytesIO()
            zf = zipfile.ZipFile(s, 'w')
            zf.write(
                os.path.join(ldpi_save_path, filename),
                os.path.join(os.path.join(ZIP_MAIN_NAME, zip_ldpi), filename))
            zf.write(
                os.path.join(mdpi_save_path, filename),
                os.path.join(os.path.join(ZIP_MAIN_NAME, zip_mdpi), filename))
            zf.write(
                os.path.join(hdpi_save_path, filename),
                os.path.join(os.path.join(ZIP_MAIN_NAME, zip_hdpi), filename))
            zf.write(
                os.path.join(xhdpi_save_path, filename),
                os.path.join(os.path.join(ZIP_MAIN_NAME, zip_xhdpi), filename))
            zf.write(
                os.path.join(xxhdpi_save_path, filename),
                os.path.join(os.path.join(ZIP_MAIN_NAME, zip_xxhdpi),
                             filename))
            zf.write(
                os.path.join(xxxhdpi_save_path, filename),
                os.path.join(os.path.join(ZIP_MAIN_NAME, zip_xxxhdpi),
                             filename))
            zf.close()

            shutil.rmtree(main_save_path)

            resp = HttpResponse(s.getvalue(),
                                content_type="application/x-zip-compressed")
            resp[
                'Content-Disposition'] = 'attachment; filename=%s' % ZIP_FILENAME

            return resp
        return render(request, 'home.html')
    return render(request, 'home.html')
예제 #53
0
def store_image(image):
    fs = FileSystemStorage()
    file = fs.save(image.name, image)
    file_url = fs.url(file)
    return file_url
def index(request):

    if (request.method == 'POST' and request.FILES['resume']):

        resume = request.FILES['resume']
        # print('resume',type(resume),resume.name)
        file_Storage = FileSystemStorage()
        file_Name = file_Storage.save(resume.name, resume)
        uploaded_file_url = file_Storage.url(file_Name)
        # print(uploaded_file_url,type(resume),resume.name)
        if ('.pdf' in str(resume)):
            # print('It is a pdf')

            email_address_pdf = extract_email_addresses_pdf(resume)
            # print('email_address_from_pdf',email_address_pdf)
            name_pdf = extract_name_pdf(resume)
            # print('primary name possibilities',name_pdf[0])
            # print('secondary name possibilities',name_pdf[1])
            phone_numbers_pdf = extract_phone_numbers_pdf(resume)
            print(phone_numbers_pdf.replace('-', ''), 'contact no.')
            # print('linkedin url',name_pdf[2])
            #extract_num_lines_pdf(resume)
            text_char_count_pdf = extract_text_characters_count(resume)
            # print('text_char_count_pdf',text_char_count_pdf)
            font_font_size = extract_font_font_size_pdf(resume)
            # print('font_font_size_pdf',font_font_size)
            table_image_count = extract_table_image_count_pdf(resume)
            # print(table_image_count)
            response = HttpResponse(content_type='text/csv')
            response[
                'Content-Disposition'] = 'attachment;filename="resume_details.csv"'

            writer = csv.writer(response)
            writer.writerow([
                'First row', 'Primary possibilities for name',
                'Secondary possibilities for name', 'Email Address',
                'Phone Number', 'LinkedIn Link',
                'Number of text characters per page', 'Font details',
                'Number of tables', 'Number of images'
            ])
            writer.writerow([
                'Second row', name_pdf[0], name_pdf[1], email_address_pdf,
                'Phone number: ' + phone_numbers_pdf.replace('-', ''),
                name_pdf[2], text_char_count_pdf, font_font_size,
                table_image_count[0], table_image_count[1]
            ])
            return response
        elif ('.docx' in str(resume)):
            # print('It is a doc')
            doc = docx.Document(resume)
            celltext = ''
            rowsum = 0
            for table in doc.tables:
                for row in table.rows:
                    rowsum += 1
                    for cell in row.cells:
                        celltext += cell.text
            num_lines_doc = 0
            num_lines_doc = document_num_lines(resume, celltext)
            num_lines_doc += rowsum
            # print('number of lines in word document',num_lines_doc)
            phone_number_doc = extract_phone_numbers_doc(resume, celltext)
            phone_number_final = ''
            if (len(phone_number_doc[0]) > 0):

                phone_number_final = 'Phone number' + phone_number_doc[0]
            else:
                phone_number_final = 'Phone number' + phone_number_doc[1]
            # print('phone_number_doc',phone_number_final.replace('-',''))

            email_address_doc = extract_email_addresses_docs(resume, celltext)
            # print('linkedin',email_address_doc[1])
            email_address_final = email_address_doc[0]

            # print('email_address_docs',email_address_final)
            name_doc = extract_name(resume, celltext)
            name_doc_final = []
            for i in range(len(name_doc)):
                if (len(name_doc[1]) > 0):
                    name_doc_final.append(name_doc[1])
                elif (len(name_doc[0]) > 0 or len(name_doc[2]) > 0):
                    if (name_doc[0] not in name_doc_final):
                        name_doc_final.append(name_doc[0])
                    if (name_doc[2] not in name_doc_final):
                        name_doc_final.append(name_doc[2])
            final_name = set(name_doc_final)
            # print('name_Doc',final_name)

            font_doc = font_type_and_font_size_extraction_doc(resume, celltext)
            # print(font_doc)
            table_count_doc, image_count_doc = extract_table_image_count(
                resume, celltext)
            # print('table count_doc,image count_doc respectively',table_count_doc,image_count_doc)
            response = HttpResponse(content_type='text/csv')
            response[
                'Content-Disposition'] = 'attachment;filename="resume_details.csv"'

            writer = csv.writer(response)
            writer.writerow([
                'Primary possibilities for name',
                'Secondary possibilities for name', 'Email Address',
                'Phone Number', 'LinkedIn Link', 'Number of text lines',
                'Font details', 'Number of tables', 'Number of images'
            ])
            writer.writerow([
                final_name, final_name, email_address_final,
                phone_number_final.replace('-', ''), email_address_doc[1],
                num_lines_doc, font_doc, table_count_doc, image_count_doc
            ])

            return response

    return render(request, 'resume_reader_app/index.html')
예제 #55
0
def view_name(request):
    file_name = ""
    file_numberOfSections = ""
    file_DllChar = ""
    dll_types = []
    dll_dict = {}
    file_ImageVersion = ""
    compileTimeInHex = ""
    compileTime = ""
    dt_object = ""
    virtual_memory = 0
    physical_memory = 0
    fileSize = ""
    severity = ""
    section_count = ""
    version = ""
    numberOfDll = 0
    dict_func = ""
    virtualMem = 0
    physicalMem = 0
    # LOGGIN DEBUG
    # logger.info(file_path)
    logger = logging.getLogger('testlogger')
    # micosoft_func == a list of dataframes
    # a temporary solution for categorizing
    microsoft_func = pd.read_html(
        'https://docs.microsoft.com/en-us/windows/win32/api/_security/#functions'
    )
    SnI_df = microsoft_func[1]

    # CSV download
    # https://docs.djangoproject.com/en/3.1/howto/outputting-csv/
    # For some reason, I can't use the bottom comment
    # if requst.method == 'POST' and 'CSV' in request.POST:
    if request.method == 'POST' and "myfile" not in request.FILES:
        response = HttpResponse(content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename="report.csv"'
        writer = csv.writer(response)

        # Insert features here for file
        # writer.writerow(["first row", "some", "value"])
        # writer.writerow(["second row", "some", "value"])

        # read data from txt file and write to csv file
        with open("temp.txt", "r") as reader:
            line = reader.readline()
            while line != '':
                params = line.split("$")
                logger.info(params[0] + "---" + params[1])
                x = params[0]
                y = "some"
                z = params[1]
                writer.writerow([x, y, z])
                line = reader.readline()

        return response

    elif request.method == 'POST' and 'myfile' in request.FILES:

        # open temp.txt and erase temp data
        file = open("temp.txt", "r+")
        file.truncate(0)
        file.close()

        file = request.FILES['myfile']
        fs = FileSystemStorage()
        file_save = fs.save(file.name, file)

        # comment out this code below to enable storing file in firebase storage
        # storage.child("files/" + file.name).put("media/" + file.name)
        fileSize = str(file.size)
        print("Uploaded file name: " + file.name)
        print("Uploaded file size: " + fileSize)

        # Test pefile
        file_name = file.name
        file_path = os.path.join(BASE_DIR, 'media/' + file.name)
        putty = pefile.PE(file_path)

        # FILE_HEADER
        machine = putty.FILE_HEADER.Machine
        timeDateStamp = putty.FILE_HEADER.TimeDateStamp
        section_count = putty.FILE_HEADER.NumberOfSections
        characteristic = putty.FILE_HEADER.Characteristics

        # OPTIONAL_HEADER
        magic = putty.OPTIONAL_HEADER.Magic
        dll = putty.OPTIONAL_HEADER.DllCharacteristics
        version = putty.OPTIONAL_HEADER.MajorImageVersion
        addressOfEntry = putty.OPTIONAL_HEADER.Magic
        severity = "HIGH"

        for entry in putty.DIRECTORY_ENTRY_IMPORT:
            dll_types.append(entry.dll.decode('utf-8'))
        dll_dict['dll_types'] = dll_types

        ##------------------- All possible value needed to return to homepage ------------------##
        numberOfDll = getNumberOfDllUsed(dll_dict['dll_types'])

        ##------------------- Get info from sections in exe file ------------------##
        virtualMem, physicalMem = getVirtualSize(file_path)

        # ------- Get Compile Time -----------
        compileTimeInHex = getTimeDateStamp(file_path)
        # convert hex to decimal string
        compileTimeInDec = int(compileTimeInHex, 16)
        logger.info(compileTimeInDec)
        compileTime = datetime.fromtimestamp(compileTimeInDec).strftime(
            '%Y-%m-%d %H:%M:%S')
        logger.info(compileTime)
        # -------- Function Collecting ----------
        # returns a dictionary of dlls as keys with values being a list of functions called with their category.
        # Ex. 'Kernal.DLL': [(function_Names, Category)]
        # def func_collect is near the top
        dict_func = func_collect(file_path, SnI_df)
        # pprint.pprint(dict_func)

        ##### ---------------- store all data in temp text file to export to csv file -------- #########
        file1 = open("temp.txt", "a")
        L = [
            "File_name$" + file_name + "\n",
            "Number of Sections$" + str(section_count) + "\n",
            "CompileTimeInHex$" + str(compileTimeInHex) + "\n",
            "CompileTime$" + compileTime + "\n",
            "virtual _memory$" + str(virtual_memory) + "\n",
            "physical_memory$" + str(physical_memory) + "\n",
            "file_size$" + str(fileSize) + "\n",
            "severity$" + severity + "\n",
            "file_version$" + str(version) + "\n",
            'NumberOfDlls$' + str(numberOfDll) + "\n",
        ]
        # \n is placed to indicate EOL (End of Line)
        file1.writelines(L)
        file1.close()
        ##### ----------------end-------- #########

        # messages.success(request, "File upload in Firebase Storage successful")
    # return render(request, "fileUpload/home.html",{"FileName":file_name,"NumberOfSection":file_numberOfSections,"DllChar":file_DllChar,"ImageVersion":file_ImageVersion})

    return render(
        request, "fileUpload/home.html", {
            "CompileTimeInHex": compileTimeInHex,
            "CompileTime": compileTime,
            "FileName": file_name,
            "virtual_memory": virtual_memory,
            "physical_memory": physical_memory,
            "file_size": fileSize,
            "severity": severity,
            "file_section_count": section_count,
            "file_version": version,
            'NumberOfDlls': numberOfDll,
            'FunctionCalls': dict_func,
            'VirtualMem': virtualMem,
            'PhysicalMem': physicalMem
        })
예제 #56
0
        "contact": "*****@*****.**"
    })

DEFAULT_BADGE_IMAGE = getattr(
    settings, 'BADGER_DEFAULT_BADGE_IMAGE',
    "%s/fixtures/default-badge.png" % dirname(__file__))

# Set up a file system for badge uploads that can be kept separate from the
# rest of /media if necessary. Lots of hackery to ensure sensible defaults.
UPLOADS_ROOT = getattr(
    settings, 'BADGER_UPLOADS_ROOT',
    os.path.join(getattr(settings, 'MEDIA_ROOT', 'media/'), 'uploads'))
UPLOADS_URL = getattr(
    settings, 'BADGER_UPLOADS_URL',
    urljoin(getattr(settings, 'MEDIA_URL', '/media/'), 'uploads/'))
BADGE_UPLOADS_FS = FileSystemStorage(location=UPLOADS_ROOT,
                                     base_url=UPLOADS_URL)

TIME_ZONE_OFFSET = getattr(settings, "TIME_ZONE_OFFSET", timedelta(0))


class TZOffset(tzinfo):
    """TZOffset"""
    def __init__(self, offset):
        self.offset = offset

    def utcoffset(self, dt):
        return self.offset

    def tzname(self, dt):
        return settings.TIME_ZONE
예제 #57
0
def submit_file_content(request):
    the_file = request.FILES['file']  # error throws up here.
    fs = FileSystemStorage()
    filename = fs.save(the_file.name, the_file)
    uploaded_file_url = fs.url(filename)
    return HttpResponse(uploaded_file_url)
예제 #58
0
    from intrinsic.evaluation import evaluate_decomposition
    for decomposition_id in decomposition_ids:
        update_kwargs = evaluate_decomposition(
            decomposition_id,
            delete_failed_open=delete_failed_open,
            **evaluate_kwargs)

        IntrinsicImagesDecomposition.objects \
            .filter(id=decomposition_id) \
            .update(**update_kwargs)


from django.core.files.storage import FileSystemStorage
INTRINSIC_STORAGE = FileSystemStorage(
    location=settings.MEDIA_ROOT,
    base_url=settings.MEDIA_URL,
)


@shared_task
def upload_intrinsic_file(name):
    from django.core.files.base import ContentFile
    from django.core.files.storage import default_storage
    default_storage.save(name,
                         ContentFile(INTRINSIC_STORAGE.open(name).read()))
    INTRINSIC_STORAGE.delete(name)


@shared_task
def export_dataset_photo_task(photo_id, out_dir):
    photo = Photo.objects.filter(id=photo_id).select_related(
예제 #59
0
def update_doctor(request, Docid):
    if request.method == 'POST':
        usr = user.objects.filter(user_id=Docid)
        # upload profile,ssn pictures and save paths to database
        fs = FileSystemStorage()
        if 'Profile_picture' in request.FILES:
            profile_picture_file = request.FILES['Profile_picture']
            ppf_name = fs.save(profile_picture_file.name, profile_picture_file)
            Pro_pic = '/hospital' + fs.url(ppf_name)
            usr.update(Profile_picture=Pro_pic)
        if 'SSN_Picture' in request.FILES:
            ssn_picture_file = request.FILES['SSN_Picture']
            spf_name = fs.save(ssn_picture_file.name, ssn_picture_file)
            SSN_Pic = '/hospital' + fs.url(spf_name)
            usr.update(SSN_Picture=SSN_Pic)
        usr.update(first_name=request.POST['first_name'])
        usr.update(middle_name=request.POST['middle_name'])
        usr.update(last_name=request.POST['last_name'])
        usr.update(country=request.POST['country'])
        usr.update(state=request.POST['state'])
        usr.update(city=request.POST['city'])
        usr.update(street=request.POST['street'])
        usr.update(zip_code=request.POST['zip_code'])
        usr.update(phone_number=request.POST['phone_number'])
        usr.update(home_phone_number=request.POST['home_phone_number'])
        usr.update(work_phone_number=request.POST['work_phone_number'])
        usr.update(Date_of_birth=request.POST['Date_of_birth'])
        usr.update(Child_num=request.POST['Child_num'])
        usr.update(email_1=request.POST['email_1'])
        usr.update(email_2=request.POST['email_2'])
        usr.update(Nationality=request.POST['Nationality'])
        usr.update(Jop_place=request.POST['Jop_place'])
        usr.update(Job_name=request.POST['Job_name'])
        usr.update(Job_organization=request.POST['Job_organization'])
        usr.update(Ssn=request.POST['Ssn'])
        ssn = request.POST['Ssn']
        ssn_id = ssn[7:14]
        usr.update(Ssn_id=ssn_id)
        genderMessage = gender(request.POST['gender'])
        maritalStatusMessage = maritalStatus(request.POST['marital_status'])
        if genderMessage == 'error':
            return HttpResponseRedirect('/hospital/updateHospitalDoctor/')
        elif maritalStatusMessage == 'error':
            return HttpResponseRedirect('/hospital/updateHospitalDoctor/')
        else:
            usr.update(gender=genderMessage)
            usr.update(marital_status=maritalStatusMessage)
        usr.update(User_type=2)
        #########################################################
        # form 2
        doct = doctor.objects.filter(Doc_id=Docid)
        doct.update(Registration_num=request.POST['Registration_num'])
        doct.update(Specialization=request.POST['Specialization'])
        doct.update(Registration_date=request.POST['Registration_date'])
        doct.update(licence=request.POST['licence'])
        doct.update(Last_date_payment=request.POST['Last_date_payment'])
        doct.update(End_date=request.POST['End_date'])
        doct.update(Specialization_type=request.POST['Specialization_type'])
        doct.update(University=request.POST['University'])
        doct.update(Work_place=request.POST['Work_place'])
        doct.update(Sub_syndicate=request.POST['Sub_syndicate'])
        doct.update(General_secretary=request.POST['General_secretary'])
        doct.update(Working_till=request.POST['Working_till'])
        doct.update(Graduation_year=request.POST['Graduation_year'])
        ########################################################
        return HttpResponseRedirect('/hospital/Index/')
    else:
        hospitaldata = hospital.objects.get(
            h_id=request.session['hospital_id'])
        doctorData = doctor.objects.get(Doc_id=Docid)
        userData = user.objects.get(user_id=Docid)
        context = {
            'hospital': hospitaldata,
            'hos_id': hospitaldata.h_id,
            'doctorData': doctorData,
            'userData': userData,
        }
        return render(request, 'updateHospitalDoctor.html', context)
예제 #60
0
        was opened.
        """
        def __init__(self, *args, **kwargs):
            self.was_opened = False
            super().__init__(*args, **kwargs)

        def open(self):
            self.was_opened = True
            super().open()

    class TestImageField(ImageField):
        attr_class = TestImageFieldFile

    # Set up a temp directory for file storage.
    temp_storage_dir = tempfile.mkdtemp()
    temp_storage = FileSystemStorage(temp_storage_dir)
    temp_upload_to_dir = os.path.join(temp_storage.location, 'tests')

    class Person(models.Model):
        """
        Model that defines an ImageField with no dimension fields.
        """
        name = models.CharField(max_length=50)
        mugshot = TestImageField(storage=temp_storage, upload_to='tests')

    class AbstractPersonWithHeight(models.Model):
        """
        Abstract model that defines an ImageField with only one dimension field
        to make sure the dimension update is correctly run on concrete subclass
        instance post-initialization.
        """