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));
}
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);
}
protected virtual bool Validate(EntityModelBase model)
{
//check concurrency based on LastModifiedOn
bool IsValid = true;
var validator = new DataValidator();
foreach (var f in model.Attributes)
{
var field = f.Value;
if (model.IsNew || field.IsChanged)
{
if (field.Field.IsRequired && !validator.HasValue(field.Field, field.Value))
{
field.ErrorMessage = $"Field {field.Field.Text} is required";
field.IsValid = false;
}
}
if (!field.IsValid)
{
IsValid = false;
}
}
return(IsValid);
}
public string ResolveDisplayExp(EntityModelBase modelBase)
{
if (!IsValid || modelBase == null)
{
return(exp);
}
string expression = exp;
foreach (var field in KeyWords)
{
string displayText = "";
var result = modelBase.GetValueData(field);
if (!result.IsValid)
{
displayText = "";
}
else if (string.IsNullOrWhiteSpace(result.DisplayValue))
{
displayText = result.Value.ToString();
}
expression = RepacleField(expression, field, displayText);
}
//ReplaceGlobalFields()
expression = expression.Replace(" ", " ");
return(expression);
}
public object ExecuteExpression(string code, EntityModelBase model)
{
_DataProvider = new EntityModelDataProvider(model);
var parser = new JavaScriptParser(code);
var expression = parser.ParseExpression();
return(GetVarFromExp(expression));
}
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 int Save(EntityModelBase model, IDbConnection connection, IDbTransaction transaction)
{
_model = model;
var parameters = new DynamicParameters();
var toUpdateFields = PrepareInsertUpdateFields(_model);
var qry = BuildQuery(model, toUpdateFields, ref parameters);
return(connection.Execute(qry, parameters, transaction));
}
private void CreateTableColumn(EntityModelBase model, IDbConnection connection, IDbTransaction transaction)
{
var fieldName = model.GetValue("dbname", "");
//var type = model.GetValue("fieldtype", 0);
var baseType = model.GetTempInfo("basetypecode", 0);
var table = model.GetValue("tablename", "");
var length = model.GetValue("length", 0);
EntityBuilder.CreateEntityColumn(connection, transaction, table, fieldName, (TypeCode)baseType, length);
}
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 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 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 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 static object ComputeFieldData(BaseField field, EntityModelBase modelBase)
{
var exp = field.ComputeExpression;
if (exp == null)
{
return(null);
}
return(null);
}
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 void PrepareErrorModel(EntityModelBase recordModel, ref UIFormModel model)
{
var fields = new InvariantDictionary <UIFormField>();
foreach (var fData in recordModel.GetInvalidFields())
{
fields.Add(fData.Field.ViewName.ToUpper(), new UIFormField()
{
WidgetId = fData.Field.ViewName, ErrorMessage = fData.ErrorMessage
});
}
model.Widgets = fields;
}
public EntityModelBase Generate(UIFormModel model)
{
this.ValidatrRequest();
_formContext.CreateDataModel();
RecordModel = _formContext.EntityModel;
SetRelationShip();
this.SetFieldsModelToRecord(model);
Status = AnyStatus.Success;
return(RecordModel);
}
public static bool CreateEntityTable(EntityModelBase model, IDbConnection connection, IDbTransaction transaction, out int defaultItemType)
{
try
{
var qry = BuildEntityTableQry(model, out defaultItemType);
DBService.ExecuteDDLQuery(qry, null, connection, transaction);
return(true);
}
catch (Exception ex)
{
throw;
}
}
object IDbRepository <EntityModelBase, object> .Insert(EntityModelBase entity)
{
int commandResult = 0;
SQLiteTransaction transaction = null;
try
{
using (SqlLiteDbConnection connection = new SqlLiteDbConnection())
{
ISqlLiteCommandBuilder <SQLiteCommand> restaurantAddCommandBuilder = new Restaurant_AddCommand(connection, entity as Restaurant);
SQLiteCommand command = restaurantAddCommandBuilder.Build();
using (transaction = connection.Connection.BeginTransaction(IsolationLevel.Serializable))
{
commandResult = command.ExecuteNonQuery();
transaction.Commit();
}
}
}
catch (SQLiteException e)
{
throw new Exception(string.Format("SQLite Exception {0} {1}", e.ErrorCode, e.Message));
}
catch (Exception e)
{
transaction.Rollback();
throw e;
}
finally
{
if (transaction != null)
{
transaction.Dispose();
}
}
return((object)commandResult);
}
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 static AnyStatus SaveEntity(StackAppContext appContext, IDBEntity entity, EntityModelBase model, IDbConnection connection, IDbTransaction transaction)
{
AnyStatus sts = AnyStatus.UpdateFailure;
var eSave = new EntityDBSave(entity);
if (model.IsNew)
{
var eId = GetNextEntityDBId(entity.EntityId.Code);
model.SetID(eId);
}
IDbConnection conn;
IDbTransaction trans;
bool isLocalConnection = true;
if (connection == null)
{
conn = DBService.Connection;
conn.Open();
trans = conn.BeginTransaction();
}
else
{
conn = connection;
trans = transaction;
isLocalConnection = false;
}
try
{
sts = entity.OnBeforeDbSave(appContext, model, conn, trans);
if (sts == AnyStatus.Success)
{
eSave.Save(model, conn, trans);
sts = entity.OnAfterDbSave(appContext, model, conn, trans);
if (sts != AnyStatus.Success)
{
if (isLocalConnection)
{
trans.Rollback();
}
}
else
{
if (isLocalConnection)
{
trans.Commit();
}
}
}
}
catch (Exception ex)
{
sts = AnyStatus.SaveFailure;
sts.Message = ex.Message;
if (isLocalConnection)
{
trans.Rollback();
}
}
finally
{
if (isLocalConnection)
{
trans.Dispose();
conn.Close();
}
}
return(sts);
}
public override AnyStatus Save(StackAppContext appContext, EntityModelBase model)
{
AnyStatus status = AnyStatus.NotInitialized;
return(status);
}
public RuleEvaluator(StackAppContext appContext, EntityModelBase model) : this(appContext, model.EntityId)
{
this._DataModel = model;
}
public override AnyStatus Save(StackAppContext appContext, EntityModelBase model)
{
return(base.Save(appContext, model));
}
void IDbRepository <EntityModelBase, object> .Save(EntityModelBase entity)
{
throw new NotImplementedException();
}
object IDbRepository <EntityModelBase, object> .Insert(EntityModelBase entity)
{
throw new NotImplementedException();
}
public override AnyStatus OnSaveComplete(StackAppContext appContext, EntityModelBase model)
{
EntityMetaData.Build();
return(base.OnSaveComplete(appContext, model));
}
protected override bool Validate(EntityModelBase model)
{
var isvalid = base.Validate(model);
return(isvalid);
}
protected override bool Validate(EntityModelBase model)
{
return(base.Validate(model));
}
internal EntityModelDataProvider(EntityModelBase modelBase) : base(null)
{
_modelBase = modelBase;
}
private static object Compute(EvalExpression exp, EntityModelBase modelBase)
{
return(null);
}
