public static List <ViewPageDataOnly> GetData(StackAppContext appContext, RequestQueryString requestQuery)
{
var baseEntity = EntityMetaData.Get(requestQuery.EntityId);
var baseField = baseEntity.GetFieldSchema(requestQuery.FieldName);
var childEntity = EntityMetaData.Get(baseField.RefObject);
var ids = FetchDataModel(appContext, requestQuery.ItemId, baseField, childEntity);
var pages = new List <ViewPageDataOnly>();
var lConext = new LayoutContext(appContext, 0, baseField.RefObject);
lConext.Build();
foreach (var id in ids)
{
var query = new RequestQueryString()
{
EntityId = baseField.RefObject, ItemId = id
};
var context = new EditFormContext(appContext, baseField.RefObject, query);
context.Build();
context.CreateDataModel();
context.LayoutContext = lConext;
var renderer = new EditFormRenderer(context);
renderer.Generate(lConext);
pages.Add(renderer.GetViewPageOnlyData());
}
return(pages);
}
public override AnyStatus Save(StackAppContext appContext, EntityModelBase model)
{
if (model.IsNew)
{
var entityId = model.GetValue <int>("entityid", 0);
var length = model.GetValue <int>("length", 0);
var type = model.GetValue <int>("fieldtype", 0);
var fieldInfo = EntityMetaData.CreateField((FieldType)type);
var baseType = fieldInfo.BaseType;
model.SetTempInfo("basetypecode", baseType);
if (length == 0)
{
if (baseType == TypeCode.String)
{
length = GetDefaultVarCharLength((FieldType)type);
}
else if (baseType == TypeCode.Decimal)
{
length = 6;
}
model.SetValue("length", length);
}
var fieldName = model.GetValue("fieldname", "");
var tableName = this.GetEntity(entityId).DBName;
model.SetValue("tablename", tableName);
model.SetValue("dbname", fieldName);
}
return(base.Save(appContext, model));
}
internal void PrepareSaveImageField(StackAppContext appContext)
{
var dmsPath = appContext.ImageStorePath;
foreach (var f in this.Attributes)
{
var val = f.Value;
if (val.Field.Type == FieldType.Image && val.IsChanged)
{
var value = val.Value;
if (value == null || (value is string && String.IsNullOrEmpty(value.ToString())))
{
f.Value.SetValue(value);
return;
}
var obj = (DynamicObj)val.Value;
if (obj.Get("IsTemp", false))
{
var tempFile = obj.Get("FileName", "");
var ext = "png";
var destFile = $"docimage_{this.EntityId.Code.ToString()}_{this.ID.ToString()}_{val.Field.Name}.{ext}";
var destFilePath = Path.Combine(dmsPath, "store_" + appContext.MasterId, destFile);
File.Copy(Path.Combine(dmsPath, "temp", tempFile), destFilePath, true);
value = destFile;
}
f.Value.SetValue(value);
}
}
}
public HomeController(ILogger <HomeController> logger, IOptions <AppKeySetting> appSettings)
{
_logger = logger;
appContext = new StackAppContext();
appContext.Init(appSettings.Value);
}
internal ObjectDataProvider(StackAppContext appContext, Dictionary <string, object> param) : this(appContext)
{
foreach (var d in param)
{
_Vars.Add(d.Key, d.Value);
}
}
private AnyStatus SaveRelatedData(StackAppContext appContext, EntityModelBase model, IDbConnection connection, IDbTransaction transaction)
{
AnyStatus sts = AnyStatus.Success;
//save child entities
foreach (var f in model.Attributes)
{
var val = f.Value;
if (val.Field.Type == FieldType.OneToMany && val.IsChanged && val.Value != null && (val.Value as IList).Count > 0)
{
var itemColl = (List <EntityModelBase>)val.Value;
var field = val.Field;
var entity = GetEntity(field.RefObject);
foreach (var localModel in itemColl)
{
SetRelationshipValue(model.ID, field.Name, localModel);
sts = entity.Save(appContext, localModel, connection, transaction);
if (sts != AnyStatus.Success)
{
break;
}
}
}
}
return(sts);
}
public static DesignerViewPage BuildPage(StackAppContext appContext, RequestQueryString requestQuery)
{
var layoutModel = EntityMetaData.Get(EntityCode.EntityLayout).GetSingle(appContext, requestQuery.ItemId);
var entity = EntityMetaData.Get(requestQuery.RelatedEntityId);
var view = TView.ParseFromJSON(layoutModel.GetValue("layoutjson", ""));
if (view == null)
{
view = entity.GetDefaultLayoutView(0);
}
var pallet = BuildPallet(appContext, entity);
var page = new DesignerViewPage(pallet, view);
page.LayoutFields = view.Fields;
page.Actions = new InvariantDictionary <Model.Form.ActionInfo>();
var saveAction = new ActionInfo("Studio/SaveDesigner", requestQuery, "BTN_SAVE")
{
Title = "Save",
ActionType = ActionType.Save,
ExecutionType = ActionExecutionType.Custom
};
page.Actions.Add("BTN_SAVE", saveAction);
return(page);
}
public virtual AnyStatus OnAfterDbSave(StackAppContext appContext, EntityModelBase model, IDbConnection connection, IDbTransaction transaction)
{
AnyStatus sts = AnyStatus.Success;
sts = SaveRelatedData(appContext, model, connection, transaction);
return(sts);
}
public EntityModelBase GetDefault(StackAppContext appContext)
{
EntityRecordModel model = new EntityRecordModel(this);
model.CreateDefault();
return(model);
}
public override Model.DataList.EntityListDefinition CreateDefaultListDefn(StackAppContext appContext)
{
var defn = base.CreateDefaultListDefn(appContext);
defn.IncludeGlobalMasterId = true;
return(defn);
}
public static IEnumerable <DbObject> ExecuteEntityQuery(StackAppContext appContext, DbQuery query)
{
query.ResolveFields();
var builder = new QueryBuilder(query);
var data = DBService.Query(builder.BuildSql(), new { MasterId = appContext.MasterId });
return(data);
}
private static DesignerPallet BuildPallet(StackAppContext appContext, IDBEntity entity)
{
var pallet = new DesignerPallet();
pallet.Fields = PrepareFieldList(entity);
pallet.Buttons = PrepareButtonNLinks(appContext, entity);
return(pallet);
}
private static List <int> FetchDataModel(StackAppContext appContext, int parentId, BaseField parentField, IDBEntity entity)
{
var filterExp = new FilterExpression(entity.EntityId);
var relField = (OneToManyField)parentField;
filterExp.Add(new FilterExpField(relField.RefFieldName, FilterOperationType.Equal, parentId));
var ids = entity.ReadIds(appContext, filterExp);
return(ids);
}
public virtual AnyStatus OnBeforeDbSave(StackAppContext appContext, EntityModelBase model, IDbConnection connection, IDbTransaction transaction)
{
var sts = AnyStatus.Success;
if (model is EntityRecordModel)
{
((EntityRecordModel)model).PrepareSaveImageField(appContext);
}
return(sts);
}
public AnyStatus SaveLayoutData(StackAppContext appContext, RequestQueryString requestQuery, TView view)
{
var layoutModel = GetSingle(appContext, requestQuery.ItemId);
var json = view.ToStoreJSON();
layoutModel.SetValue("layoutjson", json);
return(Save(appContext, layoutModel));
}
public override AnyStatus Save(StackAppContext appContext, EntityModelBase model)
{
//encrypt pwd if new
//if edit do not change **
if (model.IsNew)
{
model.SetValue("Password", Encrypt(model.GetValue("Password").ToString()));
}
return(base.Save(appContext, model));
}
public override AnyStatus OnAfterDbSave(StackAppContext appContext, EntityModelBase model, IDbConnection connection, IDbTransaction transaction)
{
AnyStatus sts = base.OnAfterDbSave(appContext, model, connection, transaction);
if (sts == AnyStatus.Success)
{
if (model.IsNew)
{
}
}
return(sts);
}
public override AnyStatus Save(StackAppContext appContext, EntityModelBase model)
{
if (model.IsNew)
{
var entityId = model.GetValue <int>("entityid", 0);
var itemType = this.GetEntity(entityId).DefaultItemTypeId;
model.SetValue("itemType", itemType);
model.SetValue("viewType", 0);
}
return(base.Save(appContext, model));
}
public virtual EntityModelBase GetSingle(StackAppContext appContext, int id)
{
var sql = _detailQry;
var arr = DBService.Query(sql, new { MasterId = appContext.MasterId, ItemId = new int[] { id } });
//var relatedFieldData = DBService.Query(_relatedFieldDataQryList, new { ItemId = new int[] {id} });
if (arr.Count() > 0)
{
var d = arr.First();
return(BuildModelFromDbObj(d));
}
throw new EntityException("Record not found.");
}
public override AnyStatus OnAfterDbSave(StackAppContext appContext, EntityModelBase model, IDbConnection connection, IDbTransaction transaction)
{
AnyStatus sts = base.OnAfterDbSave(appContext, model, connection, transaction);
int defaultItemType = 0;
if (sts == AnyStatus.Success)
{
if (model.IsNew)
{
EntityBuilder.CreateEntityTable(model, connection, transaction, out defaultItemType);
}
}
return(sts);
}
private ViewPage BuildRefForm(StackAppContext appContext, EntityCode refEntity)
{
var q = new RequestQueryString();
q.EntityId = refEntity;
var context = new EditFormContext(appContext, refEntity, q);
context.Build();
var builder = new PageBuilder.EntityPageBuilder();
var page = builder.CreateNewPage(context);
return(page);
}
public DBModelBase Read(StackAppContext appContext, int id, List <string> fields)
{
var exp = new FilterExpression(this.EntityId);
exp.Add(new FilterExpField(this.IDField, FilterOperationType.Equal, id));
var d = ReadAll(appContext, fields, exp);
if (d.Count > 0)
{
return(d.First());
}
throw new UserException("Record is not available with id: " + id.ToString());
}
private static List <DynamicObj> PrepareButtonNLinks(StackAppContext appContext, IDBEntity entity)
{
var actions = EntityActionService.GetActions(appContext, entity.EntityId, EntityLayoutType.View);
var coll = new List <DynamicObj>();
foreach (var f in actions)
{
var d = new DynamicObj();
d.Add("Id", f.Id);
d.Add("Text", f.Text);
coll.Add(d);
}
return(coll);
}
public static DataListDefinition GetEntityListDefn(StackAppContext appContext, EntityCode entityId, int queryId = 0)
{
var deff = ListDbService.GetEntityList(entityId);
var _Entity = Core.EntityMetaData.Get(entityId);
if (deff == null)
{
deff = _Entity.CreateDefaultListDefn(appContext);
}
deff.Id = entityId.Code.ToString() + "_" + queryId.ToString();
if (deff.PageSize <= 0)
{
deff.PageSize = 50;
}
return(deff);
}
public List <EntityModelBase> GetAll(StackAppContext appContext, int[] ids)
{
var sql = _detailQry;
var arr = DBService.Query(sql, new { ItemId = ids });
var list = new List <EntityModelBase>();
if (arr.Count() > 0)
{
foreach (var a in arr)
{
var model = new EntityRecordModel(this);
model.BuiltWithDB(a);
list.Add(model);
}
}
return(list);
}
public virtual EntityListDefinition CreateDefaultListDefn(StackAppContext appContext)
{
var defn = PrepareEntityListDefin();
var layoutF = this.GetLayoutFields(EntityLayoutType.View);
var tlist = new TList();
foreach (var f in layoutF)
{
tlist.Fields.Add(new TListField()
{
FieldId = f.Name
});
}
defn.Layout = tlist;
return(defn);
}
public List <int> ReadIds(StackAppContext appContext, FilterExpression filter)
{
var q = new DbQuery(this);
q.AddField(this.IDField, true);
q.SetFixedFilter(filter);
var data = QueryDbService.ExecuteEntityQuery(appContext, q);
var list = new List <int>();
if (data.Count() > 0)
{
foreach (var d in data)
{
list.Add(d.Get(this.IDField, 0));
}
}
return(list);
}
public AnyStatus ExecuteFunction <T>(StackAppContext appContext, string codeStr, Dictionary <string, object> param, T output) //Arguments param
{
AnyStatus sts = AnyStatus.Success;
try {
currentScriptTag = "Start<>";
var parser = new JavaScriptParser(codeStr);
var program = parser.ParseScript();
_DataProvider = new ObjectDataProvider(appContext, param);
_DataProvider.output = output;
ExecuteBody(program.Body);
} catch (Exception ex) {
sts = AnyStatus.ScriptFailure;
sts.Message = currentScriptTag + "::" + ex.Message;
}
return(sts);
}
public AnyStatus Save(StackAppContext appContext, EntityModelBase model, IDbConnection connection, IDbTransaction transaction)
{
AnyStatus status = AnyStatus.NotInitialized;
try
{
if (model.IsNew)
{
model.SetValue("CREATEDON", DateTime.Now.ToUniversalTime());
model.SetValue("CREATEDBY", appContext.UserInfo.UserId);
model.SetMasterId(appContext.MasterId);
}
model.SetValue("UPDATEDON", DateTime.Now.ToUniversalTime());
model.SetValue("UPDATEDBY", appContext.UserInfo.UserId);
if (this.Validate(model))
{
if (model is EntityRecordModel)
{
((EntityRecordModel)model).ResolveComputedFields();
}
status = EntityDBService.SaveEntity(appContext, this, model, connection, transaction);
if (status == AnyStatus.Success)
{
status = OnSaveComplete(appContext, model);
}
}
else
{
status = AnyStatus.InvalidData;
}
}
catch (AppException ex)
{
status = AnyStatus.SaveFailure;
status.Message = ex.Message;
}
return(status);
}
public override Model.DataList.EntityListDefinition CreateDefaultListDefn(StackAppContext appContext)
{
var defn = PrepareEntityListDefin();
var layoutF = new List <string>()
{
"fieldname", "fieldtype", "label", "linkentity", "collectionid", "computeexpression"
};
var tlist = new TList();
foreach (var f in layoutF)
{
tlist.Fields.Add(new TListField()
{
FieldId = f
});
}
defn.Layout = tlist;
defn.IncludeGlobalMasterId = true;
return(defn);
}
