def invalidateCache(self):
logging.info("ServerSettings removed from cache.")
get_server_settings.invalidate_cache()
@deserializer
def ds_ss(stream):
return ds_model(stream, ServerSettings)
@serializer
def s_ss(stream, server_settings):
s_model(stream, server_settings, ServerSettings)
register(ServerSettings, s_ss, ds_ss)
@cached(1, 3600, read_cache_in_transaction=True)
@returns(ServerSettings)
@arguments()
def get_server_settings():
@db.non_transactional
def get():
ss = ServerSettings.get_by_key_name("MainSettings")
if not ss:
ss = ServerSettings(key_name="MainSettings")
return ss
return get()
return ndb.Key(cls, look_and_feel_id)
@property
def id(self):
return self.key.id()
def invalidateCache(self):
from rogerthat.bizz.look_and_feel import get_look_and_feel_by_app_id
invalidate_cache(get_look_and_feel_by_app_id, self.app_id)
@classmethod
def get_by_app_id(cls, app_id):
return cls.query(cls.app_id == app_id)
register(List(AppLookAndFeel), s_any, ds_any)
class EmbeddedApplicationTag(Enum):
PAYMENTS = u'payments'
class EmbeddedApplicationType(Enum):
CHAT_PAYMENT = u'chat-payment'
WIDGET_PAY = u'widget-pay'
class EmbeddedApplication(NdbModel):
file_path = ndb.StringProperty(indexed=False) # /cloudstorage_bucket/path/to/file.extension
modification_date = ndb.DateTimeProperty(auto_now=True, indexed=False)
tags = ndb.StringProperty(repeated=True, choices=EmbeddedApplicationTag.all())
@property
def app_id(self):
from rogerthat.utils.app import get_app_id_from_app_user
return get_app_id_from_app_user(self.user)
@property
def is_phone_unregistered(self):
return self.status > Mobile.STATUS_NEW | Mobile.STATUS_ACCOUNT_CREATED | Mobile.STATUS_REGISTERED
@deserializer
def ds_mobile(stream):
return model_deserializer(stream, Mobile)
register(Mobile, s_model, ds_mobile)
s_mobile_list = get_list_serializer(s_model)
ds_mobile_list = get_list_deserializer(ds_mobile)
register(List(Mobile), s_mobile_list, ds_mobile_list)
class ErrorPlatformVersion(NdbModel):
platform_version = ndb.StringProperty()
client_version = ndb.StringProperty()
class ClientError(NdbModel):
PLATFORM_ANDROID = 1
PLATFORM_IPHONE = 5
PLATFORMS = (PLATFORM_ANDROID, PLATFORM_IPHONE)
def _s_street_list(stream, l):
s_long(stream, 1)
f = get_list_serializer(_s_street_to)
f(stream, l)
def _ds_street_list(stream):
l = list()
version = ds_long(stream)
f = get_list_deserializer(_ds_street_to, True)
for to in f(stream, version):
l.append(to)
return l
register(List(StreetTO), _s_street_list, _ds_street_list)
class HouseTO(object):
number = long_property('1')
bus = unicode_property('2')
@classmethod
def fromObj(cls, obj):
to = cls()
to.number = obj["h"]
to.bus = obj["t"]
return to
@deserializer
self.result = []
for news_item in news_items:
to = AppNewsInfoTO()
to.id = news_item.id
to.version = news_item.version
to.sort_timestamp = news_item.sort_timestamp
to.sort_priority = 50 if first_time else news_item.sort_priority(connections, profile,
users_that_rogered.get(news_item.id, []))
to.sender_email = remove_slash_default(news_item.sender).email()
to.broadcast_type = news_item.broadcast_type
to.feed_name = news_item.feed_name(get_app_id_from_app_user(profile.user))
self.result.append(to)
register(NewsSenderTO, _serialize_news_sender, _deserialize_news_sender)
register(NewsItemTO, _serialize_news_item, _deserialize_news_item)
class NewNewsRequestTO(object):
news_item = typed_property('1', AppNewsItemTO, False)
class NewNewsResponseTO(object):
pass
class DisableNewsRequestTO(object):
news_id = long_property('1')
def __init__(self, news_id=None):
def invalidateCache(self):
logging.info("SolutionServerSettings removed from cache.")
get_solution_server_settings.invalidate_cache()
@deserializer
def ds_ss(stream):
return ds_model(stream, SolutionServerSettings)
@serializer
def s_ss(stream, solution_server_settings):
s_model(stream, solution_server_settings, SolutionServerSettings)
register(SolutionServerSettings, s_ss, ds_ss)
@cached(1)
@returns(SolutionServerSettings)
@arguments()
def get_solution_server_settings():
@db.non_transactional
def get():
ss = SolutionServerSettings.get_by_key_name("MainSettings")
if not ss:
ss = SolutionServerSettings(key_name="MainSettings")
return ss
return get()
from solutions.common.dal import get_solution_email_settings
logging.info("SolutionEmailSettings removed from cache.")
invalidate_cache(get_solution_email_settings)
@deserializer
def ds_solution_email_settings(stream):
return ds_model(stream, SolutionEmailSettings)
@serializer
def s_solution_email_settings(stream, app):
s_model(stream, app, SolutionEmailSettings)
register(SolutionEmailSettings, s_solution_email_settings,
ds_solution_email_settings)
class FileBlob(db.Model):
content = db.BlobProperty()
service_user_email = db.StringProperty()
class SolutionNewsScraperSettings(db.Model):
urls = db.StringListProperty(indexed=False)
@staticmethod
def create_key(service_user):
return db.Key.from_path(SolutionNewsScraperSettings.kind(),
service_user.email(),
def invalidateCache(self):
from solutions.common.dal.hints import get_solution_hints
logging.info("SolutionHints removed from cache.")
invalidate_cache(get_solution_hints)
class SolutionHintSettings(db.Model):
do_not_show_again = db.ListProperty(int, indexed=False)
@classmethod
def create_key(cls, service_user):
return db.Key.from_path(cls.kind(), service_user.email(),
parent=parent_key(service_user, SOLUTION_COMMON))
@property
def service_user(self):
return users.User(self.parent_key().name())
@deserializer
def ds_solution_hints(stream):
return ds_model(stream, SolutionHints)
@serializer
def s_solution_hints(stream, app):
s_model(stream, app, SolutionHints)
register(SolutionHints, s_solution_hints, ds_solution_hints)
#
# @@license_version:1.7@@
from google.appengine.ext import db
from mcfw.cache import cached
from mcfw.rpc import returns, arguments
from mcfw.serialization import deserializer, serializer, ds_model, s_model, \
register
class BackupSettings(db.Model):
ignore_models = db.StringListProperty()
server_secret_hash = db.StringProperty()
def put(self):
super(BackupSettings, self).put()
get_settings.invalidate_cache()
@deserializer
def ds_bs(stream):
return ds_model(stream, BackupSettings)
@serializer
def s_bs(stream, app):
s_model(stream, app, BackupSettings)
register(BackupSettings, s_bs, ds_bs)
@cached(1)
@returns(BackupSettings)
@arguments()
def get_settings():
return BackupSettings.get_by_key_name("settings")