store with promise

Author: pablorsk

src/library/interfaces/cache.d.ts

@@ -5,7 +5,8 @@ export interface ICache {
 
     isCollectionExist(url: string): boolean;
     isCollectionLive(url: string, ttl: number): boolean;
-    getOrCreateCollection(url: string, use_store?: boolean): ICollection;
+    getOrCreateCollection(url: string): ICollection;
+    getCollectionFromStorePromise(url:string, collection: ICollection): ng.IPromise<ICollection>;
     setCollection(url: string, collection: ICollection): void;
     clearAllCollections(): boolean;
 

src/library/service.ts

@@ -82,7 +82,7 @@ export class Service extends ParentResourceService implements IService {
         let resource = this.getService().cachememory.getOrCreateResource(this.type, id, true);
         resource.is_loading = true;
         // exit if ttl is not expired
-        let temporal_ttl = params.ttl ? params.ttl : 0;
+        let temporal_ttl = params.ttl || 0; // this.schema.ttl
         if (this.getService().cachememory.isResourceLive(id, temporal_ttl)) {
             // we create a promise because we need return collection before
             // run success client function
@@ -134,10 +134,10 @@ export class Service extends ParentResourceService implements IService {
 
         // make request
         // if we remove this, dont work the same .all on same time (ej: <component /><component /><component />)
-        let tempororay_collection = this.getService().cachememory.getOrCreateCollection(path.getForCache(), true);
+        let tempororay_collection = this.getService().cachememory.getOrCreateCollection(path.getForCache());
 
         // MEMORY_CACHE
-        let temporal_ttl = params.ttl ? params.ttl : this.schema.ttl;
+        let temporal_ttl = params.ttl || this.schema.ttl;
         if (temporal_ttl >= 0 && this.getService().cachememory.isCollectionExist(path.getForCache())) {
             // get cached data and merge with temporal collection
             tempororay_collection.$source = 'memory';
@@ -162,8 +162,38 @@ export class Service extends ParentResourceService implements IService {
                 });
                 return tempororay_collection;
             }
+        } else {
+            // STORE
+            this.getService().cachememory.getCollectionFromStorePromise(path.getForCache(), tempororay_collection)
+            .then(
+                success => {
+                    tempororay_collection.$source = 'store';
+                    tempororay_collection.$is_loading = false;
+
+                    // localfilter getted data
+                    let localfilter = new LocalFilter();
+                    tempororay_collection = localfilter.filterCollection(tempororay_collection, params.localfilter);
+
+                    if (temporal_ttl >= 0 && Date.now() <= (tempororay_collection.$cache_last_update + temporal_ttl * 1000)) {
+                        this.runFc(fc_success, { data: success});
+                    } else {
+                        this.getAllFromHttpStorage(path, params, fc_success, fc_error, tempororay_collection);
+                    }
+                },
+                error => {
+                    this.getAllFromHttpStorage(path, params, fc_success, fc_error, tempororay_collection);
+                }
+            );
         }
 
+        return tempororay_collection;
+    }
+
+    /**
+    @deprecated
+    **/
+    private getAllFromHttpStorage(path, params, fc_success, fc_error, tempororay_collection: ICollection) {
+        // SERVER REQUEST
         tempororay_collection['$is_loading'] = true;
 
         // STORAGE_CACHE
@@ -192,8 +222,6 @@ export class Service extends ParentResourceService implements IService {
                 this.getAllFromServer(path, params, fc_success, fc_error, tempororay_collection);
             }
         );
-
-        return tempororay_collection;
     }
 
     private getAllFromServer(path, params, fc_success, fc_error, tempororay_collection: ICollection) {

src/library/services/cachememory.ts

@@ -24,13 +24,10 @@ export class CacheMemory implements ICache {
         return this.resources[id] && (Date.now() <= (this.resources[id].lastupdate + ttl * 1000));
     }
 
-    public getOrCreateCollection(url: string, use_store = false): ICollection {
+    public getOrCreateCollection(url: string): ICollection {
         if (!(url in this.collections)) {
             this.collections[url] = Base.newCollection();
             this.collections[url].$source = 'new';
-            if (use_store) {
-                this.getCollectionFromStore(url, this.collections[url]);
-            }
         }
         return this.collections[url];
     }
@@ -112,10 +109,20 @@ export class CacheMemory implements ICache {
         );
     }
 
-    private getCollectionFromStore(url:string, collection: ICollection): void {
+    public getCollectionFromStorePromise(url:string, collection: ICollection): ng.IPromise<object> {
+        var deferred = Core.injectedServices.$q.defer();
+        this.getCollectionFromStore(url, collection, deferred);
+        return deferred.promise;
+    }
+
+    private getCollectionFromStore(url:string, collection: ICollection, job_deferred: ng.IDeferred<ICollection> = null): void {
         let promise = Core.injectedServices.JsonapiStoreService.getObjet('collection.' + url);
         promise.then(success => {
-            if (success) {
+            try {
+                if (!success) {
+                    throw '';
+                }
+
                 // build collection from store and resources from memory
                 let all_ok = true;
                 for (let key in success.data) {
@@ -129,7 +136,8 @@ export class CacheMemory implements ICache {
                 }
                 if (all_ok) {
                     collection.$source = 'store';  // collection from storeservice, resources from memory
-                    return;
+                    job_deferred.resolve(collection);
+                    return ;
                 }
 
                 // request resources from store
@@ -144,19 +152,26 @@ export class CacheMemory implements ICache {
                 }
 
                 // build collection and resources from store
-                Core.injectedServices.$q.all(promises).then(success => {
+                Core.injectedServices.$q.all(promises).then(success2 => {
                     // just for precaution, we not rewrite server data
                     if (collection.$source !== 'new') {
-                        return ;
+                        throw '';
                     }
                     success.page ? collection.page = success.page : null;
                     for (let key in temporalcollection) {
                         let resource: IResource = temporalcollection[key];
                         collection.$source = 'store';  // collection and resources from storeservice
+                        collection.$cache_last_update = success._lastupdate_time;
                         collection[resource.id] = resource;  // collection from storeservice, resources from memory
                     }
+                    job_deferred.resolve(collection);
                 });
+            } catch (e) {
+                job_deferred.reject();
             }
+        },
+        error => {
+            job_deferred.reject();
         });
     }
 

src/library/sources/store.service.ts

@@ -34,7 +34,7 @@ export class StoreService {
                 // recorremos cada item y vemos si es tiempo de removerlo
                 this.allstore.getItem(key).then(success2 => {
                     // es tiempo de removerlo?
-                    if (Date.now() >= (success2._lastupdate_time + 12 * 3600 * 1000)) {
+                    if (Date.now() >= (success2._lastupdate_time + 24 * 3600 * 1000)) {
                         // removemos!!
                         this.allstore.removeItem(key);
                     }
@@ -43,11 +43,11 @@ export class StoreService {
         });
     }
 
-    public getObjet(key: string): any /* Promise<void> */ {
+    public getObjet(key: string): Promise<object> {
         return this.allstore.getItem('jsonapi.' + key);
     }
 
-    public getObjets(keys: Array<string>): any /* Promise<void> */ {
+    public getObjets(keys: Array<string>): Promise<object> {
         return this.allstore.getItem('jsonapi.' + keys[0]);
     }