fix orator primary key

sea/contrib/extensions/orator/cache_model.py

@@ -4,8 +4,8 @@
 from sea.contrib.extensions.cache import default_key
 
 
-def _related_caches_key(cls, id):
-    return 'related_caches.{}.{}.{}'.format(cls.__module__, cls.__name__, id)
+def _related_caches_key(cls, pk):
+    return 'related_caches.{}.{}.{}'.format(cls.__module__, cls.__name__, pk)
 
 
 def _model_caches_key(cache_version):
@@ -16,9 +16,9 @@ def wrapper(f, *args, **kwargs):
     return wrapper
 
 
-def _register_to_related_caches(f, id, cls, *args, **kwargs):
+def _register_to_related_caches(f, pk, cls, *args, **kwargs):
     cache = current_app.extensions.cache
-    key = cache._backend.trans_key(_related_caches_key(cls, id))
+    key = cache._backend.trans_key(_related_caches_key(cls, pk))
     redis = cache._backend._client
     cached_key = cache._backend.trans_key(
         f.make_cache_key(cls, *args, **kwargs))
@@ -34,14 +34,16 @@ def _find_register(f, ins, cls, *args, **kwargs):
 def _find_by_register(f, ins, cls, *args, **kwargs):
     if ins is None or ins is cache_ext.CacheNone:
         return True
-    return _register_to_related_caches(f, ins.id, cls, *args, **kwargs)
+    return _register_to_related_caches(f, getattr(ins, ins.__primary_key__),
+                                       cls, *args, **kwargs)
 
 
 def _bulk_register_to_related_caches(cls, key_model_map):
     cache = current_app.extensions.cache
     redis = cache._backend._client
     for cached_key, ins in key_model_map.items():
-        key = cache._backend.trans_key(_related_caches_key(cls, ins.id))
+        key = cache._backend.trans_key(
+            _related_caches_key(cls, getattr(ins, ins.__primary_key__)))
         cached_key = cache._backend.trans_key(cached_key)
         redis.sadd(key, cached_key)
         redis.expire(key, cache._backend.default_ttl)
@@ -51,16 +53,17 @@ def _bulk_register_to_related_caches(cls, key_model_map):
 def _clear_related_caches(instance):
     cache = current_app.extensions.cache
     key = cache._backend.trans_key(
-        _related_caches_key(instance.__class__, instance.id))
+        _related_caches_key(instance.__class__,
+                            getattr(instance, instance.__primary_key__)))
     redis = cache._backend._client
     related_caches = redis.smembers(key)
     if related_caches:
         redis.delete(*related_caches)
     return True
 
 
-def _id_is_list(cls, id, *args, **kwargs):
-    return isinstance(id, list)
+def _pk_is_list(cls, pk, *args, **kwargs):
+    return isinstance(pk, list)
 
 
 class ModelMeta(model.MetaModel):
@@ -73,29 +76,29 @@ def __new__(mcls, name, bases, kws):
         @classmethod
         @cache_ext.cached(fallbacked=_find_register,
                           cache_key=_model_caches_key(cache_version),
-                          unless=_id_is_list, cache_none=True)
-        def find(cls, id, columns=None):
-            if isinstance(id, list) and id and len(id) <= max_find_many_cache:
+                          unless=_pk_is_list, cache_none=True)
+        def find(cls, pk, columns=None):
+            if isinstance(pk, list) and pk and len(pk) <= max_find_many_cache:
                 cache = current_app.extensions.cache
-                keymap = {i: find.__func__.make_cache_key(cls, i) for i in id}
+                keymap = {i: find.__func__.make_cache_key(cls, i) for i in pk}
                 rv = cache.get_many(keymap.values())
-                models = dict(zip(id, rv))
-                missids = [
+                models = dict(zip(pk, rv))
+                misspks = [
                     i for i, m in models.items()
                     if m is None]
                 models = {
                     k: m for k, m in models.items()
                     if not (m is cache_ext.CacheNone or m is None)}
-                if not missids:
+                if not misspks:
                     return cls().new_collection(models.values())
-                missed = super(cls, cls).find(missids, columns)
-                missed = {m.id: m for m in missed}
+                missed = super(cls, cls).find(misspks, columns)
+                missed = {getattr(m, m.__primary_key__): m for m in missed}
                 models.update(missed)
                 key_model_map = {keymap[i]: m for i, m in missed.items()}
                 cache.set_many(key_model_map)
                 _bulk_register_to_related_caches(cls, key_model_map)
                 return cls().new_collection(list(models.values()))
-            return super(cls, cls).find(id, columns)
+            return super(cls, cls).find(pk, columns)
 
         @classmethod
         @cache_ext.cached(fallbacked=_find_by_register,