| | 1 | from config import ADMINS |
| | 2 | from enum import IntEnum |
| | 3 | from baseorm import BaseOrm |
| | 4 | from flask_login import mixins |
| | 5 | from app import app |
| | 6 | |
| | 7 | class Format(IntEnum): |
| | 8 | jpg = 1 |
| | 9 | raw = 2 |
| | 10 | tiff = 3 |
| | 11 | |
| | 12 | class Role(IntEnum): |
| | 13 | read = 1 |
| | 14 | write = 2 |
| | 15 | admin = 3 |
| | 16 | |
| | 17 | class User(BaseOrm): |
| | 18 | __tablename__ = 'user' |
| | 19 | |
| | 20 | @property |
| | 21 | def name(self): |
| | 22 | return self.__name |
| | 23 | |
| | 24 | @name.setter |
| | 25 | def name(self, name): |
| | 26 | try: |
| | 27 | self.__oldValues['name'] = self.name |
| | 28 | except AttributeError: |
| | 29 | pass |
| | 30 | self.__name = name |
| | 31 | |
| | 32 | @property |
| | 33 | def email(self): |
| | 34 | return self.__email |
| | 35 | |
| | 36 | @email.setter |
| | 37 | def email(self, email): |
| | 38 | try: |
| | 39 | self.__oldValues['email'] = self.email |
| | 40 | except AttributeError: |
| | 41 | pass |
| | 42 | self.__email = email |
| | 43 | |
| | 44 | @property |
| | 45 | def username(self): |
| | 46 | return self.__username |
| | 47 | |
| | 48 | @username.setter |
| | 49 | def username(self, username): |
| | 50 | try: |
| | 51 | self.__oldValues['username'] = self.username |
| | 52 | except AttributeError: |
| | 53 | pass |
| | 54 | self.__username = username |
| | 55 | |
| | 56 | @property |
| | 57 | def password(self): |
| | 58 | return self.__password |
| | 59 | |
| | 60 | @password.setter |
| | 61 | def password(self, password): |
| | 62 | try: |
| | 63 | self.__oldValues['password'] = self.password |
| | 64 | except AttributeError: |
| | 65 | pass |
| | 66 | self.__password = password |
| | 67 | |
| | 68 | def __init__(self, name, email, username, password, id = -1): |
| | 69 | super().__init__() |
| | 70 | self.email = email |
| | 71 | self.id = id |
| | 72 | self.name = name |
| | 73 | self.username = username |
| | 74 | self.password = password |
| | 75 | |
| | 76 | def is_authenticated(self): |
| | 77 | return True |
| | 78 | |
| | 79 | def is_active(self): |
| | 80 | return True |
| | 81 | |
| | 82 | def is_anonymous(self): |
| | 83 | return False |
| | 84 | |
| | 85 | def get_id(self): |
| | 86 | return self.id |
| | 87 | |
| | 88 | def is_admin(self): |
| | 89 | return self.email in ADMINS |
| | 90 | |
| | 91 | def __repr__(self): |
| | 92 | return '<User ID: %s Name: %s Email: %s username: %s>' % (self.id, self.name, self.email, self.username) |
| | 93 | |
| | 94 | class Portfolio(BaseOrm): |
| | 95 | __tablename__ = 'portfolio' |
| | 96 | |
| | 97 | @property |
| | 98 | def name(self): |
| | 99 | return self.__name |
| | 100 | |
| | 101 | @name.setter |
| | 102 | def name(self, name): |
| | 103 | try: |
| | 104 | self.__oldValues['name'] = self.name |
| | 105 | except AttributeError: |
| | 106 | pass |
| | 107 | self.__name = name |
| | 108 | |
| | 109 | @property |
| | 110 | def public(self): |
| | 111 | return self.__public |
| | 112 | |
| | 113 | @public.setter |
| | 114 | def public(self, public): |
| | 115 | try: |
| | 116 | self.__oldValues['public'] = self.public |
| | 117 | except AttributeError: |
| | 118 | pass |
| | 119 | self.__public = public |
| | 120 | |
| | 121 | @property |
| | 122 | def visible(self): |
| | 123 | return self.__visible |
| | 124 | |
| | 125 | @visible.setter |
| | 126 | def visible(self, visible): |
| | 127 | try: |
| | 128 | self.__oldValues['visible'] = self.visible |
| | 129 | except AttributeError: |
| | 130 | pass |
| | 131 | self.__visible = visible |
| | 132 | |
| | 133 | @property |
| | 134 | def user(self): |
| | 135 | return self.__user |
| | 136 | |
| | 137 | @user.setter |
| | 138 | def user(self, user): |
| | 139 | try: |
| | 140 | self.__oldValues['user'] = self.user |
| | 141 | except AttributeError: |
| | 142 | pass |
| | 143 | self.__user = user |
| | 144 | |
| | 145 | def __init__(self, name, user, public = False, visible = False, id = -1): |
| | 146 | super().__init__() |
| | 147 | self.id = id |
| | 148 | self.name = name |
| | 149 | self.public = public |
| | 150 | self.visible = visible |
| | 151 | app.logger.info("User: {0}".format(user)) |
| | 152 | if (isinstance(user, User)): |
| | 153 | u = user |
| | 154 | else: |
| | 155 | u = User(user[1], user[2], user[3], user[4], user[0]) |
| | 156 | if not isinstance(u, User): |
| | 157 | raise Exception("{0}: Not a 'User'".format(user)) |
| | 158 | self.user = u |
| | 159 | |
| | 160 | def set_user_count(self, usercount): |
| | 161 | self.usercount = usercount |
| | 162 | |
| | 163 | def __repr__(self): |
| | 164 | return '<Portfolio ID: %s Name: %s Owner: %s>' % (self.id, self.name, self.user) |
| | 165 | |
| | 166 | class Album(BaseOrm): |
| | 167 | __tablename__ = 'album' |
| | 168 | |
| | 169 | @property |
| | 170 | def name(self): |
| | 171 | return self.__name |
| | 172 | |
| | 173 | @name.setter |
| | 174 | def name(self, name): |
| | 175 | try: |
| | 176 | self.__oldValues['name'] = self.name |
| | 177 | except AttributeError: |
| | 178 | pass |
| | 179 | self.__name = name |
| | 180 | |
| | 181 | @property |
| | 182 | def public(self): |
| | 183 | return self.__public |
| | 184 | |
| | 185 | @public.setter |
| | 186 | def public(self, public): |
| | 187 | try: |
| | 188 | self.__oldValues['public'] = self.public |
| | 189 | except AttributeError: |
| | 190 | pass |
| | 191 | self.__public = public |
| | 192 | |
| | 193 | @property |
| | 194 | def visible(self): |
| | 195 | return self.__visible |
| | 196 | |
| | 197 | @visible.setter |
| | 198 | def visible(self, visible): |
| | 199 | try: |
| | 200 | self.__oldValues['visible'] = self.visible |
| | 201 | except AttributeError: |
| | 202 | pass |
| | 203 | self.__visible = visible |
| | 204 | |
| | 205 | @property |
| | 206 | def portfolio(self): |
| | 207 | return self.__portfolio |
| | 208 | |
| | 209 | @portfolio.setter |
| | 210 | def portfolio(self, portfolio): |
| | 211 | try: |
| | 212 | self.__oldValues['portfolio'] = self.portfolio |
| | 213 | except AttributeError: |
| | 214 | pass |
| | 215 | self.__portfolio = portfolio |
| | 216 | |
| | 217 | def __init__(self, name, portfolio): |
| | 218 | super().__init__() |
| | 219 | self.id = -1 |
| | 220 | self.name = name |
| | 221 | self.public = False |
| | 222 | self.visible = False |
| | 223 | if not isinstance(portfolio, Portfolio): |
| | 224 | raise Exception("{0}: Not a 'Portfolio'".format(portfolio)) |
| | 225 | self.portfolio = portfolio |
| | 226 | |
| | 227 | def set_user_count(self, usercount): |
| | 228 | self.usercount = usercount |
| | 229 | |
| | 230 | def __repr__(self): |
| | 231 | return '<Album Name: %r Portfolio: %r>' % (self.name, self.portfolio) |
| | 232 | |
| | 233 | class Photo(BaseOrm): |
| | 234 | __tablename__ = 'photo' |
| | 235 | |
| | 236 | @property |
| | 237 | def name(self): |
| | 238 | return self.__name |
| | 239 | |
| | 240 | @name.setter |
| | 241 | def name(self, name): |
| | 242 | try: |
| | 243 | self.__oldValues['name'] = self.name |
| | 244 | except AttributeError: |
| | 245 | pass |
| | 246 | self.__name = name |
| | 247 | |
| | 248 | @property |
| | 249 | def public(self): |
| | 250 | return self.__public |
| | 251 | |
| | 252 | @public.setter |
| | 253 | def public(self, public): |
| | 254 | try: |
| | 255 | self.__oldValues['public'] = self.public |
| | 256 | except AttributeError: |
| | 257 | pass |
| | 258 | self.__public = public |
| | 259 | |
| | 260 | @property |
| | 261 | def visible(self): |
| | 262 | return self.__visible |
| | 263 | |
| | 264 | @visible.setter |
| | 265 | def visible(self, visible): |
| | 266 | try: |
| | 267 | self.__oldValues['visible'] = self.visible |
| | 268 | except AttributeError: |
| | 269 | pass |
| | 270 | self.__visible = visible |
| | 271 | |
| | 272 | @property |
| | 273 | def album(self): |
| | 274 | return self.__album |
| | 275 | |
| | 276 | @album.setter |
| | 277 | def album(self, album): |
| | 278 | try: |
| | 279 | self.__oldValues['album'] = self.album |
| | 280 | except AttributeError: |
| | 281 | pass |
| | 282 | self.__album = album |
| | 283 | |
| | 284 | @property |
| | 285 | def file(self): |
| | 286 | return self.__file |
| | 287 | |
| | 288 | @file.setter |
| | 289 | def file(self, file): |
| | 290 | try: |
| | 291 | self.__oldValues['file'] = self.file |
| | 292 | except AttributeError: |
| | 293 | pass |
| | 294 | self.__file = file |
| | 295 | |
| | 296 | @property |
| | 297 | def exif(self): |
| | 298 | return self.__exif |
| | 299 | |
| | 300 | @exif.setter |
| | 301 | def exif(self, exif): |
| | 302 | try: |
| | 303 | self.__oldValues['exif'] = self.exif |
| | 304 | except AttributeError: |
| | 305 | pass |
| | 306 | self.__exif = exif |
| | 307 | |
| | 308 | @property |
| | 309 | def format(self): |
| | 310 | return self.__format |
| | 311 | |
| | 312 | @format.setter |
| | 313 | def format(self, format): |
| | 314 | try: |
| | 315 | self.__oldValues['format'] = self.format |
| | 316 | except AttributeError: |
| | 317 | pass |
| | 318 | self.__format = format |
| | 319 | |
| | 320 | def __init__(self, name, album): |
| | 321 | super().__init__() |
| | 322 | self.id = -1 |
| | 323 | self.name = name |
| | 324 | self.public = False |
| | 325 | self.visible = False |
| | 326 | if not isinstance(album, Album): |
| | 327 | raise Exception("{0}: Not a 'Album'".format(album)) |
| | 328 | self.album = album |
| | 329 | self.file = None |
| | 330 | self.exif = None |
| | 331 | self.format = Format.raw.value |
| | 332 | |
| | 333 | def __repr__(self): |
| | 334 | return '<Photo Name: %r File: %r Format: %r Album: %r>' % (self.name, self.file, self.format, self.album) |
| | 335 | |
| | 336 | class AccessRight(BaseOrm): |
| | 337 | __tablename__ = 'accessright' |
| | 338 | |
| | 339 | @property |
| | 340 | def perm(self): |
| | 341 | return self.__perm |
| | 342 | |
| | 343 | @perm.setter |
| | 344 | def perm(self, perm): |
| | 345 | try: |
| | 346 | self.__oldValues['perm'] = self.perm |
| | 347 | except AttributeError: |
| | 348 | pass |
| | 349 | self.__perm = perm |
| | 350 | |
| | 351 | @property |
| | 352 | def user(self): |
| | 353 | return self.__user |
| | 354 | |
| | 355 | @user.setter |
| | 356 | def user(self, user): |
| | 357 | try: |
| | 358 | self.__oldValues['user'] = self.user |
| | 359 | except AttributeError: |
| | 360 | pass |
| | 361 | self.__user = user |
| | 362 | |
| | 363 | def __init__(self, user): |
| | 364 | super().__init__() |
| | 365 | self.id = -1 |
| | 366 | self.perm = Role.read.value |
| | 367 | if not isinstance(user, User): |
| | 368 | raise Exception("{0}: Not a 'User'".format(user)) |
| | 369 | self.user = user |
| | 370 | |
| | 371 | def __repr__(self): |
| | 372 | return '<AccessRight Right: %r User: %r>' % (self.perm, self.user) |
| | 373 | |
| | 374 | class MyAnonymous(mixins.AnonymousUserMixin): |
| | 375 | id = -1 |
| | 376 | name = 'Anonymous User' |
| | 377 | email = 'no@email.com' |
| | 378 | username = 'None' |
| | 379 | |
| | 380 | @property |
| | 381 | def is_authenticated(self): |
| | 382 | return False |
| | 383 | |
| | 384 | @property |
| | 385 | def is_admin(self): |
| | 386 | return False |
| | 387 | |
| | 388 | def get_id(self): |
| | 389 | return self.id |
| | 390 | |
| | 391 | def __repr__(self): |
| | 392 | return '<User Name: %r Email: %r username: %r>' % (self.name, self.email, self.username) |
projects / pwp.git / blame_incremental