Python werkzeug.secure_filename函数代码示例

def upload():
    if request.method == 'POST':
        #Get the file
        audiofile = request.files['audio']
        fname = 'tmp/' + str(long(time.time())) + secure_filename(audiofile.filename)
        audiofile.save(fname)

        remixfile = audio.LocalAudioFile(fname)
        beats = remixfile.analysis.beats

        #https://github.com/echonest/remix/blob/master/examples/sorting/sorting.py
        def sorting_function(chunk):
            return chunk.mean_loudness()

        sortedbeats = sorted(beats, key=sorting_function)

        out = audio.getpieces(remixfile, sortedbeats)

        audioname = str(long(time.time())) + 'sorted' + secure_filename(audiofile.filename) + '.mp3'
        outfname = 'tmp/' + audioname
        out.encode(outfname, mp3=True)

        #Upload to rackspace
        chksum = pyrax.utils.get_checksum(outfname)
        cf.upload_file("beatsorter", outfname, etag=chksum)

        #os.remove(fname)
        #os.remove(outfname)
        return redirect(url_for('getaudiofile', filename=audioname))

def upload():
    error = None
    #This tells where the 'images' and 'documents' folders are located
    imupfol = os.listdir(app.config['UPLOAD_FOLDER'] + '/images/')
    docupfol = os.listdir(app.config['UPLOAD_FOLDER'] + '/documents/')
    if request.method == 'POST':
        # The File That is Being Uploaded
        file = request.files['file']
        #The name of the file being uploaded (to be used later)
        name = request.form['name']
        category = request.form['category']
        #This makes sure is's a legit file and it has a name
        if file and name !="" and category !="":
            # This checks to see if the uploaded file was an image
            if check_file(file.filename) == "image":
                filename = fileRename(secure_filename(file.filename), imupfol, name)
                addToDb(filename, name, category, "images")
                file.save(os.path.join(app.config['UPLOAD_FOLDER'], "images", filename))
            # This checks to see if the uploaded file was a document
            elif check_file(file.filename) == "document":
                filename = fileRename(secure_filename(file.filename), docupfol, name)
                addToDb(filename, name, category, "documents")
                file.save(os.path.join(app.config['UPLOAD_FOLDER'], "documents", filename))
            else:
                #This error is thrown if for whatever reason it is neither an image nor a document
                error = "Unacceptable File Type"
        else:
            #This error is thrown when the file isn't good or there is no name given for the file
            error = "Please Fill In All of the Required Info"
    #This is around the 'return' function because the webpage requires a connection to the database
    with sqlite3.connect("database.db") as con:
        return render_template('upload.html', error=error)
        con.close()

