[pwp.git] / app / models.py

from config import ADMINS
from enum import IntEnum
from baseorm import BaseOrm
from flask_login import mixins
from app import app

class Format(IntEnum):
    jpg = 1
    raw = 2
    tiff = 3

class Role(IntEnum):
    read = 1
    write = 2
    admin = 3

class User(BaseOrm):
    __tablename__ = 'user'
    
    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        try:
            self.__oldValues['name'] = self.name
        except AttributeError:
            pass
        self.__name = name

    @property
    def email(self):
        return self.__email

    @email.setter
    def email(self, email):
        try:
            self.__oldValues['email'] = self.email
        except AttributeError:
            pass
        self.__email = email

    @property
    def username(self):
        return self.__username

    @username.setter
    def username(self, username):
        try:
            self.__oldValues['username'] = self.username
        except AttributeError:
            pass
        self.__username = username

    @property
    def password(self):
        return self.__password

    @password.setter
    def password(self, password):
        try:
            self.__oldValues['password'] = self.password
        except AttributeError:
            pass
        self.__password = password

    def __init__(self, name, email, username, password, id = -1):
        super().__init__()
        self.email = email
        self.id = id
        self.name = name
        self.username = username
        self.password = password
        
    def is_authenticated(self):
        return True

    def is_active(self):
        return True

    def is_anonymous(self):
        return False

    def get_id(self):
        return self.id

    def is_admin(self):
        return self.email in ADMINS

    def __repr__(self):
        return '<User ID: %s Name: %s Email: %s username: %s>' % (self.id, self.name,  self.email,  self.username)
        
class Portfolio(BaseOrm):
    __tablename__ = 'portfolio'
    
    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        try:
            self.__oldValues['name'] = self.name
        except AttributeError:
            pass
        self.__name = name

    @property
    def public(self):
        return self.__public
        
    @public.setter
    def public(self, public):
        try:
            self.__oldValues['public'] = self.public
        except AttributeError:
            pass
        self.__public = public
        
    @property
    def visible(self):
        return self.__visible
        
    @visible.setter
    def visible(self, visible):
        try:
            self.__oldValues['visible'] = self.visible
        except AttributeError:
            pass
        self.__visible = visible
        
    @property
    def user(self):
        return self.__user
        
    @user.setter
    def user(self, user):
        try:
            self.__oldValues['user'] = self.user
        except AttributeError:
            pass
        self.__user = user
        
    def __init__(self, name, user, public = False, visible = False, id = -1):
        super().__init__()
        self.id = id
        self.name = name
        self.public = public
        self.visible = visible
        app.logger.info("User: {0}".format(user))
        if (isinstance(user, User)):
            u = user
        else:
            u = User(user[1], user[2], user[3], user[4], user[0])
        if not isinstance(u, User):
            raise Exception("{0}: Not a 'User'".format(user))
        self.user = u
        
    def set_user_count(self, usercount):
        self.usercount = usercount

    def __repr__(self):
        return '<Portfolio ID: %s Name: %s Owner: %s>' % (self.id, self.name,  self.user)

class Album(BaseOrm):
    __tablename__ = 'album'

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        try:
            self.__oldValues['name'] = self.name
        except AttributeError:
            pass
        self.__name = name

    @property
    def public(self):
        return self.__public
        
    @public.setter
    def public(self, public):
        try:
            self.__oldValues['public'] = self.public
        except AttributeError:
            pass
        self.__public = public
        
    @property
    def visible(self):
        return self.__visible
        
    @visible.setter
    def visible(self, visible):
        try:
            self.__oldValues['visible'] = self.visible
        except AttributeError:
            pass
        self.__visible = visible
        
    @property
    def portfolio(self):
        return self.__portfolio
        
    @portfolio.setter
    def portfolio(self, portfolio):
        try:
            self.__oldValues['portfolio'] = self.portfolio
        except AttributeError:
            pass
        self.__portfolio = portfolio
        
    def __init__(self, name, portfolio):
        super().__init__()
        self.id = -1
        self.name = name
        self.public = False
        self.visible = False
        if not isinstance(portfolio, Portfolio):
            raise Exception("{0}: Not a 'Portfolio'".format(portfolio))
        self.portfolio = portfolio
        
    def set_user_count(self, usercount):
        self.usercount = usercount

    def __repr__(self):
        return '<Album Name: %r Portfolio: %r>' % (self.name,  self.portfolio)

