package foundation.dao;
|
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
|
import org.apache.logging.log4j.LogManager;
|
import org.apache.logging.log4j.Logger;
|
|
import foundation.data.entity.Entity;
|
import foundation.data.entity.EntitySet;
|
import foundation.data.meta.field.FieldsRuntime;
|
import foundation.data.object.DataObject;
|
import foundation.util.ContentBuilder;
|
import foundation.util.Util;
|
|
public class PackageStringMap implements Map<String, String> {
|
|
protected static Logger logger;
|
public static String Spliter = "__";
|
private DataPackage dataPackage;
|
private String nullResult;
|
private DataSource dataSource;
|
private Map<String, String> aliasMap;
|
private List<ReplaceObject> replaceList;
|
|
|
static {
|
logger = LogManager.getLogger(PackageStringMap.class);
|
}
|
|
public PackageStringMap(DataPackage dataPackage) {
|
this.dataPackage = dataPackage;
|
this.nullResult = null;
|
this.dataSource = DataSource.DB;
|
}
|
|
public void setNullResult(String nullResult) {
|
this.nullResult = nullResult;
|
}
|
|
public String onNullResult(String key) {
|
if (nullResult == null) {
|
return null;
|
}
|
|
logger.debug("get 【{}】, result is null", key);
|
return nullResult;
|
}
|
|
@Override
|
public int size() {
|
return dataPackage.allItems.size();
|
}
|
|
@Override
|
public boolean isEmpty() {
|
return dataPackage.isEmpty(DataSource.DB);
|
}
|
|
@Override
|
public boolean containsKey(Object key) {
|
if (key == null) {
|
return nullResult != null;
|
}
|
|
ValueName valueName = new ValueName(String.valueOf(key));
|
PackageItem item = getPackageItem(valueName.itemName);
|
|
if (item == null) {
|
return nullResult != null;
|
}
|
|
try {
|
DataObject dataObject = item.getDataObject();
|
FieldsRuntime fields = dataObject.getTableFieldMetas();
|
return fields.contains(valueName.fieldName) || (nullResult != null);
|
}
|
catch (Exception e) {
|
return false;
|
}
|
}
|
|
@Override
|
public boolean containsValue(Object value) {
|
return false;
|
}
|
|
@Override
|
public String get(Object key) {
|
if (key == null) {
|
return nullResult;
|
}
|
|
String name = String.valueOf(key);
|
ValueName valueName = new ValueName(name);
|
PackageItem item = getPackageItem(valueName.itemName);
|
|
if (item == null) {
|
return onNullResult(name);
|
}
|
|
String result = null;
|
|
if (item.isEntity(dataSource)) {
|
Entity entity = item.getEntity(dataSource);
|
result = getStringValue(entity, valueName.fieldName);
|
}
|
else if (item.isEntitySet(dataSource)) {
|
ContentBuilder builder = new ContentBuilder("，");
|
EntitySet entitySet = item.getEntitySet(dataSource);
|
|
for (Entity entity: entitySet) {
|
String value = entity.getString(valueName.fieldName);
|
if (value == null) {
|
value = onNullResult(name);
|
}
|
|
builder.append(value);
|
}
|
|
result = builder.toString();
|
}
|
|
if (result == null) {
|
result = onNullResult(name);
|
}
|
|
return result;
|
}
|
|
private PackageItem getPackageItem(String itemName) {
|
if (aliasMap != null) {
|
String original = aliasMap.get(itemName);
|
|
if (!Util.isEmpty(original)) {
|
itemName = original;
|
}
|
}
|
|
PackageItem result = dataPackage.getItem(itemName);
|
return result;
|
}
|
|
private String getStringValue(Entity entity, String fieldName) {
|
if (Util.isEmpty(fieldName)) {
|
return null;
|
}
|
|
if (replaceList != null) {
|
for (ReplaceObject replace: replaceList) {
|
fieldName = fieldName.replace(replace.original, replace.to);
|
}
|
}
|
|
String result = entity.getString(fieldName);
|
return result;
|
}
|
|
public void addAlias(String original, String alias) {
|
if (Util.isEmpty(original) || Util.isEmpty(alias)) {
|
return;
|
}
|
|
if (aliasMap == null) {
|
synchronized (this) {
|
if (aliasMap == null) {
|
aliasMap = new HashMap<String, String>();
|
}
|
}
|
}
|
|
original = original.toLowerCase();
|
aliasMap.put(alias, original);
|
}
|
|
public void addReplace(String original, String replace) {
|
if (Util.isEmpty(original)) {
|
return;
|
}
|
|
if (replaceList == null) {
|
synchronized (this) {
|
if (replaceList == null) {
|
replaceList = new ArrayList<ReplaceObject>();
|
}
|
}
|
}
|
|
ReplaceObject object = new ReplaceObject(original, replace);
|
replaceList.add(object);
|
}
|
|
@Override
|
public String put(String key, String value) {
|
return value;
|
}
|
|
@Override
|
public String remove(Object key) {
|
return null;
|
}
|
|
@Override
|
public void putAll(Map<? extends String, ? extends String> m) {
|
|
}
|
|
@Override
|
public void clear() {
|
|
}
|
|
@Override
|
public Set<String> keySet() {
|
return null;
|
}
|
|
@Override
|
public Collection<String> values() {
|
return null;
|
}
|
|
@Override
|
public Set<Entry<String, String>> entrySet() {
|
return null;
|
}
|
|
public static class ValueName {
|
|
private String itemName;
|
private String fieldName;
|
|
public ValueName(String name) {
|
int pos = name.indexOf(Spliter);
|
if (pos > 0) {
|
itemName = name.substring(0, pos);
|
fieldName = name.substring(pos + Spliter.length());
|
}
|
}
|
|
public boolean isValid() {
|
return !Util.isEmpty(itemName) && !Util.isEmpty(fieldName);
|
}
|
}
|
|
public static class ReplaceObject {
|
|
private String original;
|
private String to;
|
|
public ReplaceObject(String original, String to) {
|
this.original = original;
|
this.to = to;
|
}
|
}
|
|
}
|
