package com.basic.security.manager.impl.cblite;
|
|
import android.text.TextUtils;
|
|
import com.basic.security.manager.impl.sqlite.SlBaseManager;
|
import com.basic.security.model.ModelAdapter;
|
import com.basic.security.utils.Constants;
|
import com.basic.security.utils.Page;
|
import com.couchbase.lite.DataSource;
|
import com.couchbase.lite.Database;
|
import com.couchbase.lite.Document;
|
import com.couchbase.lite.Expression;
|
import com.couchbase.lite.Meta;
|
import com.couchbase.lite.OrderBy;
|
import com.couchbase.lite.Ordering;
|
import com.couchbase.lite.Query;
|
import com.couchbase.lite.QueryBuilder;
|
import com.couchbase.lite.Result;
|
import com.couchbase.lite.ResultSet;
|
import com.couchbase.lite.SelectResult;
|
import com.couchbase.lite.Where;
|
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Vector;
|
|
public class BaseManager {
|
|
|
private static Database database;
|
|
protected static void saveMutableDocumentOnly1(ModelAdapter modelAdapter) {
|
try {
|
database.save(modelAdapter.couchbaseModel);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
protected static void save(ModelAdapter modelAdapter) {
|
try {
|
database.save(modelAdapter.couchbaseModel);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
protected static void delete(ModelAdapter modelAdapter) {
|
try {
|
database.delete(modelAdapter.couchbaseModel);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
@SuppressWarnings("all")
|
protected static ModelAdapter findOne(Expression expression) {
|
return findOne(expression, new Ordering[0]);
|
}
|
|
protected static ModelAdapter findOne(Expression expression, String sql) {
|
if (Constants.useCouchbase) {
|
return findOne(expression, new Ordering[0]);
|
} else {
|
return SlBaseManager.findOne(sql);
|
}
|
}
|
|
protected static ModelAdapter findOne(Expression expression, Ordering... orderings) {
|
ModelAdapter modelAdapter = new ModelAdapter();
|
try {
|
Map<String, Object> fields = new HashMap<>();
|
if (database == null) {
|
return modelAdapter;
|
}
|
Query query = QueryBuilder.select(SelectResult.all(), (SelectResult.expression(Meta.id)))
|
.from(DataSource.database(database))
|
.where(expression);
|
if (orderings != null && orderings.length > 0) {
|
query = ((Where) query).orderBy(orderings)
|
.limit(Expression.intValue(1));
|
}
|
ResultSet rows = query.execute();
|
Result row = null;
|
if ((row = rows.next()) != null) {
|
List columns = row.toList();
|
if (columns.size() == 2) {
|
if (columns.get(1) != null) {
|
modelAdapter = new ModelAdapter(database.getDocument(columns.get(1) + "").toMutable());
|
}
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return modelAdapter;
|
}
|
|
protected static List<ModelAdapter> findList(Expression expression) {
|
return findList(expression, null);
|
}
|
|
protected static List<ModelAdapter> findList(Expression expression, Ordering[] orderings) {
|
return findList(expression, orderings, null, null);
|
}
|
|
protected static List<ModelAdapter> findList(Expression expression, Ordering[] orderings, Integer limit) {
|
return findList(expression, orderings, limit, null);
|
}
|
|
protected static int count(Expression expression) {
|
try {
|
if (database == null) {
|
return 0;
|
}
|
Query query = QueryBuilder.select(SelectResult.all(), (SelectResult.expression(Meta.id)))
|
.from(DataSource.database(database))
|
.where(expression);
|
ResultSet rows = query.execute();
|
return rows.allResults().size();
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return 0;
|
}
|
|
protected static Page findPage(Expression expression, Integer pageSize, Integer pageNo) {
|
return findPage(expression, null, pageSize, pageNo);
|
}
|
|
protected static Page findPage(Expression expression, Ordering[] orderings, Integer pageSize, Integer pageNo) {
|
int total = count(expression);
|
List<ModelAdapter> data = findList(expression, orderings, pageSize, (pageNo - 1) * pageSize);
|
return new Page(total, data);
|
}
|
|
protected static List<ModelAdapter> findList(Expression expression, Ordering[] orderings, Integer limit, Integer offset) {
|
List<ModelAdapter> modelAdapterList = new Vector<>();
|
try {
|
if (database == null) {
|
return modelAdapterList;
|
}
|
Query query = QueryBuilder.select((SelectResult.expression(Meta.id)))
|
.from(DataSource.database(database))
|
.where(expression);
|
boolean hasOrdering = orderings != null && orderings.length > 0;
|
if (hasOrdering) {
|
query = ((Where) query).orderBy(orderings);
|
}
|
if (limit != null) {
|
if (offset != null) {
|
if (hasOrdering) {
|
query = ((OrderBy) query).limit(Expression.intValue(limit), Expression.intValue(offset));
|
} else {
|
query = ((Where) query).limit(Expression.intValue(limit), Expression.intValue(offset));
|
}
|
} else {
|
if (hasOrdering) {
|
query = ((OrderBy) query).limit(Expression.intValue(limit));
|
} else {
|
query = ((Where) query).limit(Expression.intValue(limit));
|
}
|
}
|
}
|
ResultSet rows = query.execute();
|
Result row = null;
|
|
while ((row = rows.next()) != null) {
|
List columns = row.toList();
|
ModelAdapter modelAdapter = new ModelAdapter(database.getDocument((String) columns.get(0)).toMutable());
|
if (modelAdapter != null) {
|
modelAdapterList.add(modelAdapter);
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return modelAdapterList;
|
}
|
|
protected static void deleteList(List<ModelAdapter> documentList) {
|
for (ModelAdapter document : documentList) {
|
delete(document);
|
}
|
}
|
|
protected static ModelAdapter findById(String id) {
|
if (TextUtils.isEmpty(id)) {
|
return null;
|
}
|
Document document = database.getDocument(id);
|
if (document != null) {
|
return new ModelAdapter(document.toMutable());
|
}
|
return null;
|
}
|
|
public static void setDatabase(Database database) {
|
BaseManager.database = database;
|
}
|
|
}
|