def upload_models():
    """
    Uploads the user's robot and environment files and saves them to the
    server. The URL to these files are then returned for use by ColladaLoader
    to visualize.
    """

    robot = flask.request.files['robot']
    env = flask.request.files['env']

    session_id = flask.request.form['session_id']
    session_dir = join(ompl_sessions_dir, session_id)

    file_locs = {}

    # Check that the uploaded files are valid
    if robot and env:
        if allowed_file(robot.filename) and allowed_file(env.filename):

            # If valid files, save them to the server
            robot_file = join(session_dir, secure_filename(robot.filename))
            robot.save(robot_file)
            file_locs['robot_loc'] = join("static/sessions", session_id, basename(robot_file))

            env_file = join(session_dir, secure_filename(env.filename))
            env.save(env_file)
            file_locs['env_loc'] = join("static/sessions", session_id, basename(env_file))

        else:
            return "Error: Wrong file format. Robot and environment files must be .dae"
    else:
        return "Error: Didn't upload any files! Please choose both a robot and environment file in the .dae format."

    return json.dumps(file_locs)

    def add(cls, d):
        """
        Create a Post object and adds the object to the database from a 
        dictionary with keys matching the SQL schema.

        :raises ValueError: if this ID is already in use
        """

        if cls.get(d['id']) is not None:
            raise ValueError('Post ID already in use')
        
        # save uploaded image files
        if type(d['thumbnail']) is not unicode and allowed_file(d['thumbnail'].filename):
            ext = d['thumbnail'].filename.split('.')[-1]
            filename = secure_filename(d['id'] + '_thumbnail.' + ext)
            d['thumbnail'].save(path.join(UPLOAD_FOLDER, filename))
            d['thumbnail'] = filename

        if type(d['image']) is not unicode and allowed_file(d['image'].filename):
            ext = d['image'].filename.split('.')[-1]
            filename = secure_filename(d['id'] + '_main.' + ext)
            d['image'].save(path.join(UPLOAD_FOLDER, filename))
            d['image'] = filename

        columns = '(`' + '`, `'.join(d.keys()) + '`)'
        values  = '(' + ', '.join([ '%s' for val in d.values() ]) + ')'
        
        cur = g.db.cursor()
        query = 'INSERT INTO posts ' + columns + ' VALUES ' + values
        cur.execute(query, d.values())
        g.db.commit()

        return cls.get(d['id'])

 def make_file(self, foldername, filename, challenge_id, file_contents):
     try:
         created = False
         fi = self.app.config['SERVER_ROOT']+'sand/'+str(challenge_id)+'/base/'+foldername
         if fi[-1]=='/':
             fi=fi[:-1]
         if(not path.normpath(fi) == fi and foldername != ''):
             return('Stop hacking me! ahum, I mean. There was an error making that file')
         if(not secure_filename(filename) == filename and not '.'+secure_filename(filename) == filename):
             return('Stop hacking me! ahum, I mean. There was an error making that file')
         if( path.exists( path.normpath(fi)+'/'+filename )):
             return('The file already exists')
         if(foldername != '' and not path.exists(fi)):
             mkdir(fi)
             created = True
         fi = path.normpath(fi)+'/'+filename
         if(filename != '' and not path.exists( fi ) ):
             open(fi,'w',encoding='utf-8').close()
             file_contents.save(fi)
             created = True
         if created:
             chmod(fi, S.S_IRWXU | S.S_IRWXG | S.S_IRWXO)
             return('The file has been made')
     except Exception, e:
         self.app.logger.warning('make_file '+str(e))
         return('There was an error making that file')        

def handleUpload(f, js=True):
    """ Handles the main file upload behavior. """
    value = ""
    if secure_filename(f.filename):
        # get variables
        dirname, extension = getDirnameExtension(f)
        sfilename = secure_filename(f.filename)
        # do the file saving
        if not os.path.exists("static/files/%s" % dirname):
            # if it it's not there, make the directory and save the file
            os.mkdir('static/files/%s' % dirname)
            f.save('static/files/%s/%s' % (dirname, sfilename))
            print('Uploaded file "%s" to %s' % (sfilename, dirname))

            # value is used with /js route, otherwise it's ignored
            url = url_for('getFile', dirname=dirname)
            value = 'success:' + url + ':' + dirname
            # if not js, then flash
            # used to prevent flashes from showing up upon refresh
            if not js:
                message = 'Uploaded file %s to <a href="%s">%s</a>'
                flash(Markup(message) % (sfilename, url, dirname))
        else:
            url = url_for('getFile', dirname=dirname)
            value = 'exists:' + url + ':' + dirname
            if not js:
                message = 'File %s already exists at <a href="%s">%s</a>'
                flash(Markup(message) % (sfilename, url, dirname))
    else:
        value = 'error:filenameinvalid'
        if not js:
            flash('Invalid filename.', url_for('getIndex'))
    return value

