1

# DeGAL - A pretty simple web image gallery

     2

# Copyright (C) 2007 Tero Marttila

     3

# http://marttila.de/~terom/degal/

     4

#

     5

# This program is free software; you can redistribute it and/or modify

     6

# it under the terms of the GNU General Public License as published by

     7

# the Free Software Foundation; either version 2 of the License, or

     8

# (at your option) any later version.

     9

#

    10

# This program is distributed in the hope that it will be useful,

    11

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    12

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    13

# GNU General Public License for more details.

    14

#

    15

# You should have received a copy of the GNU General Public License

    16

# along with this program; if not, write to the

    17

# Free Software Foundation, Inc.,

    18

# 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    19

#

    20

    21

import struct

    22

import base64

    23

import shelve

    24

import os.path

    25

    26

    28

    29

def int2key (id) :

    30

    """

    31

        Turn an integer into a short-as-possible url-safe string

    32

    """

    33

    for type in ('B', 'H', 'I') :

    34

        try :

    35

            return base64.b64encode(struct.pack(type, id), '-_').rstrip('=')

    36

        except struct.error :

    37

            continue

    38

    39

    raise Exception("ID overflow: %s" % id)

    40

    41

def key2int (key) :

    42

    # base64 ignores extra padding, but if it doesn't, it's (4 - len%4), if len%4 != 0

    43

    # and it breaks on unicode strings

    44

    bytes = base64.b64decode(str(key + '='*6), '-_')

    45

    46

    type = {

    47

        1: 'B',

    48

        2: 'H',

    49

        4: 'I',

    50

    }[len(bytes)]

    51

    52

    return struct.unpack(type, bytes)[0]

    53

    54

class DB (object) :

    55

    def __init__ (self, read_only=True) :

    56

        self.db = shelve.open('shorturls2', read_only and 'r' or 'c')

    57

    58

    def html_path (self, key, index) :

    59

        type, dirpath, fname = self.db[key]

    60

    61

        if type == 'img' :

    62

            fname += '.html'

    63

        elif type == 'dir' :

    64

            fname = ''

    65

    66

        if index :

    67

            dirpath = '../%s' % dirpath

    68

    69

            if type == 'dir' and index > 1 : 

    70

                fname = 'index_%s.html' % (index - 1)

    71

    72

        return os.path.join(dirpath, fname)

    73

    74

    def image_info (self, key) :

    75

        type, dirpath, fname = self.db[key]

    76

    77

        if type != 'img' :

    78

            raise ValueError("%s is not an img" % key)

    79

    80

        return dirpath, fname

    81

    82

    def shorturls_for (self, paths) :

    83

        ret = []

    84

    85

        for key in self.db.keys() :

    86

            if key.startswith('_') :

    87

                continue

    88

    89

            type, dir, fname = self.db[key]

    90

            path = os.path.join(dir.lstrip('.').lstrip('/'), fname) 

    91

            if path in paths :

    92

                ret.append(key)

    93

                paths.remove(path)

    94

    95

        if paths :

    96

            raise ValueError("Paths not found: %s" % " ".join(paths))

    97

    98

        return ret

    99

   100

def html_path (key, index=None) :

   101

    dir, fname = node_info(key)

   102

   103

    if fname :

   104

        return utils.url(dir, fname + '.html')

   105

    else :

   106

        return utils.url(dir, helpers.url_for_page(index or 0))

   107

   108

def node_info (key) :

   109

    res = db.select("""SELECT dirpath, filename FROM nodes WHERE id=?""", key2int(key)).fetchone()

   110

   111

    if res :

   112

        return res

   113

   114

    else :

   115

        raise KeyError(key)

   116

   117

def image_info (key) :

   118

    res = db.select("""SELECT dirpath, filename FROM images WHERE id=?""", key2int(key)).fetchone()

   119

   120

    if res :

   121

        return res

   122

   123

    else :

   124

        raise KeyError(key)

   125

   126

def get_images (keys) :

   127

    res = [db.select("""SELECT dirpath, filename FROM images WHERE id=?""", key2int(key)).fetchone() for key in keys]

   128

   129

    # don't mind if we don't get as many as we asked for?

   130

    if res :

   131

        return res

   132

   133

    else :

   134

        raise KeyError(keys)

   135

   136

def _got_obj_key (obj, id) :

   137

    key = int2key(id)

   138

   139

    obj.shorturl_code = key

   140

   141

    if isinstance(obj, folder.Folder) :

   142

        dir, fname = utils.strip_path(obj.path), ''

   143

    elif isinstance(obj, image.Image) :

   144

        dir, fname = utils.strip_path(obj.dir.path), obj.name

   145

    else :

   146

        assert(False, "%r %r" % (obj, id))

   147

   149

   150

def updateDB (root) :

   151

    """

   152

        Update the SQL database

   153

   154

        type    - one of 'img', 'dir'

   155

        dirpath - the path to the directory, e.g. '.', './foobar', './foobar/quux'

   156

        fname   - the filename, one of '', 'DSC9839.JPG', 'this.png', etc.

   157

    """

   158

   159

    dirqueue = [root]

   160

   161

    # dict of (dir, fname) -> obj

   162

    paths = {}

   163

   164

    while dirqueue :

   165

        dir = dirqueue.pop(0)

   166

   167

        dirqueue.extend(dir.subdirs.itervalues())

   168

   169

        if dir.alive :

   170

            pathtuple = (utils.strip_path(dir.path), '')

   171

   173

   174

            paths[pathtuple] = dir

   175

   176

        for img in dir.images.itervalues() :

   177

            pathtuple = (utils.strip_path(img.dir.path), img.name)

   178

   180

   181

            paths[pathtuple] = img

   182

   184

   185

    for (id, dir, fname) in db.select("SELECT id, dirpath, filename FROM nodes") :

   186

        try :

   187

            obj = paths.pop((dir, fname))

   188

            key = int2key(id)

   189

   190

            obj.shorturl_code = key

   191

   193

   194

        except KeyError :

   195

            pass

   197

   200

   208