class Photo(BaseOrm):
    __tablename__ = 'photo'

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        try:
            self.__oldValues['name'] = self.name
        except AttributeError:
            pass
        self.__name = name

    @property
    def public(self):
        return self.__public
        
    @public.setter
    def public(self, public):
        try:
            self.__oldValues['public'] = self.public
        except AttributeError:
            pass
        self.__public = public
        
    @property
    def visible(self):
        return self.__visible
        
    @visible.setter
    def visible(self, visible):
        try:
            self.__oldValues['visible'] = self.visible
        except AttributeError:
            pass
        self.__visible = visible
        
    @property
    def album(self):
        return self.__album
        
    @album.setter
    def album(self, album):
        try:
            self.__oldValues['album'] = self.album
        except AttributeError:
            pass
        self.__album = album
        
    @property
    def file(self):
        return self.__file

    @file.setter
    def file(self, file):
        try:
            self.__oldValues['file'] = self.file
        except AttributeError:
            pass
        self.__file = file

    @property
    def exif(self):
        return self.__exif

    @exif.setter
    def exif(self, exif):
        try:
            self.__oldValues['exif'] = self.exif
        except AttributeError:
            pass
        self.__exif = exif

    @property
    def format(self):
        return self.__format
        
    @format.setter
    def format(self, format):
        try:
            self.__oldValues['format'] = self.format
        except AttributeError:
            pass
        self.__format = format
        
    def __init__(self, name, album):
        super().__init__()
        self.id = -1
        self.name = name
        self.public = False
        self.visible = False
        if not isinstance(album, Album):
            raise Exception("{0}: Not a 'Album'".format(album))
        self.album = album
        self.file = None
        self.exif = None
        self.format = Format.raw.value
        
    def __repr__(self):
        return '<Photo Name: %r File: %r Format: %r Album: %r>' % (self.name,  self.file,  self.format,  self.album)

class AccessRight(BaseOrm):
    __tablename__ = 'accessright'

    @property
    def perm(self):
        return self.__perm

    @perm.setter
    def perm(self, perm):
        try:
            self.__oldValues['perm'] = self.perm
        except AttributeError:
            pass
        self.__perm = perm

    @property
    def user(self):
        return self.__user
        
    @user.setter
    def user(self, user):
        try:
            self.__oldValues['user'] = self.user
        except AttributeError:
            pass
        self.__user = user

    def __init__(self, user):
        super().__init__()
        self.id = -1
        self.perm = Role.read.value
        if not isinstance(user, User):
            raise Exception("{0}: Not a 'User'".format(user))
        self.user = user

    def __repr__(self):
        return '<AccessRight Right: %r User: %r>' % (self.perm,  self.user)

class MyAnonymous(mixins.AnonymousUserMixin):
    id = -1
    name = 'Anonymous User'
    email = 'no@email.com'
    username = 'None'
    
    @property
    def is_authenticated(self):
        return False

    @property
    def is_admin(self):
        return False

    def get_id(self):
        return self.id
        
    def __repr__(self):
        return '<User Name: %r Email: %r username: %r>' % (self.name,  self.email,  self.username)
Commit	Line	Data
e5424f29 MR	1	from config import ADMINS
e5424f29 MR	2	from enum import IntEnum
fc01a3eb MR	3	from baseorm import BaseOrm
	4	from flask_login import mixins
	5	from app import app
e5424f29 MR	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
fc01a3eb	17	class User(BaseOrm):
e5424f29 MR	18	__tablename__ = 'user'
	19
	20	@property
	21	def name(self):
	22	return self.__name
	23
	24	@name.setter
	25	def name(self, name):
