ionic2 - cómo usar lokijs-cordova-fs-adapter en ionic 2

Question

Estoy tratando de usar lokijs en mi aplicación iónica 2. Puedo usar lokijs.js. cuando intento persistir usando el adaptador, no puedo. estoy listo lokijs-cordova-fs-adapter se puede utilizar. pero cuando lo recomiendo en mi aplicación de la siguiente manera: obtengo un error que no puede localizar.

var LokiCordovaFSAdapter = require("./cordova-file-system-adapter");

intenté agregarlo en mi index.html e intenté crear el adaptador en mi archivo ts de la siguiente manera:

var adapter = new LokiCordovaFSAdapter({"prefix": "loki"});

obteniendo error de sintaxis en este caso. ¿Alguien puede dar un ejemplo sobre cómo usarlo?

Answer 1

Ciao, esto funciona en Ionic 2, así que paso a paso (lo hice dentro de un servicio ):

1. Verifique si ambas dependencias están instaladas:

   npm install lokijs --save
   npm install loki-cordova-fs-adapter --save

2. Declare e importe lo siguiente (antes de la declaración de clase):

   declare var require: any;
   var loki = require(''lokijs'');
   var LokiCordovaFSAdapter = require("loki-cordova-fs-adapter");
   var adapter = new LokiCordovaFSAdapter({"prefix": "loki"});

3. Use lo siguiente dentro de la clase de servicio:

   db: any; // LokiJS database
   pandas: any; // our DB''s document collection object
   
   constructor() {
     console.log("* inicializando...");
   
     this.db = new loki(''pandas.db'', {
       autoload: true,
       autoloadCallback: function() {
         console.log("* database loaded...")
       },
       autosave: true,
       autosaveInterval: 10 * 1000, //every 10 seconds
       adapter: adapter
     });
   }

4. Úselo (este código también está dentro de la clase de servicio):

   load() {
     let collection = this.db.getCollection(''pandas'');
     if (collection == null) {
       this.pandas = this.db.addCollection(''pandas'');
     } else {
       this.pandas = collection;
     }
   }
   
   pandaKamasutra() {
     console.log("* Save the pandas...");
     for (let i=0; i < 100; i++)
       this.pandas.insert({ name: ''Panda '' + (i+1), surename: "Whurgh " + i });
   }
   
   showPandas() {
     var results = this.pandas.find({});
     for (let r of results)
       console.log(`% id: ${r.$loki}, Panda: ${r.name}`);
   }

Pasé esta tarde resolviendo esto, después de nadar alrededor de los códigos LokiJS y lokijs-cordova-fs-adapter, encontré la ''luz'' en la documentación iónica aquí .

Espero que funcione para usted también. =]

Answer 2

Ver mi publicación en https://github.com/cosmith/loki-cordova-fs-adapter/issues/15 para saber cómo hacer esto en Ionic2 (publicado aquí).

Finalmente tengo esta ejecución en una aplicación Ionic2 (con mecanografía). Asegúrese de instalar el complemento cordova-plugin-file . A continuación, utilice el adaptador en la parte inferior como un proveedor normal en Ionic2 (lo tengo instalado en /src/lib/loki-cordova-fs-adapter en mi proyecto - llamado como index.ts ).

Para el uso, aquí hay un ejemplo:

import { Injectable } from ''@angular/core''
import { Platform } from ''ionic-angular''
import * as Loki from ''lokijs''
import * as LokiIndexedAdapter from ''lokijs/src/loki-indexed-adapter''
import { LokiCordovaFSAdapter } from ''lib/loki-cordova-fs-adapter''

const DATABASE_NAME: string = ''yourFilename.db.json''

@Injectable()
export class DatabaseProvider {

  private lokiOptions: any = {
    verbose: true,
    autosave: true,
    autosaveInterval: 60000,
    autoload: true
  }
  private db: any

  public constructor (private platform: Platform, private mobileAdapter: LokiCordovaFSAdapter) {}

  public load (successCallback: any): void {
    if (this.db) {
      successCallback()
    } else {
      this.db = this.loadDatabase(DATABASE_NAME, successCallback)
    }
  }

  private loadDatabase (databaseName: string, successCallback: any): any {
    this.lokiOptions.autoloadCallback = successCallback
    if (this.platform.is(''cordova'')) {
      this.lokiOptions.adapter = this.mobileAdapter
    } else {
      this.lokiOptions.adapter = new LokiIndexedAdapter()
    }
    return new Loki(databaseName, this.lokiOptions)
  }
}

Aquí está el adaptador:

