public Guid?GetEntityID(sysBpmsEntityDef entityDef, sysBpmsVariable variable, List <QueryModel> additionalParams)
{
string whereClause = VariableEngine.GenerateWhereClause(variable);
string orderClause = VariableEngine.GenerateOrderClause(variable);
//get sql query parameter from additionalParams
List <SqlParameter> queryParams = QueryModel.GetSqlParameter(base.GetAllQueryModels(additionalParams) ?? new List <QueryModel>()).ToList();
//add variable dependies to whereclause which have relation with current variable.
this.AddDependencyClause(variable, queryParams, null, ref whereClause, additionalParams);
string sqlQuery = $" select {entityDef.FormattedTableName}.ID from {entityDef.FormattedTableName} {whereClause} {orderClause} ";
this.AddDefaultParams(sqlQuery, queryParams);
this.AddVariableParameters(ref sqlQuery, queryParams);
queryParams = queryParams.Where(c => sqlQuery.Contains(c.ParameterName)).ToList();
DataTable dataTable = new DataBaseQueryService(this.UnitOfWork).GetBySqlQuery(sqlQuery, true, null, queryParams.ToArray());
if (dataTable.Rows.Count > 0)
{
return(Guid.Parse(dataTable.Rows[0][0].ToString()));
}
return(null);
}
public VariableTypeEngineBase(EngineSharedModel engineSharedModel, sysBpmsVariable variable, Guid?ProcessID, Guid?threadID, List <QueryModel> additionalParams, IUnitOfWork unitOfWork) : base(engineSharedModel, unitOfWork)
{
this.Variable = variable;
this.ProcessID = ProcessID;
this.ThreadID = threadID;
this.AdditionalParams = additionalParams;
}
/// <summary>
/// this method add variable dependies to whereclause which have relation with current variable.
/// </summary>
/// <param name="queryParams">it would update this parameter.</param>
private void AddDependencyClause(sysBpmsVariable variable, List <SqlParameter> queryParams, List <SqlParameter> insertColumnParams, ref string whereClause, List <QueryModel> additionalParams, Dictionary <string, DataModel> allSavedEntities = null)
{
//add variable dependies where clause which have relation with current variable
if (variable.DependentVariableDependencies.Any())
{
foreach (sysBpmsVariableDependency item in variable.DependentVariableDependencies)
{
object value = null;
var toVariable = new VariableService(base.UnitOfWork).GetInfo(item.ToVariableID.Value);
//set BindTrace to find a field of a entity variable if the variable is entity.
string BindTrace = $"{toVariable.Name}{(!string.IsNullOrWhiteSpace(item.ToPropertyName) ? ("." + item.ToPropertyName) : "")}";
whereClause += $"{(string.IsNullOrWhiteSpace(whereClause) ? "" : " and ")}{item.DependentPropertyName}=@{BindTrace.Replace(".", "_")}";
if (allSavedEntities?.ContainsKey(toVariable.Name) == true && allSavedEntities[toVariable.Name][BindTrace.Split('.').LastOrDefault()] != null)
{
value = allSavedEntities[toVariable.Name][BindTrace.Split('.').LastOrDefault()];
}
else
{
value = new DataManageEngine(base.EngineSharedModel, base.UnitOfWork).GetValueByBinding(BindTrace, base.GetAllQueryModels(additionalParams));
}
queryParams.Add(new SqlParameter($"@{BindTrace.Replace(".", "_")}", value ?? DBNull.Value));
if (insertColumnParams != null)
{
if (!insertColumnParams.Any(c => c.ParameterName.TrimStart('@') == item.DependentPropertyName))
{
insertColumnParams.Add(new SqlParameter("@" + item.DependentPropertyName, value ?? DBNull.Value));
}
}
}
}
whereClause = string.IsNullOrWhiteSpace(whereClause) ? "" : (whereClause.Trim().StartsWith("where") ? whereClause : (" where " + whereClause));
}
public ResultOperation IsValid(FileUploadHtml fileUploadHtml, sysBpmsVariable variable, Guid?entityId, Guid?entitydefid, string currentUserName)
{
ResultOperation resultOperation = new ResultOperation();
if (variable != null && !entityId.HasValue)
{
sysBpmsEntityDef entityDef = new EntityDefService(base.UnitOfWork).GetInfo(variable.EntityDefID.Value);
entitydefid = variable.EntityDefID.Value;
entityId = new EntityDefEngine(base.EngineSharedModel, base.UnitOfWork).GetEntityID(entityDef, variable, base.EngineSharedModel.BaseQueryModel);
}
Dictionary <Guid, HttpPostedFileBase> files = fileUploadHtml.Value == null ? new Dictionary <Guid, HttpPostedFileBase>() : (((Dictionary <Guid, object>)fileUploadHtml.Value).ToDictionary(c => c.Key.ToGuidObj(), c => c.Value == null ? null : c.Value is HttpPostedFileBase ? (HttpPostedFileBase)c.Value : new HttpPostedFileWrapper((HttpPostedFile)c.Value)));
if (files.Any())
{
foreach (var item in files)
{
ResultOperation result = this.IsValid(entitydefid, entityId, item.Value?.InputStream, item.Value?.FileName, item.Key);
if (!result.IsSuccess)
{
resultOperation.AddError(result.GetErrors());
}
}
}
else
{
resultOperation = this.IsValid(entitydefid, entityId, null, null, fileUploadHtml.DocumentdefId.ToGuidObjNull().Value);
}
return(resultOperation);
}
/// <param name="containerQuery">It is generally used in combosearch which add a parent query that filter table's rows according to query parameter and text field</param>
/// <param name="includes">It is used in List variable in DataGrid and chart is each item in array is like (Product.Name,Order.Name)</param>
public DataTable GetEntity(sysBpmsEntityDef entityDef, sysBpmsVariable variable, List <QueryModel> additionalParams, PagingProperties currentPaging, string containerQuery = null, string[] includes = null)
{
string columnName = string.Empty;
string includesQuery = string.Empty;
switch ((sysBpmsVariable.e_VarTypeLU)variable.VarTypeLU)
{
case sysBpmsVariable.e_VarTypeLU.Integer:
case sysBpmsVariable.e_VarTypeLU.String:
case sysBpmsVariable.e_VarTypeLU.Uniqueidentifier:
case sysBpmsVariable.e_VarTypeLU.Decimal:
case sysBpmsVariable.e_VarTypeLU.DateTime:
case sysBpmsVariable.e_VarTypeLU.Boolean:
columnName = variable.FieldName;
break;
case sysBpmsVariable.e_VarTypeLU.List when variable.RelationTypeLU == (int)sysBpmsVariable.e_RelationTypeLU.Entity && includes?.Any() == true:
case sysBpmsVariable.e_VarTypeLU.Object when includes?.Any() == true:
EntityDefService entityDefService = new EntityDefService(base.UnitOfWork);
foreach (var p in entityDef.Properties.Where(c => c.DbType == EntityPropertyModel.e_dbType.Entity && includes.Any(d => d.Contains(c.Name))))
{
string foreingName = entityDefService.GetInfo(p.RelationToEntityID.Value).FormattedTableName;
string includesColumnNames = string.Join(",", includes.Where(d => d.Split('.')[0] == p.Name).Select(c => $"{c.Split('.')[1]} as {p.Name}__{c.Split('.')[1]}"));
if (!includesColumnNames.Contains($"{p.Name}__ID"))
{
includesColumnNames += "," + $"ID as {p.Name}__ID";
}
includesQuery += $" left join (select {includesColumnNames} from {foreingName}) {foreingName} on {entityDef.FormattedTableName}.{p.Name}={foreingName}.{p.Name}__ID " + Environment.NewLine;
}
break;
}
columnName = string.IsNullOrWhiteSpace(columnName) ? "*" : columnName;
string whereClause = VariableEngine.GenerateWhereClause(variable);
string orderClause = VariableEngine.GenerateOrderClause(variable);
//get sql query parameter from additionalParams
List <SqlParameter> queryParams = QueryModel.GetSqlParameter(base.GetAllQueryModels(additionalParams) ?? new List <QueryModel>()).ToList();
//add variable dependies to whereclause which have relation with current variable.
this.AddDependencyClause(variable, queryParams, null, ref whereClause, additionalParams);
string sqlQuery = $" select {columnName} from {entityDef.FormattedTableName} {includesQuery} {whereClause} {orderClause} ";
//If containerQuery is not null
if (!string.IsNullOrWhiteSpace(containerQuery))
{
sqlQuery = (sqlQuery.Contains("order") && (!sqlQuery.ToLower().Contains("top") && !sqlQuery.ToLower().Contains("offset"))) ? $"{sqlQuery} OFFSET 0 ROWS " : sqlQuery;
sqlQuery = string.Format(containerQuery, sqlQuery);
}
this.AddDefaultParams(sqlQuery, queryParams);
this.AddVariableParameters(ref sqlQuery, queryParams);
queryParams = queryParams.Where(c => sqlQuery.Contains(c.ParameterName)).ToList();
return(new DataBaseQueryService(this.UnitOfWork).GetBySqlQuery(sqlQuery, true, currentPaging, queryParams.ToArray()));
}
public void Delete(Guid VariableId)
{
sysBpmsVariable Variable = this.Context.sysBpmsVariables.FirstOrDefault(d => d.ID == VariableId);
if (Variable != null)
{
this.Context.sysBpmsVariables.Remove(Variable);
}
}
public ResultOperation Add(sysBpmsVariable variable, List <sysBpmsVariableDependency> listVariables)
{
ResultOperation resultOperation = new ResultOperation();
try
{
this.BeginTransaction();
if (resultOperation.IsSuccess)
{
if (variable.RelationTypeLU != (int)sysBpmsVariable.e_RelationTypeLU.Entity)
{
variable.FilterTypeLU = variable.ApplicationPageID.HasValue ? (int)sysBpmsVariable.e_FilterTypeLU.AllEntities : variable.FilterTypeLU;
variable.EntityDefID = null;
variable.FieldName = string.Empty;
}
if (variable.RelationTypeLU != (int)sysBpmsVariable.e_RelationTypeLU.SqlQuery)
{
variable.Query = string.Empty;
variable.DBConnectionID = null;
}
sysBpmsVariable preVariable = this.GetInfo(variable.ProcessID, variable.ApplicationPageID, variable.Name);
if (preVariable != null)
{
resultOperation.AddError(LangUtility.Get("SameName.Error", nameof(sysBpmsVariable)));
}
if (resultOperation.IsSuccess)
{
this.UnitOfWork.Repository <IVariableRepository>().Add(variable);
this.UnitOfWork.Save();
if (variable.RelationTypeLU == (int)sysBpmsVariable.e_RelationTypeLU.Entity)
{
listVariables = listVariables ?? new List <sysBpmsVariableDependency>();
foreach (var item in listVariables)
{
item.DependentVariableID = variable.ID;
if (resultOperation.IsSuccess)
{
resultOperation = new VariableDependencyService(base.UnitOfWork).Add(item);
}
}
}
}
}
}
catch (Exception ex)
{
return(base.ExceptionHandler(ex));
}
base.FinalizeService(resultOperation);
return(resultOperation);
}
private ResultOperation SaveInto()
{
VariableService variableService = new VariableService(base.UnitOfWork);
ResultOperation resultOperation = new ResultOperation();
//Resort this.SetDataList because of variable dependencies.
var listSetDataList = this.SetDataList.ToList();
for (int i = 0; i < listSetDataList.Count; i++)
{
var item = listSetDataList[i];
sysBpmsVariable variable = variableService.GetInfo(base.EngineSharedModel?.CurrentProcessID, base.EngineSharedModel?.CurrentApplicationPageID, item.Key, new string[] { $"{nameof(sysBpmsVariable.DependentVariableDependencies)}.{nameof(sysBpmsVariableDependency.ToVariable)}" });
foreach (sysBpmsVariableDependency vDependency in variable.DependentVariableDependencies)
{
var parentVariable = listSetDataList.Select((c, index) => new { item = c, index }).FirstOrDefault(c => c.item.Key != item.Key && c.item.Key == vDependency.ToVariable.Name && i < c.index);
//if variable has a dependency which has higher index ,this code block replace both of them.
if (parentVariable != null)
{
listSetDataList[i] = parentVariable.item;
listSetDataList[parentVariable.index] = item;
i--;
}
}
}
this.SetDataList = listSetDataList.ToDictionary(c => c.Key, c => c.Value);
//save variables.
foreach (var item in this.SetDataList)
{
if (resultOperation.IsSuccess)
{
sysBpmsVariable variable = variableService.GetInfo(base.EngineSharedModel?.CurrentProcessID, base.EngineSharedModel?.CurrentApplicationPageID, item.Key, new string[] { nameof(sysBpmsVariable.DependentVariableDependencies) });
if (variable != null)
{
switch ((sysBpmsVariable.e_RelationTypeLU)variable.RelationTypeLU)
{
case sysBpmsVariable.e_RelationTypeLU.Local:
resultOperation = new SystemicVariableTypeEngine(base.EngineSharedModel, variable, base.EngineSharedModel?.CurrentProcessID, this.ThreadID, this.AdditionalParams, this.UnitOfWork).SaveValues(item.Value);
break;
case sysBpmsVariable.e_RelationTypeLU.Entity:
resultOperation = new EntityVariableTypeEngine(base.EngineSharedModel, variable, base.EngineSharedModel?.CurrentProcessID, this.ThreadID, this.AdditionalParams, this.UnitOfWork).SaveValues(item.Value, this.SetDataList);
item.Value.SetValue("ID", resultOperation.CurrentObject);
break;
case sysBpmsVariable.e_RelationTypeLU.SqlQuery:
resultOperation = new SqlQueryVariableTypeEngine(base.EngineSharedModel, variable, base.EngineSharedModel?.CurrentProcessID, this.ThreadID, this.AdditionalParams, this.UnitOfWork).SaveValues(item.Value);
break;
}
}
}
}
return(resultOperation);
}
public void Update(sysBpmsVariable variable)
{
//To fix 'Attaching an entity failed' error.
var local = this.Context.Set <sysBpmsVariable>().Local.FirstOrDefault(f => f.ID == variable.ID);
if (local != null)
{
this.Context.Entry(local).State = EntityState.Detached;
local = null;
}
this.Context.Entry(variable.Clone()).State = EntityState.Modified;
}
//this method make where clause for filtering Entity
public static string GenerateWhereClause(sysBpmsVariable variable)
{
string whereClause;
if (string.IsNullOrWhiteSpace(variable.WhereClause))
{
whereClause = variable.FilterTypeLU == (int)sysBpmsVariable.e_FilterTypeLU.AllEntities ?
"" : " where ThreadID=@ThreadID ";
}
else
{
whereClause = $" where ({variable.WhereClause})" +
(variable.FilterTypeLU == (int)sysBpmsVariable.e_FilterTypeLU.AllEntities ? "" : " and ThreadID=@ThreadID");
}
return(whereClause);
}
public VariableDTO(sysBpmsVariable variable)
{
this.ID = variable.ID;
this.ProcessID = variable.ProcessID;
this.ApplicationPageID = variable.ApplicationPageID;
this.Name = variable.Name;
this.VarTypeLU = variable.VarTypeLU;
this.EntityDefID = variable.EntityDefID;
this.FieldName = variable.FieldName;
this.Query = variable.Query;
this.FilterTypeLU = variable.FilterTypeLU;
this.Collection = variable.Collection;
this.DBConnectionID = variable.DBConnectionID;
this.DefaultValue = variable.DefaultValue;
this.WhereClause = variable.WhereClause;
this.OrderByClause = variable.OrderByClause;
this.ListVariableDependencyDTO = variable.DependentVariableDependencies?.Select(c => new VariableDependencyDTO(c)).ToList();
}
public SelectVariableDTO(sysBpmsVariable variable)
{
this.ID = variable.ID;
this.ProcessID = variable.ProcessID;
this.ApplicationPageID = variable.ApplicationPageID;
this.Name = variable.Name;
this.VarTypeLU = variable.VarTypeLU;
this.EntityDefID = variable.EntityDefID;
this.FieldName = variable.FieldName;
this.Query = variable.Query;
this.FilterTypeLU = variable.FilterTypeLU;
this.Collection = variable.Collection;
this.DBConnectionID = variable.DBConnectionID;
this.DefaultValue = variable.DefaultValue;
this.WhereClause = variable.WhereClause;
this.OrderByClause = variable.OrderByClause;
this.listVariableDependencyDTO = variable.DependentVariableDependencies?.Select(c => new VariableDependencyDTO(c)).ToList();
if (this.EntityDefID.HasValue && this.VarTypeLU == (int)sysBpmsVariable.e_VarTypeLU.Object)
using (EntityDefService entityDefService = new EntityDefService())
this.ListEntityPropertyModel = entityDefService.GetInfo(this.EntityDefID.Value).AllProperties.Where(c => c.IsActive).ToList();
}
public ResultOperation SaveFile(FileUploadHtml fileUploadHtml, sysBpmsVariable variable, Guid?entityId, Guid?entitydefid, string captionOf, string currentUserName)
{
ResultOperation resultOperation = new ResultOperation();
if (variable != null && !entityId.HasValue)
{
sysBpmsEntityDef entityDef = new EntityDefService(base.UnitOfWork).GetInfo(variable.EntityDefID.Value);
entitydefid = variable.EntityDefID.Value;
entityId = new EntityDefEngine(base.EngineSharedModel, base.UnitOfWork).GetEntityID(entityDef, variable, base.EngineSharedModel.BaseQueryModel);
}
Dictionary <Guid, HttpPostedFileBase> files = fileUploadHtml.Value == null ? new Dictionary <Guid, HttpPostedFileBase>() : (((Dictionary <Guid, object>)fileUploadHtml.Value).ToDictionary(c => c.Key.ToGuidObj(), c => c.Value == null ? null : c.Value is HttpPostedFileBase ? (HttpPostedFileBase)c.Value : new HttpPostedFileWrapper((HttpPostedFile)c.Value)));
foreach (var item in files)
{
if (resultOperation.IsSuccess)
{
resultOperation = this.SaveFile(item.Value?.InputStream, item.Value?.FileName, entityId, entitydefid, item.Key, captionOf, !fileUploadHtml.Multiple);
}
}
return(resultOperation);
}
public object PostAddEdit(VariableDTO variableDTO)
{
int RelationTypeLU = base.MyRequest.Form["RelationTypeLU"].ToIntObj();
variableDTO.ListDependencies = variableDTO.ListDependencies ?? new List <VariableDependencyDTO>();
if (variableDTO.ProcessID.HasValue || variableDTO.ApplicationPageID.HasValue)
{
if (RelationTypeLU == (int)sysBpmsVariable.e_RelationTypeLU.Local && variableDTO.VarTypeLU == (int)sysBpmsVariable.e_VarTypeLU.List)
{
variableDTO.Collection = variableDTO.ListItems.BuildXml();
}
//set ViewBags
using (VariableService variableService = new VariableService())
{
using (ProcessService processService = new ProcessService())
{
sysBpmsVariable variable = variableDTO.ID != Guid.Empty ? variableService.GetInfo(variableDTO.ID) : new sysBpmsVariable();
if (!base.ProcessId.HasValue || processService.GetInfo(base.ProcessId.Value).AllowEdit())
{
ResultOperation resultOperation = variable.Update(variableDTO.ProcessID, variableDTO.ApplicationPageID, variableDTO.Name, variableDTO.VarTypeLU, variableDTO.EntityDefID, variableDTO.FieldName, variableDTO.Query, variableDTO.FilterTypeLU, variableDTO.Collection, variableDTO.DBConnectionID, variableDTO.DefaultValue, variableDTO.WhereClause, variableDTO.OrderByClause);
if (!resultOperation.IsSuccess)
{
return(new PostMethodMessage(resultOperation.GetErrors(), DisplayMessageType.error));
}
List <sysBpmsVariableDependency> VariableDependencies = new List <sysBpmsVariableDependency>();
if (variableDTO.ID != Guid.Empty)
{
foreach (var item in variableDTO.ListDependencies)
{
sysBpmsVariableDependency variableDependency = new sysBpmsVariableDependency();
resultOperation = variableDependency.Update(item.ID, variableDTO.ID, item.DependentPropertyName, item.ToVariableID, item.ToPropertyName, item.Description);
if (!resultOperation.IsSuccess)
{
return(new PostMethodMessage(resultOperation.GetErrors(), DisplayMessageType.error));
}
VariableDependencies.Add(variableDependency);
}
resultOperation = variableService.Update(variable, VariableDependencies);
}
else
{
foreach (var item in variableDTO.ListDependencies)
{
sysBpmsVariableDependency variableDependency = new sysBpmsVariableDependency();
resultOperation = variableDependency.Update(item.ID, item.DependentVariableID, item.DependentPropertyName, item.ToVariableID, item.ToPropertyName, item.Description);
if (!resultOperation.IsSuccess)
{
return(new PostMethodMessage(resultOperation.GetErrors(), DisplayMessageType.error));
}
VariableDependencies.Add(variableDependency);
}
resultOperation = variableService.Add(variable, VariableDependencies);
}
if (resultOperation.IsSuccess)
{
return(new PostMethodMessage(SharedLang.Get("Success.Text"), DisplayMessageType.success, new
{
name = variable.Name,
id = variable.ID,
comboTree = variableService.GetVariableAsComboTree(base.ProcessId, base.ApplicationPageId, null).AsJson(),
entityVariables = variableService.GetList(base.ProcessId, base.ApplicationPageId, (int)sysBpmsVariable.e_VarTypeLU.Object, "", null, true).Select(c => new { text = c.Name, value = c.ID }).ToList(),
listVariables = variableService.GetList(base.ProcessId, base.ApplicationPageId, (int)sysBpmsVariable.e_VarTypeLU.List, "", null, true).Select(c => new { text = c.Name, value = c.Name }).ToList()
}));
}
else
{
return(new PostMethodMessage(resultOperation.GetErrors(), DisplayMessageType.error));
}
}
else
{
return(new PostMethodMessage(LangUtility.Get("NotAllowEdit.Text", nameof(sysBpmsProcess)), DisplayMessageType.error));
}
}
}
}
return(new PostMethodMessage(SharedLang.Get("NotFound.Text"), DisplayMessageType.error));
}
public object GetAddEdit(Guid?ID = null, string VariableName = "", Guid?ProcessId = null, Guid?ApplicationPageId = null)
{
using (VariableService variableService = new VariableService())
{
VariableDTO variable = null;
if (ID.ToGuidObj() != Guid.Empty)
{
variable = new VariableDTO(variableService.GetInfo(ID.Value));
}
else
if (!string.IsNullOrWhiteSpace(VariableName))
{
variable = new VariableDTO(variableService.GetInfo(ProcessId, ApplicationPageId, VariableName));
}
if (variable == null)
{
variable = new VariableDTO(new sysBpmsVariable()
{
ProcessID = ProcessId, ApplicationPageID = ApplicationPageId
});
}
using (EntityDefService entityDefService = new EntityDefService())
{
List <EntityPropertyModel> Properties = new List <EntityPropertyModel>();
var Entities = entityDefService.GetList(string.Empty, true);
if (variable != null && variable.EntityDefID.HasValue)
{
Properties = entityDefService.GetInfo(variable.EntityDefID.Value).AllProperties;
}
else
{
Properties = new List <EntityPropertyModel>();
}
variable.ListVariableDependencyDTO?.ForEach((item) =>
{
if (item.ToVariableID.HasValue)
{
sysBpmsVariable getVar = variableService.GetInfo(item.ToVariableID.Value);
if (getVar.EntityDefID.HasValue)
{
item.GetToVariableProperties = entityDefService.GetInfo(getVar.EntityDefID.Value).AllProperties;
}
}
else
{
item.GetToVariableProperties = new List <EntityPropertyModel>();
}
});
using (DBConnectionService dbConnectionService = new DBConnectionService())
return new
{
Model = variable,
ListConnection = dbConnectionService.GetList("").Select(c => new DBConnectionDTO(c)).ToList(),
ListTypes = EnumObjHelper.GetEnumList <sysBpmsVariable.e_VarTypeLU>().Select(c => new QueryModel(c.Key.ToString(), c.Value)),
ListRelations = EnumObjHelper.GetEnumList <sysBpmsVariable.e_RelationTypeLU>().Where(c => variable.ProcessID.HasValue || c.Key != (int)sysBpmsVariable.e_RelationTypeLU.Local).Select(c => new QueryModel(c.Key.ToString(), c.Value)),
ListEntities = Entities.Select(c => new { c.ID, Name = c.Name + $"({c.DisplayName})" }).ToList(),
ListFilters = EnumObjHelper.GetEnumList <sysBpmsVariable.e_FilterTypeLU>().Select(c => new QueryModel(c.Key.ToString(), c.Value)),
ListProperties = Properties,
DependencyToVariables = variableService.GetList(base.ProcessId, base.ApplicationPageId, null, "", null, true).Where(c => c.ID != variable.ID).Select(c => new VariableDTO(c)).ToList()
};
}
}
}
public SystemicVariableTypeEngine(EngineSharedModel engineSharedModel, sysBpmsVariable variable, Guid?processID, Guid?threadID, List <QueryModel> additionalParams, IUnitOfWork unitOfWork = null) : base(engineSharedModel, variable, processID, threadID, additionalParams, unitOfWork)
{
}
private List <SqlParameter> GetColumsAsParams(sysBpmsEntityDef sysBpmsEntityDef, Dictionary <string, object> dataList, sysBpmsVariable sysBpmsVariable)
{
List <EntityPropertyModel> Properties = sysBpmsEntityDef.Properties;
List <SqlParameter> columnParams = new List <SqlParameter>();
for (int index = 0; index < dataList.Count; index++)
{
var item = dataList.ToList()[index];
string propertyName = (sysBpmsVariable == null || sysBpmsVariable.VarTypeLU == (int)sysBpmsVariable.e_VarTypeLU.Object) ? item.Key : sysBpmsVariable.FieldName;
EntityPropertyModel _Property = Properties.FirstOrDefault(c => c.Name == propertyName);
if (Properties.Any(c => c.Name == propertyName))
{
switch (_Property.DbType)
{
case EntityPropertyModel.e_dbType.Decimal:
if (_Property.Required)
{
dataList[item.Key] = item.Value.ToDecimalObj();
}
else
{
dataList[item.Key] = item.Value != null?item.Value.ToDecimalObjNull() : (decimal?)null;
}
break;
case EntityPropertyModel.e_dbType.Integer:
if (_Property.Required)
{
dataList[item.Key] = item.Value.ToIntObj();
}
else
{
dataList[item.Key] = item.Value != null?item.Value.ToIntObjNull() : (int?)null;
}
break;
case EntityPropertyModel.e_dbType.Long:
if (_Property.Required)
{
dataList[item.Key] = Convert.ToInt64(item.Value);
}
else
{
dataList[item.Key] = item.Value != null?Convert.ToInt64(item.Value) : (long?)null;
}
break;
case EntityPropertyModel.e_dbType.String:
dataList[item.Key] = item.Value.ToStringObj();
break;
case EntityPropertyModel.e_dbType.DateTime:
if (string.IsNullOrWhiteSpace(item.Value.ToStringObj()))
{
dataList[item.Key] = DBNull.Value;
}
else
{
dataList[item.Key] = Convert.ToDateTime(dataList[item.Key]);
}
break;
case EntityPropertyModel.e_dbType.Uniqueidentifier:
if (string.IsNullOrWhiteSpace(item.Value.ToStringObj()))
{
dataList[item.Key] = DBNull.Value;
}
break;
}
columnParams.Add(new SqlParameter("@" + propertyName, dataList[item.Key]));
}
}
return(columnParams);
}
/// <summary>
/// this method save entityDef after form post action.
/// </summary>
public Tuple <ResultOperation, Guid?> SaveIntoDataBase(sysBpmsEntityDef entityDef, sysBpmsVariable variable, DataModel dataModel, List <QueryModel> additionalParams, Dictionary <string, DataModel> allSavedEntities)
{
ResultOperation resultOperation = new ResultOperation();
List <SqlParameter> columnParams = this.GetColumsAsParams(entityDef, dataModel.ToList(), variable);
string whereClause = VariableEngine.GenerateWhereClause(variable);
string orderClause = VariableEngine.GenerateOrderClause(variable);
//get sql query parameter from additionalParams
List <SqlParameter> queryParams = QueryModel.GetSqlParameter(base.GetAllQueryModels(additionalParams) ?? new List <QueryModel>()).ToList();
//variable.VariableDependencies is null retrieve it from database
variable.DependentVariableDependencies = variable.DependentVariableDependencies ?? new VariableDependencyService(base.UnitOfWork).GetList(variable.ID, null);
//add variable dependies to whereclause which have relation with current variable.
this.AddDependencyClause(variable, queryParams, columnParams, ref whereClause, additionalParams, allSavedEntities);
string sqlQueryIsExist = $@"(select top(1) {entityDef.FormattedTableName}.ID from {entityDef.FormattedTableName} {whereClause} {orderClause})";
string sqlInsertQuery = $@"INSERT INTO {entityDef.FormattedTableName}
({(base.EngineSharedModel.CurrentThreadID.HasValue ? "ThreadID," : "")}{string.Join(",", columnParams.Select(c => c.ParameterName.TrimStart('@')))})
OUTPUT inserted.ID
VALUES
({(base.EngineSharedModel.CurrentThreadID.HasValue ? ("'" + base.EngineSharedModel.CurrentThreadID.Value + "',") : "")}{string.Join(",", columnParams.Select(c => c.ParameterName))})";
this.AddDefaultParams((sqlInsertQuery + sqlQueryIsExist), queryParams);
this.AddVariableParameters(ref sqlInsertQuery, queryParams);
this.AddVariableParameters(ref sqlQueryIsExist, queryParams);
queryParams = columnParams.Union(queryParams).Where(c => (sqlInsertQuery + sqlQueryIsExist).Contains(c.ParameterName)).GroupBy(c => c.ParameterName).Select(c => c.FirstOrDefault()).ToList();
DataTable dataTableIsExist = new DataBaseQueryService(base.UnitOfWork).GetBySqlQuery(sqlQueryIsExist, true, null, queryParams.ToArray());
Guid? entityIsExistId = dataTableIsExist != null && dataTableIsExist.Rows.Count > 0 ? dataTableIsExist.Rows[0][0].ToGuidObj() : (Guid?)null;
if (entityIsExistId.HasValue)
{
string sqlUpdateQuery = $@"update {entityDef.FormattedTableName} set {string.Join(",", columnParams.Select(c => c.ParameterName.TrimStart('@') + "=" + c.ParameterName))} where ID='{entityIsExistId.ToStringObj()}'";
//update entity
new DataBaseQueryService(base.UnitOfWork).ExecuteBySqlQuery(sqlUpdateQuery, true, queryParams.ToArray());
}
else
{
//insert entity
this.CheckMandatory(resultOperation, entityDef, columnParams);
if (resultOperation.IsSuccess)
{
entityIsExistId = new DataBaseQueryService(base.UnitOfWork).ExecuteScalar <Guid>(sqlInsertQuery, true, queryParams.ToArray()).ToGuidObjNull();
}
}
return(new Tuple <ResultOperation, Guid?>(resultOperation, entityIsExistId));
}
//this method make order clause for filtering Entity
public static string GenerateOrderClause(sysBpmsVariable variable)
{
return(!string.IsNullOrWhiteSpace(variable.OrderByClause) ? $" order by {variable.OrderByClause}" : "");
}
public EntityVariableTypeEngine(EngineSharedModel engineSharedModel, sysBpmsVariable variable, Guid?processID, Guid?threadID, List <QueryModel> additionalParams, IUnitOfWork unitOfWork = null) : base(engineSharedModel, variable, processID, threadID, additionalParams, unitOfWork)
{
this.EntityDef = new EntityDefService(base.UnitOfWork).GetInfo(Variable.EntityDefID.Value);
}
public ResultOperation Update(sysBpmsVariable variable, List <sysBpmsVariableDependency> listVariables)
{
ResultOperation resultOperation = new ResultOperation();
try
{
this.BeginTransaction();
if (resultOperation.IsSuccess)
{
if (variable.RelationTypeLU != (int)sysBpmsVariable.e_RelationTypeLU.Entity)
{
variable.FilterTypeLU = variable.ApplicationPageID.HasValue ? (int)sysBpmsVariable.e_FilterTypeLU.AllEntities : variable.FilterTypeLU;
variable.EntityDefID = null;
variable.FieldName = string.Empty;
}
if (variable.RelationTypeLU != (int)sysBpmsVariable.e_RelationTypeLU.SqlQuery)
{
variable.Query = string.Empty;
variable.DBConnectionID = null;
}
sysBpmsVariable preVariable = this.GetInfo(variable.ProcessID, variable.ApplicationPageID, variable.Name);
if (preVariable != null && preVariable.ID != variable.ID)
{
resultOperation.AddError(LangUtility.Get("SameName.Error", nameof(sysBpmsVariable)));
}
if (resultOperation.IsSuccess)
{
this.UnitOfWork.Repository <IVariableRepository>().Update(variable);
this.UnitOfWork.Save();
//if variable is entity type.
if (variable.RelationTypeLU == (int)sysBpmsVariable.e_RelationTypeLU.Entity)
{
listVariables = listVariables ?? new List <sysBpmsVariableDependency>();
//VariableDependency
List <sysBpmsVariableDependency> Dependencies = new VariableDependencyService(base.UnitOfWork).GetList(variable.ID, null);
//delete VariableDependency if is not exist in listVariables
Dependencies.ForEach(c =>
{
if (!listVariables.Any(d => d.ID == c.ID))
{
new VariableDependencyService(base.UnitOfWork).Delete(c.ID);
}
});
//add or update VariableDependency
foreach (var item in listVariables)
{
item.DependentVariableID = variable.ID;
if (resultOperation.IsSuccess)
{
if (item.ID == Guid.Empty)
{
resultOperation = new VariableDependencyService(base.UnitOfWork).Add(item);
}
else
{
resultOperation = new VariableDependencyService(base.UnitOfWork).Update(item);
}
}
}
}
else
{
new VariableDependencyService(base.UnitOfWork).GetList(variable.ID, null).ForEach(c =>
{
if (resultOperation.IsSuccess)
{
resultOperation = new VariableDependencyService(base.UnitOfWork).Delete(c.ID);
}
});
}
}
}
}
catch (Exception ex)
{
return(base.ExceptionHandler(ex));
}
base.FinalizeService(resultOperation);
return(resultOperation);
}
public void Add(sysBpmsVariable variable)
{
variable.ID = Guid.NewGuid();
this.Context.sysBpmsVariables.Add(variable);
}
public ResultOperation SaveIntoDataBase(ContentHtml contentHtml, sysBpmsThreadTask threadTask, List <VariableModel> setExternalVariable, string threadTaskDescription)
{
ResultOperation resultOperation = new ResultOperation();
try
{
base.BeginTransaction();
//First set variable according to elements.
//resultOperation = this.SetValuesToElements(contentHtml);
//Then set external variables, filled by user defined actions.
if (setExternalVariable != null)
{
foreach (var item in setExternalVariable)
{
foreach (var dataModel in item.Items)
{
foreach (var val in dataModel.ToList())
{
this.SetValueByBinding(val.Key, val.Value);
}
}
}
}
if (resultOperation.IsSuccess)
{
resultOperation = this.SaveInto();
}
if (resultOperation.IsSuccess)
{
DocumentEngine documentEngine = new DocumentEngine(base.EngineSharedModel, base.UnitOfWork);
foreach (FileUploadHtml item in contentHtml.Rows.SelectMany(r => (r is RowHtml ? ((RowHtml)r).Columns : ((AccordionHtml)r).GetListColumn()).SelectMany(d => d.children.Where(f => f is FileUploadHtml).ToList())))
{
if (resultOperation.IsSuccess)
{
sysBpmsVariable variable = item.VariableId.ToGuidObjNull() == null ? null :
new VariableService(base.UnitOfWork).GetInfo(item.VariableId.ToGuidObj());
Guid?entityId = (variable != null && this.SetDataList.ContainsKey(variable.Name)) ? this.SetDataList[variable?.Name].GetValue <Guid>("ID") : (Guid?)null;
Guid?entityDefId = variable?.EntityDefID;
resultOperation = documentEngine.IsValid(item, variable, entityId, entityDefId, base.EngineSharedModel.CurrentUserName);
if (resultOperation.IsSuccess)
{
resultOperation = documentEngine.SaveFile(item, variable, entityId, entityDefId, "", base.EngineSharedModel.CurrentUserName);
}
}
}
}
if (resultOperation.IsSuccess)
{
if (!string.IsNullOrWhiteSpace(this.ThreadTaskDescription))
{
threadTask.Update(this.ThreadTaskDescription);
new ThreadTaskService(base.UnitOfWork).Update(threadTask);
}
}
}
catch (Exception ex)
{
return(base.ExceptionHandler(ex));
}
base.FinalizeService(resultOperation);
return(resultOperation);
}
