filesystem.py

# -*- coding: utf-8 -*-

# imports
import os
from datetime import datetime
import locale
import shutil
from mimetypes import guess_type
from zipfile import ZipFile


class FileSystem(object):

    FILE_EXTENSIONS = ["png", "jpg", "jpeg", "bmp", "ps", "eps", "pdf", "txt", "xml", "py", "c", "cpp", "root", "pxlio"]
    BROWSER_EXTENSIONS = ["png", "jpg", "jpeg", "bmp", "pdf"]
    ADDITIONAL_MIMES = {"pxlio": "text/plain",
                        "root" : "text/plain"}

    def __init__(self):
        # allowed extensions
        self.allowed_extensions = FileSystem.FILE_EXTENSIONS

    def setup(self, basedir=None):
        if basedir==None:
            basedir = os.path.expanduser("~")
        if not os.path.isdir(basedir):
            raise Exception("Basedir ("+str(basedir)+") does not exist!")
        # the basedir
        self.basedir = os.path.join(basedir, ".vispa")
        if os.path.isdir(self.basedir):
            return "Basedir already exists"
        else: 
            os.makedirs(self.basedir, 0700)
            return "Basedir now exists"

    def get_mime_type(self, filepath):
        mime, encoding = guess_type(filepath)
        if mime is not None:
            return mime
        ext = filepath.split(".")[-1]
        if ext is not None and ext != "" and ext.lower() in FileSystem.ADDITIONAL_MIMES.keys():
            return FileSystem.ADDITIONAL_MIMES[ext]
        return None

    def check_file_extension(self, path, extensions=[]):
        if (len(extensions) == 0):
            return True
        for elem in extensions:
            elem = elem if elem.startswith(".") else "." + elem
            if path.lower().endswith(elem.lower()):
                return True
        return False

    def exists(self, path, pathtype=None, fileextension=None, permissionmode="r"):
        if isinstance(permissionmode, str) and permissionmode.lower() not in ["r", "w"]:
            return False

        # path exists physically?
        if not os.path.exists(path):
            return False

        # pathtype correct? (file, folder, or None)
        if pathtype is not None:
            pathtype = pathtype.lower()
            if not pathtype in ["file", "folder"]:
                return False
            if os.path.isdir(path) and pathtype == "file":
                return False
            elif not os.path.isdir(path) and pathtype == "folder":
                return False

        # file extension correct?
        if fileextension is not None:
            fileextension = fileextension if isinstance(fileextension, list) else [fileextension]
            hit = False
            for fileext in fileextension:
                fileext = fileext if fileext.startswith(".") else "." + fileext
                if path.endswith(fileext):
                    hit = True
            if not hit:
                return False

        # permission?
        if permissionmode is not None:
            return False

        return True


    def get_file_list(self, path, deep, ext_filter=[], reverse=False):
        dirlist = os.listdir(path)
        returnlist = []
        for elem in dirlist:
            fullPath = os.path.join(path, elem)
            locale.setlocale(locale.LC_ALL, '')
            stats = os.stat(path + ('' if path.endswith('/') else '/') + elem)
            size = stats.st_size
            size = locale.format("%d", size, grouping=True)
            mtime = stats.st_mtime
            mtime = datetime.fromtimestamp(mtime).strftime("%Y-%m-%d %H:%M:%S")
            if os.path.isdir(fullPath):
                if elem.startswith("."):
                    continue
                returnlist.append({'name': elem, 'type': 'folder', 'parent': path + '/', 'extension': '', 'mtime': mtime, 'size': size, "path": os.path.join(path, elem)})
                if deep:
                    returnlist.extend(self.get_file_list(fullPath, deep, ext_filter, reverse))
            else:
                if elem.startswith("."):
                    continue
                extension = elem.split(".")[-1]
                returnlist.append({'name': elem, 'type': 'file', 'parent': path + '/', 'extension': extension, 'mtime': mtime, 'size': size, "path": os.path.join(path, elem)})
        # apply filters
        filelist = []
        # delete "." in file extensions
        ext_filter = map(lambda ext: ext if not ext.startswith(".") else ext[1:], ext_filter)
        for elem in returnlist:
            if (elem["type"] == "folder"):
                filelist.append(elem)
                continue
            if not reverse:
                if str(elem["extension"]) not in ext_filter:
                    filelist.append(elem)
            else:
                if str(elem["extension"]) in ext_filter:
                    filelist.append(elem)
        return filelist


    def cut_slashs(self, path):
        path = path[1:] if path.startswith("/") else path
        if path == "":
            return path
        path = path[:-1] if path.endswith("/") else path
        return path

    def create_folder(self, path, name):
        # folder with the same name existent?
        fullpath = os.path.join(path, name)
        if os.path.isdir(fullpath):
            raise Exception("Name already in use!")
        try:
            os.mkdir(fullpath)
        except Exception as e:
            #raise Exception("You don't have the permission to create this folder!")
            raise Exception(str(e))

    def create_file(self, path, name):
        # file with the same name existent?
        fullpath = os.path.join(path, name)
        if os.path.exists(fullpath):
            raise Exception("Name already in use!")
        try:
            f = file(fullpath, "w")
            f.close()
        except Exception as e:
            raise Exception(str(e))
        

    def rename_folder(self, path, name):
        # file or folder
        if not os.path.isdir(path):
            raise Exception("Renaming file with folder function!")

        # folder with the same name existent?
        path = path if not path.endswith("/") else path[:-1]
        fullpath = os.path.join("/".join(path.split("/")[:-1]), name)
        if os.path.exists(fullpath):
            raise Exception("Name already in use!")

        os.renames(path, fullpath)

    def rename_file(self, path, name):
        # file or folder
        if os.path.isdir(path):
            raise Exception("Renaming folder with file function!")

        # file with the same name existent?
        fullpath = os.path.join("/".join(path.split("/")[:-1]), name)
        if os.path.exists(fullpath):
            raise Exception("Name already in use!")

        os.renames(path, fullpath)

    def remove(self, path):
        if isinstance(path, list):
            for p in path:
                self.remove(p)
            return True

        if os.path.isdir(path):
            shutil.rmtree(path)
        else:
            os.remove(path)

    def compress(self, path, paths, name):
        # paths has to be a list of strings
        paths = paths if isinstance(paths, list) else [paths]

        path = path if not path.endswith("/") else path[:-1]

        fullpath = os.path.join(path, "%s.zip" % name)

        if os.path.exists(fullpath):
            raise Exception("Name already in use!")

        archive = ZipFile(fullpath, "w")

        path = path if path.startswith("/") else path
        for p in paths:
            if p is None or p == "":
                continue
            p = p if p.startswith(os.sep) else os.sep + path
            if os.path.isdir(p):
                for elem in os.listdir(p):
                    fullp = os.path.join(p, elem)
                    if os.path.isdir(fullp):
                        paths.append(fullp)
                    else:
                        ap = fullp[len(path):] if fullp.startswith(path) else fullp
                        archive.write(fullpp, ap)

            ap = p[len(path):] if p.startswith(path) else p
            archive.write(p, ap)

        archive.close()

    def paste(self, path, target, cut):
        if isinstance(target, list):
            for p in target:
                self.paste(path, p, cut)
            return True

        fulltarget = os.path.join(path, target.split("/")[-1])

        if os.path.exists(fulltarget):
            raise Exception("Name already in use!")

        if os.path.isdir(target):
            shutil.copytree(target, fulltarget)
            if cut:
                shutil.rmtree(target)
        else:
            shutil.copy2(target, path)
            if cut:
                os.remove(target)


    def save_file_content(self, path, content, force=True):
        #check if file already exists
        if os.path.exists(path) and not force:
            return False, "The file '%s' already exists!" % path

        out = open(path, "w")
        for line in content.data:
            out.write(line)
        out.close()

        return True, "File saved!"

    def get_file_content(self, path):
        f = open(path, "r")
        content = f.read()
        f.close()
        if content == '':
            content = ' '
        return content

    def is_browser_file(self, path):
        extension = path.split(".")[-1]
        return extension in FileSystem.BROWSER_EXTENSIONS

    def handle_file_name_collision(self, name, path):
        # collision?
        files = os.listdir(path)
        if name not in files:
            return name

        # when this line is reached, there is a collision!

        # cut the file extension
        extension = name.split(".")[-1]
        prename = None
        if name == extension:
            extension = ""
            prename = name
        else:
            prename = name.split("." + extension)[0]

        # has the name already a counter at its end?
        hasCounter = False
        preprename = None
        counter = prename.split("_")[-1]

        if counter != prename:
            try:
                counter = int(counter)
                hasCounter = True
                preprename = "_".join(prename.split("_")[:-1])
            except:
                pass

        if hasCounter:
            # increment and try again
            counter += 1
            newname = "%s_%d%s" % (preprename, counter, "" if extension == "" else "." + extension)
        else:
            newname = "%s_1%s" % (prename, "" if extension == "" else "." + extension)

        # return
        return self.handle_file_name_collision(newname, path)