fc01a3eb MR	26	try:
	27	self.__oldValues['name'] = self.name
	28	except AttributeError:
	29	pass
e5424f29	30	self.__name = name
e5424f29 MR	31
	32	@property
	33	def email(self):
	34	return self.__email
	35
	36	@email.setter
	37	def email(self, email):
fc01a3eb MR	38	try:
	39	self.__oldValues['email'] = self.email
	40	except AttributeError:
	41	pass
e5424f29	42	self.__email = email
e5424f29 MR	43
	44	@property
	45	def username(self):
	46	return self.__username
	47
	48	@username.setter
	49	def username(self, username):
fc01a3eb MR	50	try:
	51	self.__oldValues['username'] = self.username
	52	except AttributeError:
	53	pass
e5424f29	54	self.__username = username
e5424f29 MR	55
	56	@property
	57	def password(self):
	58	return self.__password
	59
	60	@password.setter
	61	def password(self, password):
fc01a3eb MR	62	try:
	63	self.__oldValues['password'] = self.password
	64	except AttributeError:
	65	pass
e5424f29	66	self.__password = password
e5424f29	67
fc01a3eb	68	def __init__(self, name, email, username, password, id = -1):
e5424f29 MR	69	super().__init__()
e5424f29 MR	70	self.email = email
fc01a3eb	71	self.id = id
e5424f29 MR	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
fc01a3eb MR	84
	85	def get_id(self):
	86	return self.id
	87
e5424f29 MR	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
fc01a3eb	94	class Portfolio(BaseOrm):
e5424f29 MR	95	__tablename__ = 'portfolio'
	96
	97	@property
	98	def name(self):
	99	return self.__name
	100
	101	@name.setter
	102	def name(self, name):
fc01a3eb MR	103	try:
	104	self.__oldValues['name'] = self.name
	105	except AttributeError:
	106	pass
e5424f29 MR	107	self.__name = name
	108
	109	@property
	110	def public(self):
	111	return self.__public
	112
	113	@public.setter
	114	def public(self, public):
fc01a3eb MR	115	try:
	116	self.__oldValues['public'] = self.public
	117	except AttributeError:
	118	pass
e5424f29 MR	119	self.__public = public
	120
	121	@property
	122	def visible(self):
	123	return self.__visible
	124
	125	@visible.setter
	126	def visible(self, visible):
fc01a3eb MR	127	try:
	128	self.__oldValues['visible'] = self.visible
	129	except AttributeError:
	130	pass
e5424f29 MR	131	self.__visible = visible
	132
	133	@property
	134	def user(self):
	135	return self.__user
	136
	137	@user.setter
	138	def user(self, user):
fc01a3eb MR	139	try:
	140	self.__oldValues['user'] = self.user
	141	except AttributeError:
	142	pass
e5424f29 MR	143	self.__user = user
e5424f29 MR	144
fc01a3eb	145	def __init__(self, name, user, public = False, visible = False, id = -1):
e5424f29	146	super().__init__()
fc01a3eb	147	self.id = id
e5424f29	148	self.name = name
fc01a3eb MR	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):
e5424f29	157	raise Exception("{0}: Not a 'User'".format(user))
fc01a3eb	158	self.user = u
e5424f29 MR	159
	160	def set_user_count(self, usercount):
	161	self.usercount = usercount
	162
	163	def __repr__(self):
fc01a3eb	164	return '<Portfolio ID: %s Name: %s Owner: %s>' % (self.id, self.name, self.user)
e5424f29	165
fc01a3eb	166	class Album(BaseOrm):
e5424f29 MR	167	__tablename__ = 'album'
	168
	169	@property
	170	def name(self):
	171	return self.__name
	172
	173	@name.setter
	174	def name(self, name):
fc01a3eb MR	175	try:
	176	self.__oldValues['name'] = self.name
	177	except AttributeError:
	178	pass
