237 lines
7.2 KiB
Java
237 lines
7.2 KiB
Java
package net.tccn.meta;
|
|
|
|
import net.tccn.base.Kv;
|
|
import net.tccn.dbq.DbPlat;
|
|
import net.tccn.dbq.Field;
|
|
import net.tccn.dbq.fbean.FilterType;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Optional;
|
|
import java.util.function.BiFunction;
|
|
import java.util.function.Function;
|
|
import java.util.stream.Collectors;
|
|
|
|
/**
|
|
*
|
|
* Created by liangxianyou at 2019/1/7 13:31.
|
|
*/
|
|
public class MetaKit {
|
|
//基础数据缓存
|
|
private static List<MetaTable> metaTables;
|
|
private static List<MetaLink> metaLinks;
|
|
private static List<MetaService> metaServices;
|
|
|
|
private static List<DbPlat> dbPlats;
|
|
|
|
static {
|
|
metaTables = MetaTable.dao.find();
|
|
metaLinks = MetaLink.dao.find();
|
|
metaServices = MetaService.dao.find();
|
|
|
|
dbPlats = DbPlat.dao.find();
|
|
}
|
|
|
|
//----- get/set ----
|
|
public static List<MetaTable> getMetaTables() {
|
|
return metaTables;
|
|
}
|
|
|
|
public static void setMetaTables(List<MetaTable> metaTables) {
|
|
MetaKit.metaTables = metaTables;
|
|
}
|
|
|
|
public static List<MetaLink> getMetaLinks() {
|
|
return metaLinks;
|
|
}
|
|
|
|
public static void setMetaLinks(List<MetaLink> metaLinks) {
|
|
MetaKit.metaLinks = metaLinks;
|
|
}
|
|
|
|
public static List<MetaService> getMetaServices() {
|
|
return metaServices;
|
|
}
|
|
|
|
public static List<DbPlat> getDbPlats() {
|
|
return dbPlats;
|
|
}
|
|
|
|
public static void setDbPlats(List<DbPlat> dbPlats) {
|
|
MetaKit.dbPlats = dbPlats;
|
|
}
|
|
|
|
//-----------------------------------
|
|
public static void setMetaServices(List<MetaService> metaServices) {
|
|
MetaKit.metaServices = metaServices;
|
|
}
|
|
|
|
/**
|
|
* 通过 别名 查询 MetaTable
|
|
* @param alias
|
|
* @return
|
|
*/
|
|
private static MetaTable metaTableByAlias(String alias) {
|
|
Optional<MetaTable> table = metaTables.stream().filter(x -> x.getAlias().equals(alias)).findAny();
|
|
return table.orElse(null);
|
|
}
|
|
|
|
/**
|
|
* 通过 MetaLink[] 得到 MetaTable{}
|
|
* @param links
|
|
* @return {alias:table}
|
|
*/
|
|
private static Map<String, MetaTable> metaTables(List<MetaLink> links) {
|
|
Map map = new HashMap();
|
|
List<String> tables = links.stream().map(MetaLink::getTables).flatMap(Arrays::stream).distinct().collect(Collectors.toList());//tables
|
|
metaTables.stream().filter(x -> tables.contains(x.getAlias())).forEach(x -> {
|
|
map.put(x.getAlias(), x);
|
|
});
|
|
return map;
|
|
}
|
|
|
|
/**
|
|
* 通过 link._key 得到 MetaLink[]
|
|
* @param links
|
|
* @return
|
|
*/
|
|
private static List<MetaLink> metaLinks(List<String> links) {
|
|
if (links == null) {
|
|
return new ArrayList<>();
|
|
}
|
|
return metaLinks.stream().filter(x -> links.contains(x.getKey())).collect(Collectors.toList());
|
|
}
|
|
|
|
/**
|
|
* 构建完整的 MetaService
|
|
* @param name
|
|
* @return
|
|
*/
|
|
public static MetaService metaService(String name) {
|
|
Optional<MetaService> service = metaServices.stream().filter(x -> x.getName().equals(name)).findAny();
|
|
//处理业务逻辑
|
|
service.ifPresent(x -> {
|
|
x.setMetaTable(metaTableByAlias(x.getTable()));
|
|
x.setMetaLinks(metaLinks(x.getLinks()));
|
|
x.setTables(metaTables(x.getMetaLinks()));
|
|
});
|
|
return service.orElse(null);
|
|
}
|
|
|
|
//字段特征排序
|
|
public static BiFunction<MetaTable, String[], MetaTable> sortItem = (t, arr) -> {
|
|
List<Field> items = t.getItems();
|
|
|
|
//x 是跨越值
|
|
a:for (int i = 0, x = 0; i < arr.length; i++) {
|
|
int inx = i - x;
|
|
|
|
if (!items.get(inx).equals(arr[i])) {
|
|
Field tmp = items.get(inx);
|
|
for (int j = inx + 1; j < items.size(); j++) {
|
|
if (items.get(j).equals(arr[i])) {
|
|
items.set(inx, items.get(j));
|
|
items.set(j, tmp);
|
|
continue a;
|
|
}
|
|
}
|
|
|
|
//运行到这里，说明在 list 中找不到排序标识对应的数据， 让排序角标差值+1
|
|
x ++;
|
|
}
|
|
}
|
|
t.setItems(items);
|
|
return t;
|
|
};
|
|
|
|
public static Function<String, Field> getField = (n) -> {
|
|
String[] arr = n.split("[.]");
|
|
MetaTable metaTable = metaTableByAlias(arr[0]);
|
|
return metaTable.getItems().stream().filter(x -> x.getName().equals(arr[1])).findAny().orElse(null);
|
|
};
|
|
|
|
//listcfg
|
|
public static Function<MetaService, Kv> builderCfg = (m) -> {
|
|
List<String> shows = m.getShows();
|
|
List<Map> filters = m.getFilters();
|
|
|
|
List<Map> _filters = new ArrayList<>();
|
|
List<Map> _cols = new ArrayList<>();
|
|
|
|
//todo: 优化，批量操作
|
|
//build shows
|
|
shows.forEach(x -> {
|
|
Field field = getField.apply(x);
|
|
if (field != null) {
|
|
Kv col = Kv.of();
|
|
col.set("col", x.split("[.]]")[0] + field.showField());//a.createtime=dt
|
|
col.set("label", field.getLabel());
|
|
col.set("order", 1);//dev 是否支持排序
|
|
_cols.add(col);
|
|
}
|
|
});
|
|
|
|
//build filters
|
|
filters.forEach(x -> {
|
|
Kv filter = Kv.of();
|
|
Field filed = getField.apply(x.get("name") + "");
|
|
|
|
if (filed != null) {
|
|
filter.set("name", x.get("name"));
|
|
filter.set("label", filed.getLabel());
|
|
}
|
|
|
|
filter.set("inType", filed.getInType());
|
|
filter.set("inExt", filed.getInExt());
|
|
|
|
List<Kv> types = new ArrayList<>();
|
|
List<String> list = (List) x.get("filterType");
|
|
list.forEach(t -> {
|
|
FilterType type = FilterType.getFilterType(t);
|
|
if (type != null) {
|
|
types.add(Kv.of("name", t).set("remark", type.getRemark()));
|
|
}
|
|
});
|
|
|
|
filter.set("filterType", types);
|
|
Object checked = x.getOrDefault("checked", false);
|
|
filter.set("checked", checked instanceof Boolean ? checked : false);
|
|
_filters.add(filter);
|
|
});
|
|
|
|
/*shows.forEach(x -> {
|
|
_shows.add(Kv.of("name", x).set("label", getFieldLabel(x)));
|
|
});*/
|
|
|
|
Kv cfg = Kv.of();
|
|
cfg.set("title", m.getName())//业务名称
|
|
//.set("url", getUrl())
|
|
.set("cols", _cols)//展示的数据列
|
|
//.set("conditionLabel", "")
|
|
.set("filters", _filters);//查询过滤条件
|
|
|
|
return cfg;
|
|
};
|
|
|
|
//itemUpdate
|
|
public static BiFunction<MetaTable, List<Field>, MetaTable> itemUpdate = (t, fields) -> {
|
|
List<Field> items = t.getItems();
|
|
for (int i = 0; i < fields.size(); i++) {
|
|
for (int j = 0; j < items.size(); j++) {
|
|
if (items.get(j).equals(fields.get(i).getName())) {
|
|
items.set(j, fields.get(i));
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
};
|
|
|
|
|
|
public static MetaTable getMetaTableByKey(String key) {
|
|
return metaTables.stream().filter(x -> x.getKey().equals(key)).findAny().orElse(null);
|
|
};
|
|
}
|