protected void QuickAddCondition(SqlCriteria sqlCriteria, ModelQueryType queryType, string name, BeeDataAdapter dataAdapter)
{
if (queryType == ModelQueryType.Between)
{
if (dataAdapter.ContainsKey(name + "begin"))
{
sqlCriteria.GreaterThanOrEqual(name, dataAdapter[name + "begin"]);
}
if (dataAdapter.ContainsKey(name + "end"))
{
sqlCriteria.GreaterThanOrEqual(name, dataAdapter[name + "end"]);
}
}
else
{
if (dataAdapter.ContainsKey(name))
{
AddCondition(sqlCriteria, queryType, name, dataAdapter[name]);
}
}
}
private BeeDataAdapter GetSearchItem(PropertySchema propertySchema)
{
BeeDataAdapter dataAdapter = null;
ModelPropertyAttribute modelPropertyAttribute
= propertySchema.GetCustomerAttribute <ModelPropertyAttribute>();
if (modelPropertyAttribute != null)
{
if (!modelPropertyAttribute.Visible)
{
return(null);
}
if (!modelPropertyAttribute.Queryable)
{
return(null);
}
dataAdapter = new BeeDataAdapter();
string descriptionInfo = modelPropertyAttribute.Description;
if (string.IsNullOrEmpty(descriptionInfo))
{
descriptionInfo = propertySchema.Name;
}
dataAdapter.Add("name", propertySchema.Name);
dataAdapter.Add("Type", propertySchema.PropertyType);
dataAdapter.Add("QueryType", modelPropertyAttribute.QueryType);
dataAdapter.Add("Description", descriptionInfo);
if (!string.IsNullOrEmpty(modelPropertyAttribute.MappingName))
{
dataAdapter.Add("MappingName", modelPropertyAttribute.MappingName);
}
if (propertySchema.PropertyType.IsEnum && !dataAdapter.ContainsKey("MappingName"))
{
dataAdapter.Add("MappingName", propertySchema.PropertyType.ToString());
}
}
return(dataAdapter);
}
public override PageResult Index(BeeDataAdapter dataAdapter)
{
DbSession dbSession = GetDbSession();
DataTable dataTable = null;
try
{
InitPagePara(dataAdapter);
EntityProxy <WeiXinUser> entityProxy = EntityProxyManager.Instance.GetEntityProxy <WeiXinUser>();
SqlCriteria sqlCriteria = GetQueryCondition(dataAdapter);
if (dataAdapter.ContainsKey("linkflag"))
{
bool linkFlag = dataAdapter.TryGetValue <Boolean>("linkflag", false);
if (!linkFlag)
{
sqlCriteria.Equal("fakeid", "");
}
else
{
sqlCriteria.NotEqual("fakeid", "");
}
}
string selectClause = GetQuerySelectClause(typeof(WeiXinUser));
dataTable = InnerQuery("WeiXinUser", selectClause, dataAdapter, sqlCriteria);
}
catch (Exception e)
{
Logger.Error("List object({0}) Error".FormatWith(typeof(WeiXinUser)), e);
}
finally
{
dbSession.Dispose();
}
return(View(dataTable));
}
/// <summary>
/// Gets the conditions via the attribute of the modeltype and the data from page.
/// </summary>
/// <param name="modelType">the model type.</param>
/// <param name="dataAdapter">the data from page.</param>
/// <returns>the condition.</returns>
protected virtual SqlCriteria GetQueryCondition(Type modelType, BeeDataAdapter dataAdapter)
{
IEntityProxy entityProxy = EntityProxyManager.Instance.GetEntityProxyFromType(modelType);
SqlCriteria result = new SqlCriteria();
dataAdapter = new BeeDataAdapter(dataAdapter);
dataAdapter.RemoveEmptyOrNull();
ModelAttribute modelAttribute = entityProxy.GetCustomerAttribute <ModelAttribute>();
foreach (PropertySchema propertySchema in entityProxy.GetPropertyList())
{
string propertyName = propertySchema.Name;
ModelPropertyAttribute modelPropertyAttribute
= propertySchema.GetCustomerAttribute <ModelPropertyAttribute>();
if (modelPropertyAttribute != null)
{
if (dataAdapter.ContainsKey(propertyName))
{
if (modelPropertyAttribute.Queryable)
{
object conditionValue = dataAdapter[propertyName];
if (propertySchema.PropertyType == typeof(string))
{
conditionValue = HttpUtility.HtmlDecode(conditionValue.ToString());
}
if (modelPropertyAttribute.QueryType == ModelQueryType.Equal &&
propertySchema.PropertyType == typeof(bool))
{
bool value = false;
bool.TryParse(conditionValue.ToString(), out value);
if (value)
{
conditionValue = 1;
}
else
{
conditionValue = 0;
}
}
if (propertySchema.PropertyType == typeof(DateTime))
{
DateTime propertyValue = dataAdapter.TryGetValue <DateTime>(propertyName, DateTime.MinValue);
if (propertyValue != DateTime.MinValue)
{
conditionValue = propertyValue;
}
else
{
// 若是时间，而又没有赋值， 则略过
continue;
}
}
AddCondition(result, modelPropertyAttribute.QueryType, propertyName, conditionValue);
}
}
else
{
if (modelPropertyAttribute.Queryable &&
modelPropertyAttribute.QueryType == ModelQueryType.Between)
{
if (dataAdapter.ContainsKey(propertyName + "begin"))
{
if (propertySchema.PropertyType == typeof(DateTime))
{
DateTime beginTime = dataAdapter.TryGetValue <DateTime>(propertyName + "begin", DateTime.MinValue);
result.GreaterThanOrEqual(propertyName, beginTime);
}
else
{
result.GreaterThanOrEqual(propertyName, dataAdapter[propertyName + "begin"]);
}
}
if (dataAdapter.ContainsKey(propertyName + "end"))
{
DateTime endTime = dataAdapter.TryGetValue <DateTime>(propertyName + "end", DateTime.MinValue);
if (propertySchema.PropertyType == typeof(DateTime))
{
if (endTime == endTime.Date)
{
endTime = endTime.AddDays(1);
}
//result.LessThan(propertyName, endTime.ToString("yyyy-MM-dd"));
result.LessThan(propertyName, endTime);
}
else
{
result.LessThanOrEqual(propertyName, dataAdapter[propertyName + "end"]);
}
}
}
}
}
}
return(result);
}
private static bool CheckMethod(MethodSchema methodSchema, string methodName
, BeeDataAdapter dataAdapter, out BeeDataAdapter filteredData)
{
bool result = false;
filteredData = new BeeDataAdapter();
bool flag = true;
List <ParameterInfo> customerTypeParaList = new List <ParameterInfo>();
List <ParameterInfo> simpleTypeParaList = new List <ParameterInfo>();
foreach (ParameterInfo parameterInfo in methodSchema.ParameterInfos)
{
if (Type.GetTypeCode(parameterInfo.ParameterType) == TypeCode.Object &&
parameterInfo.ParameterType != typeof(Guid))
{
customerTypeParaList.Add(parameterInfo);
}
else
{
simpleTypeParaList.Add(parameterInfo);
}
}
foreach (ParameterInfo parameterInfo in simpleTypeParaList)
{
// check the simple parameters name
if (!dataAdapter.ContainsKey(parameterInfo.Name))
{
flag = false;
break;
}
}
if (flag)
{
foreach (ParameterInfo parameterInfo in simpleTypeParaList)
{
filteredData.Add(parameterInfo.Name, dataAdapter[parameterInfo.Name]);
}
if (customerTypeParaList.Count == 0)
{
result = true;
}
else
{
bool allParameterFlag = true;
foreach (ParameterInfo parameterInfo in customerTypeParaList)
{
object dataValue = dataAdapter[parameterInfo.Name];
if (dataValue == null || parameterInfo.ParameterType != dataValue.GetType())
{
allParameterFlag = false;
}
}
if (allParameterFlag)
{
result = true;
}
else if (customerTypeParaList.Count == 1)
{
// try to match if possible
foreach (ParameterInfo parameterInfo in customerTypeParaList)
{
if (parameterInfo.ParameterType == typeof(BeeDataAdapter))
{
//dataAdapter.RemoveEmptyOrNull();
filteredData.Add(parameterInfo.Name, dataAdapter);
}
else
{
filteredData.Add(parameterInfo.Name,
ConvertUtil.ConvertDataToObject(parameterInfo.ParameterType, dataAdapter));
//dataAdapter.RemoveEmptyOrNull();
}
}
result = true;
}
else
{
// do nothing here.
}
}
}
return(result);
}
private BeeDataAdapter GetDetailItem(PropertySchema propertySchema, string identityColumn)
{
ModelPropertyAttribute modelPropertyAttribute
= propertySchema.GetCustomerAttribute <ModelPropertyAttribute>();
BeeDataAdapter dataAdapter = new BeeDataAdapter();
string descriptionInfo;
bool readOnly = false;
if (string.Compare(identityColumn, propertySchema.Name, true) == 0)
{
dataAdapter.Add("showonly", true);
readOnly = true;
}
if (modelPropertyAttribute != null)
{
descriptionInfo = modelPropertyAttribute.Description;
if (string.IsNullOrEmpty(descriptionInfo))
{
descriptionInfo = propertySchema.Name;
}
if (!modelPropertyAttribute.Visible)
{
dataAdapter.Add("visible", false);
}
if (!string.IsNullOrEmpty(modelPropertyAttribute.MappingName))
{
dataAdapter.Add("mappingname", modelPropertyAttribute.MappingName);
}
readOnly = readOnly || modelPropertyAttribute.ReadonlyFlag;
if (!readOnly)
{
if (propertySchema.PropertyType.UnderlyingSystemType == typeof(DateTime))
{
if (string.Compare("modifytime", propertySchema.Name, true) == 0 ||
string.Compare("updatetime", propertySchema.Name, true) == 0 ||
string.Compare("createtime", propertySchema.Name, true) == 0)
{
readOnly = true;
dataAdapter.Add("showonly", true);
}
}
}
}
else
{
descriptionInfo = propertySchema.Name;
}
dataAdapter.Add("description", descriptionInfo);
dataAdapter.Add("name", propertySchema.Name);
dataAdapter.Add("readonly", readOnly);
if (propertySchema.PropertyType == typeof(DateTime))
{
dataAdapter.Add("date", true);
}
if (propertySchema.PropertyType.IsEnum && !dataAdapter.ContainsKey("mappingname"))
{
dataAdapter.Add("mappingname", propertySchema.PropertyType.ToString());
}
return(dataAdapter);
}
