@capgo/capacitor-data-storage-sqlite 6.0.0

package/CapacitorDataStorageSqlite.podspec

@@ -0,0 +1,18 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapacitorDataStorageSqlite'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Plugin/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target  = '13.0'
+  s.dependency 'Capacitor'
+  s.dependency 'SQLite.swift/SQLCipher'
+  s.swift_version = '5.1'
+end

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Capacitor Data Storage Sqlite
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/android/build.gradle

@@ -0,0 +1,63 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.6.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.5'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.5.1'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.2.1'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace "com.jeep.plugin.capacitor.capacitordatastoragesqlite"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 34
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 22
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 34
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+}
+
+repositories {
+    google()
+        mavenCentral()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+    implementation "androidx.coordinatorlayout:coordinatorlayout:1.1.0"
+    implementation 'net.zetetic:android-database-sqlcipher:4.4.3@aar'
+    implementation "androidx.sqlite:sqlite:2.1.0"
+
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    >
+</manifest>

package/android/src/main/java/com/jeep/plugin/capacitor/capacitordatastoragesqlite/CapacitorDataStorageSqlite.java

@@ -0,0 +1,387 @@
+package com.jeep.plugin.capacitor.capacitordatastoragesqlite;
+
+import android.content.Context;
+import com.getcapacitor.JSObject;
+import com.jeep.plugin.capacitor.capacitordatastoragesqlite.cdssUtils.Data;
+import com.jeep.plugin.capacitor.capacitordatastoragesqlite.cdssUtils.ImportExportJson.JsonStore;
+import com.jeep.plugin.capacitor.capacitordatastoragesqlite.cdssUtils.ImportExportJson.JsonTable;
+import com.jeep.plugin.capacitor.capacitordatastoragesqlite.cdssUtils.StorageDatabaseHelper;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+public class CapacitorDataStorageSqlite {
+
+  private StorageDatabaseHelper mDb;
+  private Context context;
+
+  public CapacitorDataStorageSqlite(Context context) {
+    this.context = context;
+  }
+
+  /**
+   * Echo
+   *
+   * @param value
+   * @return String
+   */
+  public String echo(String value) {
+    return value;
+  }
+
+  public void openStore(
+    String dbName,
+    String tableName,
+    Boolean encrypted,
+    String inMode,
+    int version
+  ) throws Exception {
+    try {
+      mDb = new StorageDatabaseHelper(
+        context,
+        dbName + "SQLite.db",
+        tableName,
+        encrypted,
+        inMode,
+        version
+      );
+      if (mDb != null) {
+        mDb.open();
+        if (mDb.isOpen) {
+          return;
+        } else {
+          throw new Exception("mDb is not opened");
+        }
+      } else {
+        throw new Exception("mDb is null");
+      }
+    } catch (Exception e) {
+      throw new Exception(e.getMessage());
+    }
+  }
+
+  public void closeStore(String dbName) throws Exception {
+    String database = dbName + "SQLite.db";
+    if (mDb != null && mDb.isOpen && mDb.getStoreName().equals(database)) {
+      try {
+        mDb.close();
+        return;
+      } catch (Exception e) {
+        throw new Exception(e.getMessage());
+      }
+    } else {
+      throw new Exception("mDb " + dbName + " is not opened or null");
+    }
+  }
+
+  public boolean isStoreOpen(String dbName) throws Exception {
+    String database = dbName + "SQLite.db";
+    if (mDb != null && mDb.getStoreName().equals(database)) {
+      return mDb.isOpen;
+    } else {
+      throw new Exception("mDb " + dbName + " is not the current one or null");
+    }
+  }
+
+  public void set(String key, String value) throws Exception {
+    if (mDb != null && mDb.isOpen) {
+      try {
+        Data data = new Data();
+        data.name = key;
+        data.value = value;
+        mDb.set(data);
+        return;
+      } catch (Exception e) {
+        throw new Exception(e.getMessage());
+      }
+    } else {
+      throw new Exception("mDb is not opened or null");
+    }
+  }
+
+  public String get(String key) throws Exception {
+    if (mDb != null && mDb.isOpen) {
+      try {
+        Data data = mDb.get(key);
+        if (data.id == null) {
+          return "";
+        } else {
+          return data.value;
+        }
+      } catch (Exception e) {
+        throw new Exception(e.getMessage());
+      }
+    } else {
+      throw new Exception("mDb is not opened or null");
+    }
+  }
+
+  public void remove(String name) throws Exception {
+    if (mDb != null && mDb.isOpen) {
+      try {
+        mDb.remove(name);
+        return;
+      } catch (Exception e) {
+        throw new Exception(e.getMessage());
+      }
+    } else {
+      throw new Exception("mDb is not opened or null");
+    }
+  }
+
+  public void clear() throws Exception {
+    if (mDb != null && mDb.isOpen) {
+      try {
+        mDb.clear();
+        return;
+      } catch (Exception e) {
+        throw new Exception(e.getMessage());
+      }
+    } else {
+      throw new Exception("mDb is not opened or null");
+    }
+  }
+
+  public boolean iskey(String name) throws Exception {
+    boolean ret = false;
+    if (mDb != null && mDb.isOpen) {
+      try {
+        ret = mDb.iskey(name);
+        return ret;
+      } catch (Exception e) {
+        throw new Exception(e.getMessage());
+      }
+    } else {
+      throw new Exception("mDb is not opened or null");
+    }
+  }
+
+  public String[] keys() throws Exception {
+    if (mDb != null && mDb.isOpen) {
+      try {
+        List<String> resKeys = mDb.keys();
+        String[] keyArray = resKeys.toArray(new String[resKeys.size()]);
+        return keyArray;
+      } catch (Exception e) {
+        throw new Exception(e.getMessage());
+      }
+    } else {
+      throw new Exception("mDb is not opened or null");
+    }
+  }
+
+  public String[] values() throws Exception {
+    if (mDb != null && mDb.isOpen) {
+      try {
+        List<String> resValues = mDb.values();
+        String[] valueArray = resValues.toArray(new String[resValues.size()]);
+        return valueArray;
+      } catch (Exception e) {
+        throw new Exception(e.getMessage());
+      }
+    } else {
+      throw new Exception("mDb is not opened or null");
+    }
+  }
+
+  public String[] filtervalues(String filter) throws Exception {
+    if (mDb != null && mDb.isOpen) {
+      try {
+        List<String> resValues = mDb.filtervalues(filter);
+        String[] valueArray = resValues.toArray(new String[resValues.size()]);
+        return valueArray;
+      } catch (Exception e) {
+        throw new Exception(e.getMessage());
+      }
+    } else {
+      throw new Exception("mDb is not opened or null");
+    }
+  }
+
+  public JSObject[] keysvalues() throws Exception {
+    if (mDb != null && mDb.isOpen) {
+      try {
+        List<Data> resKeysValues = mDb.keysvalues();
+        JSObject[] jsObjArray = new JSObject[resKeysValues.size()];
+
+        for (int i = 0; i < resKeysValues.size(); i++) {
+          JSObject res = new JSObject();
+          res.put("key", resKeysValues.get(i).name);
+          res.put("value", resKeysValues.get(i).value);
+          jsObjArray[i] = res;
+        }
+        return jsObjArray;
+      } catch (Exception e) {
+        throw new Exception(e.getMessage());
+      }
+    } else {
+      throw new Exception("mDb is not opened or null");
+    }
+  }
+
+  public void setTable(String table) throws Exception {
+    if (mDb != null && mDb.isOpen) {
+      try {
+        mDb.setTable(table, true);
+        return;
+      } catch (Exception e) {
+        throw new Exception(e.getMessage());
+      }
+    } else {
+      throw new Exception("mDb is not opened or null");
+    }
+  }
+
+  public boolean isTable(String table) throws Exception {
+    boolean ret = false;
+    if (mDb != null && mDb.isOpen) {
+      try {
+        ret = mDb.isTable(table);
+        return ret;
+      } catch (Exception e) {
+        throw new Exception(e.getMessage());
+      }
+    } else {
+      throw new Exception("mDb is not opened or null");
+    }
+  }
+
+  public String[] tables() throws Exception {
+    if (mDb != null && mDb.isOpen) {
+      try {
+        List<String> resTables = mDb.tables();
+        String[] tableArray = resTables.toArray(new String[resTables.size()]);
+        return tableArray;
+      } catch (Exception e) {
+        throw new Exception(e.getMessage());
+      }
+    } else {
+      throw new Exception("mDb is not opened or null");
+    }
+  }
+
+  public void deleteTable(String table) throws Exception {
+    if (mDb != null && mDb.isOpen) {
+      try {
+        mDb.deleteTable(table);
+        return;
+      } catch (Exception e) {
+        throw new Exception(e.getMessage());
+      }
+    } else {
+      throw new Exception("mDb is not opened or null");
+    }
+  }
+
+  public void deleteStore(String dbName) throws Exception {
+    try {
+      context.deleteDatabase(dbName + "SQLite.db");
+      context.deleteFile(dbName + "SQLite.db");
+      File databaseFile = context.getDatabasePath(dbName + "SQLite.db");
+      if (databaseFile.exists()) {
+        throw new Exception("failed to delete the store");
+      } else {
+        return;
+      }
+    } catch (Exception e) {
+      throw new Exception(e.getMessage());
+    }
+  }
+
+  public boolean isStoreExists(String dbName) throws Exception {
+    boolean ret = false;
+    try {
+      File databaseFile = context.getDatabasePath(dbName + "SQLite.db");
+      if (databaseFile.exists()) ret = true;
+      return ret;
+    } catch (Exception e) {
+      throw new Exception(e.getMessage());
+    }
+  }
+
+  public Boolean isJsonValid(String parsingData) throws Exception {
+    try {
+      JSObject jsonObject = new JSObject(parsingData);
+      JsonStore jsonSQL = new JsonStore();
+      Boolean isValid = jsonSQL.isJsonStore(jsonObject);
+      return isValid;
+    } catch (Exception e) {
+      throw new Exception(e.getMessage());
+    }
+  }
+
+  public JSObject importFromJson(String parsingData) throws Exception {
+    try {
+      JSObject retObj = new JSObject();
+      JSObject jsonObject = new JSObject(parsingData);
+      JsonStore jsonSQL = new JsonStore();
+      Boolean isValid = jsonSQL.isJsonStore(jsonObject);
+      if (!isValid) {
+        String msg = "Stringify Json Object not Valid";
+        throw new Exception(msg);
+      }
+      int totalChanges = 0;
+      String dbName = jsonSQL.getDatabase();
+      Boolean encrypted = jsonSQL.getEncrypted();
+      String inMode = "";
+      if (encrypted) {
+        inMode = "secret";
+      }
+      ArrayList<JsonTable> tables = jsonSQL.getTables();
+      for (JsonTable table : tables) {
+        // open the database
+        mDb = new StorageDatabaseHelper(
+          context,
+          dbName + "SQLite.db",
+          table.getName(),
+          encrypted,
+          inMode,
+          1
+        );
+        if (mDb != null) {
+          mDb.open();
+          if (mDb.isOpen) {
+            int changes = mDb.importFromJson(table.getValues());
+            mDb.close();
+            if (changes < 1) {
+              throw new Exception("changes < 1");
+            } else {
+              totalChanges += changes;
+            }
+          } else {
+            throw new Exception("mDb is not opened");
+          }
+        } else {
+          throw new Exception("mDb is null");
+        }
+      }
+      retObj.put("changes", totalChanges);
+      return retObj;
+    } catch (Exception e) {
+      String msg = "importFromJson : " + e.getMessage();
+      throw new Exception(msg);
+    }
+  }
+
+  public JSObject exportToJson() throws Exception {
+    if (mDb != null && mDb.isOpen) {
+      try {
+        JSObject ret = mDb.exportToJson();
+        JsonStore jsonSQL = new JsonStore();
+        Boolean isValid = jsonSQL.isJsonStore(ret);
+        if (isValid) {
+          return ret;
+        } else {
+          String msg = "ExportToJson: return Obj is not a JsonStore Obj";
+          throw new Exception(msg);
+        }
+      } catch (Exception e) {
+        String msg = "ExportToJson " + e.getMessage();
+        throw new Exception(msg);
+      }
+    } else {
+      String msg = "mDb is not opened or null ";
+      throw new Exception(msg);
+    }
+  }
+}