def register_user(user_data):
    """Registers a user in the database, returns False and flashes an error if an error occurs"""
    disallowed_characters = [" ", "/", "'"]
    if username_exists(user_data[0]):
        flash("That username is already taken!")
    if user_data[1] != user_data[2]:
        flash("Your passwords don't match!")
    if not user_data[2] or not user_data[1]:
        flash("You didn't enter a password")
    if any(c in disallowed_characters for c in user_data[0]):
        flash("The following characters are disallowed in your username (spaces,/,')")
    if not (user_data[3] and user_data[4]):
        flash("It looks like you didn't enter your name or age")
    else:
        db = get_db()
        db.execute("INSERT INTO user_data\
                    (password,username,name,age,bio)\
                     VALUES (?,?,?,?,?)", [generate_password_hash(user_data[1]),
                                           werkzeug.secure_filename(user_data[0]),
                                           user_data[3],
                                           user_data[4],
                                           user_data[5]])
        db.commit()
        os.mkdir(os.path.join('static/uploads', werkzeug.secure_filename(user_data[0])))
        return True
    return False

def addAssignment():
    assignmentName = request.form['assignmentName']
    try:
        input_file = request.files['input_file']
    except Exception as e:
        message.append("The following errors occurred:\n")
        message.append("- input file error")
        print e
    comp_file = None
    try:
        comp_file = request.files['comp_file']
    except Exception as e:
        if len(message) == 0:
            message.append("The following errors occurred:\n")
        message.append("- comp file error")
    
    if input_file and comp_file and len(assignmentName) > 0 and allowed_input_file(input_file.filename) and allowed_comp_file(comp_file.filename):
        conn = connectToDB()
        cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
        insert_assignment_query = "INSERT INTO assignments VALUES (default, %s, %s) RETURNING id"
        cur.execute(insert_assignment_query, (assignmentName , session['id'] ))
        assignmentId = cur.fetchone()[0]
    
        filename = secure_filename(input_file.filename)
        the_input_file_path = os.path.join(app.config['INPUT_FOLDER'], filename)
        input_file.save(the_input_file_path)
        filename = secure_filename(comp_file.filename)
        the_comp_file_path = os.path.join(app.config['COMPARISON_FOLDER'], filename)
        comp_file.save(the_comp_file_path)        
        
        insert_comp_file_query = "INSERT INTO test_cases VALUES (default, %s, %s, %s)"
        cur.execute(insert_comp_file_query, (the_input_file_path,the_comp_file_path, assignmentId))
            
        conn.commit()
    return redirect(url_for('admin_panel')) 

def upload():
    form = UploadForm()
    if form.validate_on_submit():
        _uuid = str(uuid.uuid4())
        dirpath = osp.abspath(osp.join(app.config['TEMP_FOLDER'], _uuid))
        app.logger.debug(dirpath)
        os.makedirs(dirpath, exist_ok=True)

        parsed_results = request.files['parsed_results']
        parsed_results_file = osp.join(dirpath,
                                       secure_filename(parsed_results.filename))
        parsed_results.save(parsed_results_file)

        pkg_src_archive = request.files['pkg_src_archive']
        pkg_src_archive_file = osp.join(dirpath,
                                        secure_filename(pkg_src_archive.filename))
        pkg_src_archive.save(pkg_src_archive_file)

        try:
            _id = db_util.store_in_db(parsed_results_file,
                                      pkg_src_archive_file,
                                      {'package-short-name': form.pkg_short_name.data,
                                       'package-version': form.pkg_version.data,
                                       'platform': form.platform.data,
                                       'assessment-date': datetime.datetime.today()})
            return render_template('results.html', report_id=_id)

        except Exception as err:
            app.logger.debug(err)
            return abort(400)
        else:
            return render_template('view.html')
    else:
        return render_template('upload.html', form=form)

