public void OnSelectHost() {
MoveHost model = (MoveHost) getWindow();
if (model.getProgress() != null) {
return;
}
if (!model.Validate()) {
return;
}
model.setSelectedHosts(new java.util.ArrayList<VDS>());
for (EntityModel a : Linq.<EntityModel>Cast(model.getItems())) {
if (a.getIsSelected()) {
model.getSelectedHosts().add((VDS) a.getEntity());
}
}
VDSGroup cluster = (VDSGroup) model.getCluster().getSelectedItem();
java.util.ArrayList<VdcActionParametersBase> paramerterList =
new java.util.ArrayList<VdcActionParametersBase>();
for (VDS host : model.getSelectedHosts()) {
// Try to change host's cluster as neccessary.
if (host.getvds_group_id() != null && !host.getvds_group_id().equals(cluster.getId())) {
paramerterList.add(new ChangeVDSClusterParameters(cluster.getId(), host.getId()));
}
}
model.StartProgress(null);
Frontend.RunMultipleAction(
VdcActionType.ChangeVDSCluster,
paramerterList,
new IFrontendMultipleActionAsyncCallback() {
@Override
public void Executed(FrontendMultipleActionAsyncResult result) {
ClusterGuideModel clusterGuideModel = (ClusterGuideModel) result.getState();
java.util.ArrayList<VDS> hosts =
((MoveHost) clusterGuideModel.getWindow()).getSelectedHosts();
java.util.ArrayList<VdcReturnValueBase> retVals =
(java.util.ArrayList<VdcReturnValueBase>) result.getReturnValue();
if (retVals != null && hosts.size() == retVals.size()) {
int i = 0;
for (VDS selectedHost : hosts) {
if (selectedHost.getstatus() == VDSStatus.PendingApproval
&& retVals.get(i) != null
&& retVals.get(i).getSucceeded()) {
Frontend.RunAction(
VdcActionType.ApproveVds, new ApproveVdsParameters(selectedHost.getId()));
}
}
i++;
}
clusterGuideModel.getWindow().StopProgress();
clusterGuideModel.Cancel();
clusterGuideModel.PostAction();
}
},
this);
}
public MoudleModel() {
super();
entityModels = new ArrayList<EntityModel>();
EntityModel entityModel = new EntityModel();
entityModel.setCode(EntityModel.ASSIST_TABLE_ALIAS);
entityModel.setTable(EntityModel.ASSIST_TABLE);
entityModels.add(entityModel);
}
static void processProperties(
JSONObject entity, ViewEntityModel viewModel, DbContext ctx, EntityModelVersion version) {
JSONArray properties = entity.getJSONArray("properties");
for (int p = 0; p < properties.length(); p++) {
JSONObject property = properties.getJSONObject(p);
EntityModel child;
String alias;
if (property.has("model")) {
String model = property.getString("model");
if (model.equals(viewModel.getRootModel().getName())) {
child = viewModel.getRootModel();
alias = viewModel.getRootAlias();
} else {
ViewEntityModel.EntityRelationship relationship =
viewModel.getModel(property.getString("model"));
child = relationship.getModel();
alias = relationship.getAlias();
}
} else {
child = viewModel;
alias = viewModel.getRootAlias();
}
String propertyName = property.getString("name");
if ("*".equals(propertyName)) {
for (EntityProperty childProperty : child.getAllProperties(version.getVersion())) {
String name = childProperty.getName();
if (childProperty.getModel() instanceof ViewEntityModel
&& childProperty.getAlias() != null) name = childProperty.getAlias();
EntityProperty cp =
version.newProperty(
childProperty.getType(), name, childProperty.isNullable(), null, null);
cp.setModelAlias(alias);
cp.setOriginalModel(childProperty.getModel());
}
} else {
EntityProperty childProperty = null;
try {
childProperty = child.getProperty(version.getVersion(), propertyName);
} catch (IllegalArgumentException ignore) {
}
EntityProperty cp =
version.newProperty(
childProperty == null
? EntityProperty.Type.valueOf(property.getString("type"))
: childProperty.getType(),
property.getString("name"),
!property.has("nullable") || property.getBoolean("nullable"),
property.has("alias") ? property.getString("alias") : null,
property.has("sql") ? property.getString("sql") : null);
cp.setModelAlias(alias);
if (childProperty != null) cp.setOriginalModel(childProperty.getModel());
}
}
}
static List<EntityProperty> getProperties(JSONObject query, EntityModel m, Version version) {
List<EntityProperty> props;
if (query.has("properties")) {
props = new ArrayList<EntityProperty>();
JSONArray names = query.getJSONArray("properties");
for (int n = 0; n < names.length(); n++) {
props.add(m.getProperty(version, names.getString(n)));
}
} else props = m.getAllProperties(version);
return props;
}
/**
* 得到表名通过code
*
* @param code
* @return
*/
public String getTableByCode(String code) {
Assert.notNull(code);
if (entityModels != null) {
for (EntityModel entityModel : entityModels) {
if (code.equals(entityModel.getCode())) {
return entityModel.getTable();
}
}
}
return null;
}
public static EntityModel newModel(
Version version, String name, String packageName, boolean render) {
EntityModel model = MODELS.get(packageName + ".model." + name);
if (model == null) {
model = new EntityModel(version, name, packageName, render);
MODELS.put(model.getFullName(), model);
} else {
model.newVersion(version);
}
return model;
}
public UserPortalLoginModel() {
setChangePasswordCommand(new UICommand("ChangePassword", this));
setNewPassword(new EntityModel());
setVerifyPassword(new EntityModel());
EntityModel tempVar = new EntityModel();
tempVar.setEntity(true);
setIsENGINEUser(tempVar);
EntityModel tempVar2 = new EntityModel();
tempVar2.setEntity(true);
setIsAutoConnect(tempVar2);
}
public void OnManage() {
ListModel model = (ListModel) getWindow();
java.util.ArrayList<EntityModel> items = Linq.<EntityModel>Cast(model.getItems());
java.util.ArrayList<network> networks = Linq.<network>Cast(getItems());
if (getEntity() == null) {
Cancel();
return;
}
java.util.ArrayList<VdcActionParametersBase> prms1 =
new java.util.ArrayList<VdcActionParametersBase>();
for (EntityModel a : items) {
boolean value = false;
for (network b : networks) {
if (b.getId().equals(((network) a.getEntity()).getId())) {
value = true;
break;
}
}
if (a.getIsSelected() && !value) {
prms1.add(new AttachNetworkToVdsGroupParameter(getEntity(), (network) a.getEntity()));
}
}
// Call the command only if necessary (i.e. only if there are paramters):
if (prms1.size() > 0) {
Frontend.RunMultipleAction(VdcActionType.AttachNetworkToVdsGroup, prms1);
}
java.util.ArrayList<VdcActionParametersBase> prms2 =
new java.util.ArrayList<VdcActionParametersBase>();
for (EntityModel a : items) {
boolean value = true;
for (network b : networks) {
if (b.getId().equals(((network) a.getEntity()).getId())) {
value = false;
break;
}
}
if (!a.getIsSelected() && !value) {
prms2.add(new AttachNetworkToVdsGroupParameter(getEntity(), (network) a.getEntity()));
}
}
// Call the command only if necessary (i.e. only if there are paramters):
if (prms2.size() > 0) {
Frontend.RunMultipleAction(VdcActionType.DetachNetworkToVdsGroup, prms2);
}
Cancel();
}
@Override
public void eventRaised(Event<? extends EventArgs> ev, Object sender, EventArgs args) {
super.eventRaised(ev, sender, args);
entityModel.eventRaised(ev, sender, args);
if (ev.matchesDefinition(RegistrationResult.RetrievedEventDefinition)) {
asyncResult_Retrieved();
}
if (ev.matchesDefinition(ProvideTickEvent.definition)) {
syncSearch();
}
}
void renderMappers(Configuration cfg) throws IOException {
for (EntityModel model : getAllModels()) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("model", model);
params.put("version", currentVersion());
for (Query query : model.getSelectQueries()) {
params.put("query", query);
writeFile(
defaultPackageName + ".mapper.cursor",
model.getName() + query.getName() + "Mapper",
getTemplate(cfg, "java", "cursorobjectmapper"),
params);
}
params.put("prefix", "insert");
params.put("suffix", "");
writeFile(
defaultPackageName + ".mapper.content.insert",
model.getName() + "Mapper",
getTemplate(cfg, "java", "contentvaluesmapper"),
params);
for (Query query : model.getUpdateQueries()) {
params.put("prefix", "update");
params.put("suffix", query.getName());
writeFile(
defaultPackageName + ".mapper.content.update",
model.getName() + query.getName() + "Mapper",
getTemplate(cfg, "java", "contentvaluesmapper"),
params);
}
}
}
public ArrayList<EntityModel> getAllUsersEntity(String userId) {
ArrayList<EntityModel> entityModels = new ArrayList<EntityModel>();
String sql = "SELECT * FROM " + table_stats + " WHERE " + KEY_UserID + " = '" + userId + "'";
SQLiteDatabase database = this.getReadableDatabase();
Cursor cursor = database.rawQuery(sql, null);
if (cursor.moveToFirst()) {
do {
EntityModel entityModel = new EntityModel();
entityModel.setFollowings(cursor.getLong(0));
entityModel.setFollowers(cursor.getLong(1));
entityModel.setMutuals(cursor.getLong(2));
entityModel.setNonfollwers(cursor.getLong(3));
entityModel.setMillis(cursor.getLong(4));
entityModels.add(entityModel);
} while (cursor.moveToNext());
}
return entityModels;
}
void renderModels(Configuration cfg) throws IOException {
List<EntityModel> allModels = getAllModels();
Map<String, Object> params = new HashMap<String, Object>();
params.put("models", allModels);
params.put("packageName", defaultPackageName + ".providers");
params.put("authority", authority);
params.put("version", currentVersion());
writeFile(
defaultPackageName + ".providers", "Schemas", getTemplate(cfg, "java", "schema"), params);
for (EntityModel model : allModels) {
if (!model.isRender()) continue;
params = new HashMap<String, Object>();
params.put("model", model);
params.put("version", currentVersion());
params.put("properties", model.getAllProperties(null));
writeFile(
model.getPackageName() + ".model",
model.getName(),
getTemplate(cfg, "java", "model"),
params);
}
}
public void addUserEntity(EntityModel entityModel, String userId) {
SQLiteDatabase liteDatabase = this.getWritableDatabase();
ContentValues contentValues = new ContentValues();
contentValues.put(KEY_FOLLOWING, entityModel.getFollowings());
contentValues.put(KEY_FOLLOWERS, entityModel.getFollowers());
contentValues.put(KEY_MUTUAL, entityModel.getMutuals());
contentValues.put(KEY_NONFOLLWERS, entityModel.getNonfollwers());
contentValues.put(KEY_TIMESTAMP, entityModel.getMillis());
contentValues.put(KEY_UserID, MainSingleTon.currentUserModel.getUserid());
liteDatabase.insert(table_stats, null, contentValues);
System.out.println("entityModel = " + entityModel);
}
public boolean Validate() {
getDescription().ValidateEntity(new IValidation[] {new NotEmptyValidation()});
boolean isDisksValid = false;
setMessage(null);
if (getDisks() != null) {
for (EntityModel a : getDisks()) {
if (a.getIsSelected()) {
isDisksValid = true;
break;
}
}
if (!isDisksValid) {
setMessage("At least one disk must be marked.");
return false;
}
return getDescription().getIsValid();
}
return getDescription().getIsValid();
}
@Override
public void setEntity(E value) {
if (getEntity() == null) {
entityModel.setEntity(value);
return;
}
// Equals doesn't always has the same outcome as checking the ids of the elements.
if (value != null) {
if (!((IVdcQueryable) value)
.getQueryableId()
.equals(((IVdcQueryable) getEntity()).getQueryableId())) {
entityModel.setEntity(value);
return;
}
}
if (!getEntity().equals(value)) {
entityModel.setEntity(value);
return;
}
setEntity(value, false);
}
String renderDropStructure(EntityModel model, Configuration cfg) throws IOException {
StringWriter out = new StringWriter();
try {
Map<String, Object> params = new HashMap<String, Object>();
params.put("model", model);
if (model instanceof ViewEntityModel)
getTemplate(cfg, "sql", "model_drop_view").process(params, out);
else if (model.getExtensions().contains("fts3"))
getTemplate(cfg, "sql", "model_drop_fts3").process(params, out);
else getTemplate(cfg, "sql", "model_drop").process(params, out);
} catch (TemplateException err) {
throw new IOException(err);
}
return out.toString().replaceAll("\\n", "").replaceAll("\\r", "");
}
static void processQueries(JSONObject queries, EntityModel m, Version version) {
if (queries != null) {
if (queries.has("select")) {
JSONArray select = queries.getJSONArray("select");
for (int s = 0; s < select.length(); s++) {
JSONObject query = select.getJSONObject(s);
List<EntityProperty> props = getProperties(query, m, version);
m.newSelectQuery(
query.getString("id"),
query.isNull("selection") ? null : query.getString("selection"),
query.isNull("orderBy") ? null : query.getString("orderBy"),
props);
}
}
if (queries.has("update")) {
JSONArray update = queries.getJSONArray("update");
for (int s = 0; s < update.length(); s++) {
JSONObject query = update.getJSONObject(s);
List<EntityProperty> props = getProperties(query, m, version);
m.newUpdateQuery(
query.getString("id"),
query.isNull("selection") ? null : query.getString("selection"),
props);
}
}
if (queries.has("delete")) {
JSONArray delete = queries.getJSONArray("delete");
for (int s = 0; s < delete.length(); s++) {
JSONObject query = delete.getJSONObject(s);
m.newDeleteQuery(
query.getString("id"),
query.isNull("selection") ? null : query.getString("selection"));
}
}
}
}
public void PostManage(java.util.ArrayList<network> networkList, ListModel model) {
Collections.sort(networkList, new Linq.NetworkByNameComparer());
java.util.ArrayList<EntityModel> items = new java.util.ArrayList<EntityModel>();
for (network a : networkList) {
if (!a.getname().equals("engine")) {
EntityModel tempVar = new EntityModel();
tempVar.setEntity(a);
tempVar.setTitle(a.getname());
items.add(tempVar);
}
}
model.setItems(items);
boolean noItems = items.isEmpty();
java.util.ArrayList<network> networks = Linq.<network>Cast(getItems());
java.util.ArrayList<EntityModel> selectedItems = new java.util.ArrayList<EntityModel>();
for (EntityModel item : items) {
network net = (network) item.getEntity();
boolean value = false;
for (network a : networks) {
if (a.getId().equals(net.getId())) {
value = true;
break;
}
}
item.setIsSelected(value);
if (value) {
selectedItems.add(item);
}
}
model.setSelectedItems(selectedItems);
UICommand tempVar2 = new UICommand("Cancel", this);
tempVar2.setTitle("Cancel");
tempVar2.setIsDefault(noItems);
tempVar2.setIsCancel(true);
model.getCommands().add(tempVar2);
if (!noItems) {
UICommand tempVar3 = new UICommand("OnManage", this);
tempVar3.setTitle("OK");
tempVar3.setIsDefault(true);
model.getCommands().add(0, tempVar3);
}
}
@Override
public Event<EventArgs> getEntityChangedEvent() {
return entityModel.getEntityChangedEvent();
}
@Override
public E getEntity() {
return entityModel.getEntity();
}
protected void setEntity(E value, boolean fireEvents) {
entityModel.setEntity(value, fireEvents);
}
// overriden from EntityModel
public void setName(String aName) {
if (this.hasUniqueName(aName)) {
super.setName(aName);
}
}
public static void setCatalog(EntityModel model, PersistCatalog catalog) {
model.setCatalog(catalog);
}
void renderDbHelper(Configuration cfg) throws IOException {
Version lastVersion = null;
for (Version version : versions) {
if (lastVersion != null) {
List<String> sql = new ArrayList<String>();
switch (version.getType()) {
case DIFF:
{
Version.Diff diff = lastVersion.diff(version);
for (EntityModel removed : diff.removedModels) {
if (removed instanceof ViewEntityModel) sql.add(renderDropStructure(removed, cfg));
}
for (EntityModel removed : diff.removedModels) {
if (!(removed instanceof ViewEntityModel))
sql.add(renderDropStructure(removed, cfg));
}
for (EntityIndex removed : diff.removedIndexes) {
sql.add(renderDropIndex(removed, cfg));
}
for (EntityModel added : diff.addedModels) {
if (!(added instanceof ViewEntityModel))
sql.add(renderCreateStructure(added, added.getProperties(version), cfg));
}
for (EntityModel added : diff.addedModels) {
if (added instanceof ViewEntityModel)
sql.add(renderCreateStructure(added, added.getProperties(version), cfg));
}
for (EntityIndex added : diff.addedIndexes) {
sql.add(renderCreateIndex(added, cfg));
}
diffProperties(sql, lastVersion, version, diff, cfg);
break;
}
case DIFF_PROPERTIES:
{
Version.Diff diff = lastVersion.diff(version);
diffProperties(sql, lastVersion, version, diff, cfg);
break;
}
case ADD_MODELS:
for (EntityModel model : version.getModels()) {
sql.add(renderCreateStructure(model, model.getProperties(version), cfg));
for (EntityIndex index : model.getIndexes(version)) {
sql.add(renderCreateIndex(index, cfg));
}
}
break;
case DROP_MODELS:
for (EntityModel removed : version.getModels()) {
if (removed instanceof ViewEntityModel) sql.add(renderDropStructure(removed, cfg));
}
for (EntityModel removed : version.getModels()) {
if (!(removed instanceof ViewEntityModel)) sql.add(renderDropStructure(removed, cfg));
}
break;
case ADD_PROPERTIES:
{
for (EntityModel model : version.getModels()) {
for (EntityProperty property : model.getProperties(version)) {
sql.add(renderAddProperty(property, cfg));
}
}
break;
}
case ADD_INDEXES:
{
for (EntityModel model : version.getModels()) {
for (EntityIndex index : model.getIndexes(version)) {
sql.add(renderCreateIndex(index, cfg));
}
}
break;
}
case DROP_PROPERTIES:
{
for (EntityModel model : version.getModels()) {
for (EntityProperty property : model.getProperties(version)) {
sql.add(renderDropProperty(property, cfg));
}
}
break;
}
case DROP_INDEXES:
{
for (EntityModel model : version.getModels()) {
for (EntityIndex index : model.getIndexes(version)) {
sql.add(renderDropIndex(index, cfg));
}
}
break;
}
}
version.setSql(sql);
} else {
List<String> sql = new ArrayList<String>();
for (EntityModel model : version.getModels()) {
sql.add(renderCreateStructure(model, model.getProperties(version), cfg));
for (EntityIndex index : model.getIndexes(version)) {
sql.add(renderCreateIndex(index, cfg));
}
}
version.setSql(sql);
}
lastVersion = version;
}
Map<String, Object> params = new HashMap<String, Object>();
params.put("baseVersion", baseVersion());
params.put("versions", versions);
params.put("versionCount", versions.size());
params.put("packageName", defaultPackageName + ".providers");
params.put("defaultPackage", defaultPackageName);
params.put("databaseName", databaseName);
writeFile(
defaultPackageName + ".providers",
"NucleiDbHelper",
getTemplate(cfg, "java", "dbhelper"),
params);
}
static EntityModel processEntity(JSONObject entity, DbContext ctx, Version version) {
if (entity.has("rootModel")) { // if there is a rootModel property, we're dealing with a view
processEntityView(entity, ctx);
} else { // otherwise an entity table
EntityModelVersion v =
ctx.currentVersion()
.newModel(
entity.getString("name"), !entity.has("render") || entity.getBoolean("render"))
.currentVersion();
if (entity.has("properties")) {
JSONArray properties = entity.getJSONArray("properties");
for (int p = 0; p < properties.length(); p++) {
JSONObject property = properties.getJSONObject(p);
v.newProperty(
property.has("type")
? EntityProperty.Type.valueOf(property.getString("type"))
: EntityProperty.Type.UNKNOWN,
property.getString("name"),
property.has("nullable") && property.getBoolean("nullable"));
}
}
}
EntityModel m = ctx.getModel(entity.getString("name"));
if (m == null)
throw new NullPointerException("Model " + entity.getString("name") + " not found");
if (entity.has("extensions")) {
JSONArray extensions = entity.getJSONArray("extensions");
for (int p = 0; p < extensions.length(); p++) {
m.getExtensions().add(extensions.getString(p));
}
}
if (entity.has("queries")) processQueries(entity.getJSONObject("queries"), m, version);
if (entity.has("indexes")) {
JSONArray indexes = entity.getJSONArray("indexes");
for (int i = 0; i < indexes.length(); i++) {
JSONObject index = indexes.getJSONObject(i);
List<EntityIndexProperty> properties = new ArrayList<EntityIndexProperty>();
if (index.has("properties")) {
JSONArray indexProperties = index.getJSONArray("properties");
for (int p = 0; p < indexProperties.length(); p++) {
Object prop = indexProperties.get(p);
EntityIndexProperty property = new EntityIndexProperty();
if (prop instanceof String) {
property.setProperty(m.getProperty(m.currentVersion().getVersion(), (String) prop));
property.setOrder(EntityIndexProperty.Order.DEFAULT);
} else {
JSONObject o = (JSONObject) prop;
property.setProperty(
m.getProperty(m.currentVersion().getVersion(), o.getString("name")));
property.setOrder(
o.has("order")
? EntityIndexProperty.Order.valueOf(index.getString("order"))
: EntityIndexProperty.Order.DEFAULT);
}
properties.add(property);
}
}
m.currentVersion()
.newIndex(
index.has("type")
? EntityIndex.Type.valueOf(index.getString("type"))
: EntityIndex.Type.DEFAULT,
index.getString("name"),
properties);
}
}
return m;
}