import { Injectable } from ''@angular/core''
class LokiCordovaFSAdapterError extends Error {}

// const TAG: string = ''[LokiCordovaFSAdapter]''
declare var window: any
declare var cordova: any

@Injectable()
export class LokiCordovaFSAdapter {
  private options: any

  public constructor () {
    this.options = {''prefix'': ''loki''}
  }

  public saveDatabase (dbname: string, dbstring: string, callback: any): any {
    // console.log(TAG, ''saving database'')
    this._getFile(dbname,
      (fileEntry) => {
        fileEntry.createWriter(
          (fileWriter) => {
            fileWriter.onwriteend = () => {
              if (fileWriter.length === 0) {
                const blob: any = this._createBlob(dbstring, ''text/plain'')
                fileWriter.write(blob)
                callback()
              }
            }
            fileWriter.truncate(0)

          },
          (err) => {
            // console.log(TAG, ''error writing file'', err)
            throw new LokiCordovaFSAdapterError(''Unable to write file'' + JSON.stringify(err))
          }
        )
      },
      (err) => {
        // console.log(TAG, ''error getting file'', err)
        throw new LokiCordovaFSAdapterError(''Unable to get file'' + JSON.stringify(err))
      }
    )
  }

  public loadDatabase (dbname: string, callback: any): void {
    // console.log(TAG, ''loading database'')
    this._getFile(dbname,
      (fileEntry) => {
        // console.log(''got database file'')
        fileEntry.file((file) => {
          const reader: FileReader = new FileReader()
          reader.onloadend = (event: any) => {
            const contents: any = event.target.result
            if (contents.length === 0) {
              // console.log(TAG, ''database is empty'')
              callback(null)
            } else {
              // console.log(''sending back database'')
              callback(contents)
            }
          }
          reader.readAsText(file)
        }, (err) => {
          // console.log(TAG, ''error reading file'', err)
          callback(new LokiCordovaFSAdapterError(''Unable to read file'' + err.message))
        })
      },
      (err) => {
        // console.log(TAG, ''error getting file'', err)
        callback(new LokiCordovaFSAdapterError(''Unable to get file: '' + err.message))
      }
    )
  }

  public deleteDatabase (dbname: string, callback: any): void {
    window.resolveLocalFileSystemURL(cordova.file.dataDirectory,
      (dir) => {
        const fileName: string = this.options.prefix + ''__'' + dbname
        dir.getFile(fileName, { create: true },
          (fileEntry) => {
            fileEntry.remove(
              () => {
                callback()
              },
              (err) => {
                // console.log(TAG, ''error delete file'', err)
                throw new LokiCordovaFSAdapterError(''Unable delete file'' + JSON.stringify(err))
              }
            )
          },
          (err) => {
            // console.log(TAG, ''error delete database'', err)
            throw new LokiCordovaFSAdapterError(
              ''Unable delete database'' + JSON.stringify(err)
            )
          }
        )
      },
      (err) => {
        throw new LokiCordovaFSAdapterError(
          ''Unable to resolve local file system URL'' + JSON.stringify(err)
        )
      }
    )
  }

  private _getFile (name: string, handleSuccess: any, handleError: any): void {
    // console.log(TAG, ''Retrieving file: '' + name)
    window.resolveLocalFileSystemURL(cordova.file.dataDirectory,
      (dir) => {
        const fileName: string = this.options.prefix + ''__'' + name
        dir.getFile(fileName, { create: true }, handleSuccess, handleError)
      },
      (err) => {
        throw new LokiCordovaFSAdapterError(
          ''Unable to resolve local file system URL'' + JSON.stringify(err)
        )
      }
    )
  }

  // adapted from http://.com/questions/15293694/blob-constructor-browser-compatibility
  private _createBlob (data: string, datatype: string): any {
    let blob: any

    try {
      blob = new Blob([data], { type: datatype })
    } catch (err) {
      window.BlobBuilder = window.BlobBuilder ||
        window.WebKitBlobBuilder ||
        window.MozBlobBuilder ||
        window.MSBlobBuilder

      if (err.name === ''TypeError'' && window.BlobBuilder) {
        const bb: MSBlobBuilder = new window.BlobBuilder()
        bb.append(data)
        blob = bb.getBlob(datatype)
      } else if (err.name === ''InvalidStateError'') {
        // InvalidStateError (tested on FF13 WinXP)
        blob = new Blob([data], { type: datatype })
      } else {
        // We''re screwed, blob constructor unsupported entirely
        throw new LokiCordovaFSAdapterError(
          ''Unable to create blob'' + JSON.stringify(err)
        )
      }
    }
    return blob
  }
}