private void LoadRootPanelContent()
{
if (_rootPanel == null)
{
var parameters = BuildArguments(SelectParameters.GetValues(HttpContext.Current, this));
_rootPanel = Util.ESales.GetPanelContent(Path, parameters);
}
}
private StringBuilder CreateRawCacheKey()
{
// Note: The cache key will contain information such as server names and
// passwords, however it will be stored in the internal cache, which is
// not accessible to page developers, so it is secure.
StringBuilder sb = new StringBuilder(CacheInternal.PrefixDataSourceControl, 1024);
sb.Append(GetType().GetHashCode().ToString(CultureInfo.InvariantCulture));
sb.Append(CacheDuration.ToString(CultureInfo.InvariantCulture));
sb.Append(':');
sb.Append(((int)CacheExpirationPolicy).ToString(CultureInfo.InvariantCulture));
SqlDataSourceCache sqlCache = Cache as SqlDataSourceCache;
if (sqlCache != null)
{
sb.Append(":");
sb.Append(sqlCache.SqlCacheDependency);
}
sb.Append(":");
sb.Append(ConnectionString);
sb.Append(":");
sb.Append(SelectCommand);
//sb.Append(SelectCountCommand);
// Append parameter names and values
if (SelectParameters.Count > 0)
{
sb.Append("?");
IDictionary parameters = SelectParameters.GetValues(Context, this);
foreach (DictionaryEntry entry in parameters)
{
sb.Append(entry.Key.ToString());
if ((entry.Value != null) && (entry.Value != DBNull.Value))
{
sb.Append("=");
sb.Append(entry.Value.ToString());
}
else
{
if (entry.Value == DBNull.Value)
{
sb.Append("(dbnull)");
}
else
{
sb.Append("(null)");
}
}
sb.Append("&");
}
}
return(sb);
}
private object[] GetParametersForSelect(DataSourceSelectArguments arguments)
{
var parameters = new List <object>();
foreach (DictionaryEntry entry in SelectParameters.GetValues(HttpContext.Current, owner))
{
parameters.Add(entry.Value);
}
if (CanPage)
{
parameters.Add(arguments.MaximumRows);
parameters.Add(arguments.StartRowIndex);
}
if ((!string.IsNullOrEmpty(arguments.SortExpression)) && (!InternalSort))
{
parameters.Add(arguments.SortExpression);
}
return(parameters.ToArray());
}
protected override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments)
{
var args = new TpObjectDataSourceEventArgs();
owner.OnSelecting(args);
if (args.Cancel)
{
return(null);
}
object obj = args.BusinessObject ?? Source.GetDataFromSource(GetParametersForSelect(arguments));
if (arguments.RetrieveTotalRowCount && CanRetrieveTotalRowCount)
{
arguments.TotalRowCount = GetRowCount(obj);
}
args.SelectParams = SelectParameters.GetValues(HttpContext.Current, owner);
if (obj == null)
{
return(null);
}
if (!(obj is IEnumerable))
{
obj = new[] { obj };
}
if (InternalSort && (!string.IsNullOrEmpty(arguments.SortExpression)))
{
obj = Sort((IEnumerable)obj, arguments.SortExpression);
}
args.BusinessObject = obj;
owner.OnSelected(args);
return((IEnumerable)obj);
}
private void InitializeParameters(out string fetchXml, out QueryByAttribute query)
{
// merge the select parameters
IOrderedDictionary parameters = QueryParameters.GetValues(_context, _owner);
fetchXml = GetNonNullOrEmpty(
parameters[_fetchXmlParameterName] as string,
_owner.FetchXml);
if (!string.IsNullOrEmpty(fetchXml))
{
IOrderedDictionary selectParameters = SelectParameters.GetValues(_context, _owner);
// apply select parameters replacement to the FetchXml
foreach (DictionaryEntry entry in selectParameters)
{
if (entry.Key != null)
{
string key = entry.Key.ToString().Trim();
if (!key.StartsWith("@"))
{
key = "@" + key;
}
string value = "{0}".FormatWith(entry.Value);
if (Owner.EncodeParametersEnabled)
{
value = AntiXssEncoder.XmlEncode(value);
}
fetchXml = Regex.Replace(fetchXml, key, value, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
}
}
}
// process the QueryByAttribute
query = null;
if (_owner.QueryByAttribute != null && !string.IsNullOrEmpty(_owner.QueryByAttribute.EntityName))
{
IOrderedDictionary selectParameters = SelectParameters.GetValues(_context, _owner);
query = new QueryByAttribute();
query.EntityName = LookupParameter(selectParameters, _owner.QueryByAttribute.EntityName);
query.Attributes.AddRange(CopyParameters(selectParameters, _owner.QueryByAttribute.Attributes));
query.Values.AddRange(CopyParameters(selectParameters, _owner.QueryByAttribute.Values));
if (_owner.QueryByAttribute.ColumnSet != null && _owner.QueryByAttribute.ColumnSet.Count > 0)
{
// specify individual columns to load
query.ColumnSet = new ColumnSet(CopyParameters(selectParameters, _owner.QueryByAttribute.ColumnSet));
}
else
{
// default to all columns
query.ColumnSet = new ColumnSet(true);
}
if (_owner.QueryByAttribute.Orders != null && _owner.QueryByAttribute.Orders.Count > 0)
{
for (int i = 0; i < _owner.QueryByAttribute.Orders.Count; ++i)
{
OrderExpression order = new OrderExpression();
order.AttributeName = LookupParameter(selectParameters, _owner.QueryByAttribute.Orders[i].Value);
string orderText = LookupParameter(selectParameters, _owner.QueryByAttribute.Orders[i].Text);
if (orderText.StartsWith("desc", StringComparison.InvariantCultureIgnoreCase))
{
order.OrderType = OrderType.Descending;
}
query.Orders.Add(order);
}
}
// merge the select parameters
string entityName = parameters[_entityNameParameterName] as string;
if (!string.IsNullOrEmpty(entityName))
{
query.EntityName = entityName;
}
// comma delimited
string attributes = parameters[_attributesParameterName] as string;
if (!string.IsNullOrEmpty(attributes))
{
query.Attributes.Clear();
query.Attributes.AddRange(attributes.Split(','));
}
// comma delimited
string values = parameters[_valuesParameterName] as string;
if (!string.IsNullOrEmpty(values))
{
query.Values.Clear();
query.Values.AddRange(values.Split(','));
}
// comma delimited
string columnSet = parameters[_columnSetParameterName] as string;
if (!string.IsNullOrEmpty(columnSet))
{
if (string.Compare(columnSet, _allColumnsParameterValue, StringComparison.InvariantCultureIgnoreCase) == 0)
{
query.ColumnSet = new ColumnSet(true);
}
else
{
string[] parts = columnSet.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length > 0)
{
for (int i = 0; i < parts.Length; i++)
{
parts[i] = parts[i].Trim();
}
query.ColumnSet.AddColumns(parts);
}
else
{
query.ColumnSet = new ColumnSet(true);
}
}
}
// comma delimited
string orders = parameters[_ordersParameterName] as string;
if (!string.IsNullOrEmpty(orders))
{
QueryByAttribute queryByAttribute = query;
AppendSortExpressionToQuery(orders, order => queryByAttribute.Orders.Add(order));
query = queryByAttribute;
}
// all remaining parameters are treated as key/value pairs
Dictionary <string, object> extendedParameters = new Dictionary <string, object>();
if (query.Attributes != null)
{
for (int i = 0; i < query.Attributes.Count; ++i)
{
extendedParameters[query.Attributes[i]] = query.Values[i];
}
}
bool changed = false;
foreach (string key in parameters.Keys)
{
// ignore special parameters
if (!Array.Exists(_keywords, delegate(string value) { return(string.Compare(value, key, StringComparison.InvariantCultureIgnoreCase) == 0); }))
{
extendedParameters[key] = parameters[key];
changed = true;
}
}
if (changed)
{
query.Attributes.Clear();
query.Values.Clear();
int i = 0;
foreach (KeyValuePair <string, object> extendedParameter in extendedParameters)
{
query.Attributes[i] = extendedParameter.Key;
query.Values[i] = extendedParameter.Value;
++i;
}
}
}
}