def add_user():
    """
    Add or update user information
    """
    if request.method == 'POST':
        print('In Adduser post method')
        data = request.form
        pics=[]
        try:
            #save in database here, use userid when actually saving
            for name in request.files:
                    f = request.files[name]
                    filename = secure_filename(f.filename)
                    pics.append(filename)

            userid=data.get('userid',None)
            resp = AddUpdateUser(data['name'], data['dob'], data['email'], data['mentorfor'], \
            data['learn'], data['about'], str(pics), userid)
            #error, return message
            if resp == -1:
                print('In Adduser post method: returning -1')
                return json.dumps({'msg':'error', 'code':-1})
            #else return userid
            else:
                #del pics[:]
                print('In Adduser post method: returning 200')
                for name in request.files:
                    f = request.files[name]
                    filename = str(resp) + '_' + secure_filename(f.filename)
                    #pics.append("http://tushki1405.pythonanywhere.com/pics/" + filename)
                    f.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
                return json.dumps({'msg':'success', 'code':200, 'userid':resp, 'name':data['name']})
        except Exception as e:
            return json.dumps({'msg':str(e), 'code':-1})
    return 'add user'

def upload_file():
    if 'nickname' not in session:
        return json.dumps({'success': False})

    if 'encrypted_file' in request.files:
        file = request.files['encrypted_file']
        is_allowed_file_type = allowed_enc_file_type(file.filename)
    else:
        file = request.files['file']
        is_allowed_file_type = allowed_file_type(file.filename)

    path = request.form['path']

    if file and is_allowed_file_type:
        filename = secure_filename(file.filename)
        user_path = os.path.join(UPLOAD_DIR, secure_filename(session['nickname']))
        directory_path = os.path.join(user_path, path)
        if not is_path_safe_and_valid(directory_path, user_path):
            directory_path = user_path
        file.save(os.path.join(directory_path, filename))

        flash(u'Plik został pomyślnie zapisany.', 'success')

        response = {
            'success': True
        }
    else:
        response = {
            'success': False,
            'message': u'Plik posiada niedozwolone rozszerzenie.'
        }

    return json.dumps(response)

def home():
    msg1 = ""
    msg2 = ""
    if request.method == "POST":
        text = request.form['message']
        if text != "":
            messageFile = open("Message.txt","w+")
            messageFile.write(text)
            messageFile.close()
            file = request.files['musicfile']
            if file and allowed_file(file.filename):
                filename = secure_filename(file.filename)
                file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
                if filename.rsplit('.', 1)[1] == "wav":
                    os.system("./wavstego/wavstego -e 1234 -m Message.txt -a "+filename+" -o MixedTape.wav")
                else:
                    os.system("./mp3stego/mp3stego -b 320 -e Message.txt -p 1234 "+filename+" MixedTape.mp3")
                msg1 = "Success!"
            else:
                msg1 = "Error: Please enter a proper music file"
        else:
            file = request.files['encryptedfile']
            if file and allowed_file(file.filename):
                filename = secure_filename(file.filename)
                file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
                if filename.rsplit('.', 1)[1] == "wav":
                    os.system("./wavstego/wavstego -d 1234 -a MixedTape.wav")
                else:
                    os.system("./mp3stego/mp3stego -p 1234 MixedTape.mp3")
                msg2 = "Success!"
            else:
                msg2 = "Error: Please enter a proper music file"
    return render_template('index.html',message1 = msg1, message2 = msg2)

    def build_msg(self, recipient):
        try:
            current_app.logger.info(
                'EMAILTRY | Sending message:\nTo: {}\n:From: {}\nSubject: {}'.format(
                    recipient, self.from_email, self.subject
                )
            )

            msg = Message(
                subject='[Pittsburgh Purchasing] {}'.format(self.subject),
                html=self.html_body, body=self.txt_body,
                sender=self.from_email, reply_to=self.reply_to,
                recipients=self.handle_recipients(recipient), cc=self.cc_email
            )

            for attachment in self.attachments:
                if (
                    isinstance(attachment, FileStorage) and
                    secure_filename(attachment.filename) != ''
                ):
                        msg.attach(
                            filename=secure_filename(attachment.filename),
                            content_type=attachment.content_type,
                            data=attachment.stream.read()
                        )

            return msg

        except Exception, e:
            current_app.logger.info(
                'EMAILFAIL | Error: {}\nTo: {}\n:From: {}\nSubject: {}'.format(
                    e, self.to_email, self.from_email, self.subject
                )
            )
            return False

