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")