e5424f29 MR	179	self.__name = name
	180
	181	@property
	182	def public(self):
	183	return self.__public
	184
	185	@public.setter
	186	def public(self, public):
fc01a3eb MR	187	try:
	188	self.__oldValues['public'] = self.public
	189	except AttributeError:
	190	pass
e5424f29 MR	191	self.__public = public
	192
	193	@property
	194	def visible(self):
	195	return self.__visible
	196
	197	@visible.setter
	198	def visible(self, visible):
fc01a3eb MR	199	try:
	200	self.__oldValues['visible'] = self.visible
	201	except AttributeError:
	202	pass
e5424f29 MR	203	self.__visible = visible
	204
	205	@property
	206	def portfolio(self):
	207	return self.__portfolio
	208
	209	@portfolio.setter
	210	def portfolio(self, portfolio):
fc01a3eb MR	211	try:
	212	self.__oldValues['portfolio'] = self.portfolio
	213	except AttributeError:
	214	pass
e5424f29 MR	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
fc01a3eb	233	class Photo(BaseOrm):
e5424f29 MR	234	__tablename__ = 'photo'
	235
	236	@property
	237	def name(self):
	238	return self.__name
	239
	240	@name.setter
	241	def name(self, name):
fc01a3eb MR	242	try:
	243	self.__oldValues['name'] = self.name
	244	except AttributeError:
	245	pass
e5424f29 MR	246	self.__name = name
	247
	248	@property
	249	def public(self):
	250	return self.__public
	251
	252	@public.setter
	253	def public(self, public):
fc01a3eb MR	254	try:
	255	self.__oldValues['public'] = self.public
	256	except AttributeError:
	257	pass
e5424f29 MR	258	self.__public = public
	259
	260	@property
	261	def visible(self):
	262	return self.__visible
	263
	264	@visible.setter
	265	def visible(self, visible):
fc01a3eb MR	266	try:
	267	self.__oldValues['visible'] = self.visible
	268	except AttributeError:
	269	pass
e5424f29 MR	270	self.__visible = visible
	271
	272	@property
	273	def album(self):
	274	return self.__album
	275
	276	@album.setter
	277	def album(self, album):
fc01a3eb MR	278	try:
	279	self.__oldValues['album'] = self.album
	280	except AttributeError:
	281	pass
e5424f29 MR	282	self.__album = album
	283
	284	@property
	285	def file(self):
	286	return self.__file
	287
	288	@file.setter
	289	def file(self, file):
fc01a3eb MR	290	try:
	291	self.__oldValues['file'] = self.file
	292	except AttributeError:
	293	pass
e5424f29 MR	294	self.__file = file
	295
	296	@property
	297	def exif(self):
	298	return self.__exif
	299
	300	@exif.setter
	301	def exif(self, exif):
fc01a3eb MR	302	try:
	303	self.__oldValues['exif'] = self.exif
	304	except AttributeError:
	305	pass
e5424f29 MR	306	self.__exif = exif
	307
	308	@property
	309	def format(self):
	310	return self.__format
	311
	312	@format.setter
	313	def format(self, format):
fc01a3eb MR	314	try:
	315	self.__oldValues['format'] = self.format
	316	except AttributeError:
	317	pass
e5424f29 MR	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
fc01a3eb	336	class AccessRight(BaseOrm):
e5424f29 MR	337	__tablename__ = 'accessright'
	338
	339	@property
	340	def perm(self):
	341	return self.__perm
	342
	343	@perm.setter
	344	def perm(self, perm):
fc01a3eb MR	345	try:
	346	self.__oldValues['perm'] = self.perm
	347	except AttributeError:
	348	pass
e5424f29 MR	349	self.__perm = perm
	350
	351	@property
	352	def user(self):
	353	return self.__user
	354
	355	@user.setter
	356	def user(self, user):
fc01a3eb MR	357	try:
	358	self.__oldValues['user'] = self.user
	359	except AttributeError:
	360	pass
e5424f29 MR	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
fc01a3eb MR	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)