def project_new_version(id):

    form = NewProjectVersionForm(request.form)
    if request.method == 'POST' and form.validate():

        version_number_formatted_without_the_dot = request.form['version'].replace('.', '')

        project = Project.query.get(id)
        new_project_folder = os.path.join(app.config['UPLOAD_FOLDER'],
                                          str(id),
                                          'v{0}'.format(version_number_formatted_without_the_dot))
        os.makedirs(new_project_folder, exist_ok=True)

        excel_file = request.files['excel_file']
        excel_file_path = os.path.join(new_project_folder, secure_filename(excel_file.filename))
        excel_file.save(excel_file_path)

        template_file = request.files['template_file']
        template_file_path = os.path.join(new_project_folder, secure_filename(template_file.filename))
        template_file.save(template_file_path)

        versioning_data = {'to_fill': 0, 'filled': 0}
        for _file, _path in [('excel_file', excel_file.filename), ('template_file', template_file.filename)]:
            versioning_data[_file] = _path

        try:
            equipments, wb, hostnames = nsg_processing(excel_file_path, template_file_path)
        except:
            exit()
            #TODO: Add a return page that handles this error


        data_of_equipments = list()
        for equipment in equipments:
            equipment.save_script_as(new_project_folder, equipment.hostname)

            versioning_data['to_fill'] += equipment.get_nbr_of_var_to_fill_in()
            versioning_data['filled'] += equipment.get_resolved_var()

            _data_of_equipment = dict()
            for _item in ('Hostname', 'Equipment', 'Type'):
                _data_of_equipment[_item] = equipment.get_value_of_var(_item, wb)
            _data_of_equipment['filling_ratio'] = equipment.get_filling_ratio()
            _data_of_equipment['filling_ratio_in_percentage'] = equipment.get_filling_ratio_in_percentage()
            _data_of_equipment['tb'] = equipment.tb
            data_of_equipments.append(_data_of_equipment)

            with open(os.path.join(new_project_folder, 'data.pickle'), 'wb') as f:
                pickle.dump(data_of_equipments, f, 0)

        versioning_data['fillingRatio'] = '{:.0%}'.format(versioning_data['filled']/versioning_data['to_fill'])
        versioning_data['project_folder'] = new_project_folder
        versioning_data['description'] = request.form['description']
        versioning_data['version'] = request.form['version']
        session['versioning_data'] = versioning_data

        return render_template('project_upgrade_preview.html', id=project.id,
                               equipments=data_of_equipments, iterator=Integer(1))

    return redirect(url_for('project_display', project_id=id))

def upload_waptsetup():
    logger.debug("Entering upload_waptsetup")
    tmp_target = None
    try:
        if request.method == "POST":
            file = request.files["file"]
            if file and "waptsetup.exe" in file.filename:
                filename = secure_filename(file.filename)
                tmp_target = os.path.join(wapt_folder, secure_filename("." + filename))
                target = os.path.join(wapt_folder, secure_filename(filename))
                file.save(tmp_target)
                if not os.path.isfile(tmp_target):
                    result = dict(status="ERROR", message="Problem during upload")
                else:
                    os.rename(tmp_target, target)
                    result = dict(status="OK", message="%s uploaded" % (filename,))
            else:
                result = dict(status="ERROR", message="Wrong file name")
        else:
            result = dict(status="ERROR", message="Unsupported method")
    except:
        e = sys.exc_info()
        if tmp_target and os.path.isfile(tmp_target):
            os.unlink(tmp_target)
        result = dict(status="ERROR", message="unexpected: %s" % (e,))
    return Response(response=json.dumps(result), status=200, mimetype="application/json")