class User(db.Model, UserMixin):
__tablename__ = 'Users'
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.Unicode(50), unique=True)
name = db.Column(db.Unicode(50), nullable=False)
password = db.Column(db.Unicode(50), nullable=False) # NOT USED!!!
email = db.Column(db.Unicode(254), nullable=False)
organization = db.Column(db.Unicode(50)) # Organization and role aren't used either.
role = db.Column(db.Unicode(50))
creation_date = db.Column(db.DateTime, nullable=False, index=True)
last_access_date = db.Column(db.DateTime, nullable=False, index=True)
auth_system = db.Column(db.Unicode(20), nullable=True)
auth_data = db.Column(db.Unicode(255), nullable=True)
def __init__(self, login=None, name=None, password=None, email=None, organization=None, role=None,
creation_date=None, last_access_date=None, auth_system=None, auth_data=None):
self.login = login
self.name = name
self.password = password
self.email = email
self.organization = organization
self.role = role
self.creation_date = creation_date
self.last_access_date = last_access_date
self.auth_system = auth_system
self.auth_data = auth_data
def __repr__(self):
return "User(%r, %r, %r, %r, %r, %r, %r, %r, %r, %r)" % (
self.login, self.name, self.password, self.email, self.organization, self.role, self.creation_date,
self.last_access_date, self.auth_system, self.auth_data)
def __unicode__(self):
return self.name
@classmethod
def exists(cls, login, word):
return cls.query.filter(sql.and_(cls.login == login, cls.password == word)).first()
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
class TranslatedApp(db.Model):
__tablename__ = 'TranslatedApps'
id = db.Column(db.Integer, primary_key = True)
translation_url_id = db.Column(db.Integer, ForeignKey('TranslationUrls.id'))
url = db.Column(db.Unicode(255), unique = True, nullable = False, index = True)
translation_url = relation("TranslationUrl", backref="apps")
def __init__(self, url, translation_url):
self.url = url
if isinstance(translation_url, basestring):
raise Exception("TranslationApp requires a TranslationUrl, not a string")
self.translation_url = translation_url
def __unicode__(self):
return self.url
class TranslationSubscription(db.Model):
__tablename__ = 'TranslationSubscriptions'
id = db.Column(db.Integer, primary_key = True)
translation_url_id = db.Column(db.Integer, ForeignKey('TranslationUrls.id'))
recipient_id = db.Column(db.Integer, ForeignKey('TranslationNotificationRecipients.id'))
mechanism = db.Column(db.Unicode(255), nullable = False, index = True)
last_check = db.Column(db.DateTime, index = True)
# mechanism: web, file (...)
translation_url = relation("TranslationUrl", backref="subscriptions")
recipient = relation("TranslationNotificationRecipient", backref="subscriptions")
def __init__(self, translation_url, recipient, mechanism):
self.translation_url = translation_url
self.recipient = recipient
self.mechanism = mechanism
self.last_check = datetime.datetime.utcnow() - datetime.timedelta(hours = 24)
def update(self):
self.last_check = datetime.datetime.utcnow()
class RepositoryApp(db.Model):
__tablename__ = 'RepositoryApps'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(200), nullable = False, index = True)
url = db.Column(db.Unicode(1024), nullable = False)
app_thumb = db.Column(db.Unicode(255))
description = db.Column(db.UnicodeText)
app_link = db.Column(db.Unicode(255))
app_image = db.Column(db.Unicode(255))
app_format = db.Column(db.Unicode(255)) # opensocial or html
preview_link = db.Column(db.Unicode(1024), nullable=True)
uses_proxy = db.Column(db.Boolean, index=True)
repository = db.Column(db.Unicode(400), nullable = False, index = True)
external_id = db.Column(db.Unicode(200), index = True)
adaptable = db.Column(db.Boolean, index = True)
translatable = db.Column(db.Boolean, index = True)
offline = db.Column(db.Boolean, index = True)
translation_percent = db.Column(db.UnicodeText) # JSON document containing which bundles have been translated how much
last_check = db.Column(db.DateTime, index = True)
last_change = db.Column(db.DateTime, index = True)
last_download_change = db.Column(db.DateTime, index = True)
failing = db.Column(db.Boolean, index = True)
failing_since = db.Column(db.DateTime, index = True)
supports_ssl = db.Column(db.Boolean, index=True)
proxy_image_works = db.Column(db.Boolean, index=True)
proxy_image_stored = db.Column(db.Boolean, index=True)
contains_flash = db.Column(db.Boolean, index=True)
downloaded_hash = db.Column(db.Unicode(255), index=True)
contents_hash = db.Column(db.Unicode(255), index=True)
last_processed_downloaded_hash = db.Column(db.Unicode(255), index=True)
last_processed_contents_hash = db.Column(db.Unicode(255), index=True)
last_processed_time = db.Column(db.DateTime, index=True)
def __init__(self, name, url, repository, external_id = None):
self.name = name
self.url = url
self.repository = repository
self.external_id = unicode(external_id)
self.app_thumb = None
self.description = None
self.adaptable = False
self.translatable = False
self.last_check = None
self.last_change = None
self.failing = False
self.failing_since = None
@property
def check_urls_hash(self):
return unicode(zlib.crc32(json.dumps(sorted([ check_url.url for check_url in self.check_urls if check_url.active ]))))
@property
def original_translations(self):
return ','.join([ ote.language.language for ote in self.languages ])
@original_translations.setter
def original_translations(self, attr):
if not attr:
return
languages = list(attr.split(','))
if not languages:
return
for orig_lang in self.original_translations.split(','):
if orig_lang in languages:
languages.remove(orig_lang)
for lang_db in db.session.query(Language).filter(Language.language.in_(languages)).all():
new_lang = RepositoryAppLanguage(repository_app=self, language=lang_db)
db.session.add(new_lang)
from alembic import op
import sqlalchemy as sa
import sqlalchemy.sql as sql
from appcomposer.db import db
from appcomposer.application import app
metadata = db.MetaData()
active_translation = db.Table(
'ActiveTranslationMessages',
metadata,
db.Column('id', db.Integer()),
db.Column('bundle_id', db.Integer),
db.Column('taken_from_default', db.Boolean),
db.Column('from_developer', db.Boolean),
db.Column('key', db.Unicode(255)),
db.Column('value', db.UnicodeText()),
)
bundle = db.Table(
'TranslationBundles',
metadata,
db.Column('id', db.Integer()),
db.Column('from_developer', db.Boolean),
db.Column('translation_url_id', db.Integer),
db.Column('language', db.Unicode(20)),
db.Column('target', db.Unicode(20)),
)
def upgrade():
### commands auto generated by Alembic - please adjust! ###
class App(db.Model):
__tablename__ = 'Apps'
__table_args__ = (UniqueConstraint('name', 'owner_id'), )
id = db.Column(db.Integer, primary_key=True)
unique_id = db.Column(db.Unicode(50), index=True, unique=True)
name = db.Column(db.Unicode(50), index=True)
composer = db.Column(db.Unicode(50),
index=True,
nullable=False,
server_default=u'expert')
data = db.Column(db.Text, nullable=False, server_default=u'{}')
creation_date = db.Column(db.DateTime, nullable=False, index=True)
modification_date = db.Column(db.DateTime, nullable=False, index=True)
last_access_date = db.Column(db.DateTime, nullable=False, index=True)
description = db.Column(db.Unicode(1000), nullable=True)
# TODO: Find out why these relationships seems to not work sometimes.
owner_id = db.Column(db.Integer,
ForeignKey("Users.id"),
nullable=False,
index=True)
owner = relation("User",
backref=backref("own_apps",
order_by=id,
cascade='all,delete'))
spec_id = db.Column(db.Integer, ForeignKey("Specs.id"))
spec = relation(
"Spec", backref="apps"
) # declare the relation and place a backref to the apps on the Spec objects.
# An app can have many bundles (one-to-many).
bundles = relation("Bundle", backref="app")
def __repr__(self):
return self.to_json()
def __init__(self, name=None, owner=None, composer=None, description=None):
self.name = name
self.owner = owner
self.composer = composer
self.creation_date = self.modification_date = self.last_access_date = datetime.datetime.now(
)
# Generate a not-too-long unique id.
uid = base64.urlsafe_b64encode(uuid.uuid4().bytes[0:15])
self.unique_id = uid
while App.find_by_unique_id(self.unique_id) is not None:
self.unique_id = base64.urlsafe_b64encode(uuid.uuid4().bytes[0:15])
self.description = description
def to_dict(self):
"""
Turns the app into a dictionary with just data (which is easy to serialize).
"""
d = {
"unique_id": self.unique_id,
"name": self.name,
"owner_id": self.owner_id,
"composer": self.composer,
"data": self.data,
"creation_date": self.creation_date.__str__(),
"modification_date": self.modification_date.__str__(),
"last_access_date": self.last_access_date.__str__(),
}
return d
def to_json(self):
"""
Turns the App into a JSON string.
"""
return json.dumps(self.to_dict())
@classmethod
def find_by_unique_id(cls, unique_id):
return cls.query.filter_by(unique_id=unique_id).first()