public List <ClientReportInfo> GetClientReport(ReportCondition c)
{
using (var db = GetDbContext())
{
var orderPred = PredicateBuilder.New <ZY_Customer>(x => x.CreatedTime != null);
if (c.FromDate.HasValue)
{
var f = c.FromDate.Value.Date;
orderPred = orderPred.And(x => x.CreatedTime >= f);
}
if (c.ToDate.HasValue)
{
var to = c.ToDate.Value.Date.AddDays(1);
orderPred = orderPred.And(x => x.CreatedTime < to);
}
var tmp = db.ZY_Customer.AsExpandable()
.Where(orderPred)
.Select(x => new { x.OpenId, x.CreatedTime })
.ToList()
.Select(x => new
{
x.OpenId,
CreatedTime = x.CreatedTime.ToString("yyyy-MM")
});
return(tmp.ToList().GroupBy(x => x.CreatedTime)
.Select(x => new ClientReportInfo()
{
Time = x.Key
,
Value = x.Count()
}).ToList());
}
}
public ActionResult GetClientReport(ReportCondition c)
{
var now = DateTime.Now;
c.FromDate = now.AddMonths(-12);
c.ToDate = now;
var data = BS.GetClientReport(c);
var list = new List <ClientReportInfo>();
for (DateTime i = c.FromDate.Value; i <= c.ToDate; i = i.AddMonths(1))
{
var m = i.ToString("yyyy-MM");
var d = data.FirstOrDefault(x => x.Time == m);
if (d != null)
{
list.Add(d);
}
else
{
list.Add(new ClientReportInfo()
{
Time = m
});
}
}
var result = new JsonNetResult()
{
Data = list, MaxJsonLength = int.MaxValue
};
result.Settings.DateFormatString = "yyyy-MM-dd";
return(result);
}
private static ReportCondition ReportConditionFromRule(ReportConditionalFormatRule rule, ReportColumn column)
{
ReportCondition reportCondition = new ReportCondition();
if (rule.Operator.HasValue && rule.Operator != ConditionType.Unspecified)
{
string alias = "oper" + rule.Operator.ToString();
reportCondition.Operator = Entity.Get <OperatorEnum>(new EntityRef(alias));
}
Parameter parameter = reportCondition.ConditionParameter != null?reportCondition.ConditionParameter.AsWritable <Parameter>() : new Parameter();
// Clear the old parameter
if (parameter.ParamTypeAndDefault != null)
{
parameter.ParamTypeAndDefault.AsWritable().Delete();
}
// Force entity resource list for argument if we have entities
ActivityArgument activityArgument = null;
if (rule.Values != null && rule.Values.Count > 0)
{
ResourceListArgument resourceList = new ResourceListArgument();
foreach (KeyValuePair <long, string> valuePair in rule.Values)
{
Resource resource = Entity.Get <Resource>(valuePair.Key);
if (resource != null)
{
resourceList.ResourceListParameterValues.Add(resource);
}
}
TypedArgument argumentType = column.ColumnExpression.ReportExpressionResultType.As <TypedArgument>();
resourceList.ConformsToType = argumentType.ConformsToType;
activityArgument = resourceList.As <ActivityArgument>();
activityArgument.Save();
}
else if (rule.Operator.HasValue)
{
int operatorCount = ConditionTypeHelper.GetArgumentCount(rule.Operator.Value);
if (operatorCount > 0)
{
activityArgument = ReportConditionHelper.ArgumentForConditionType(column.ColumnExpression.ReportExpressionResultType, rule.Operator.Value, rule.Value);
activityArgument.Save();
}
}
parameter.ParamTypeAndDefault = activityArgument;
parameter.Save();
reportCondition.ConditionParameter = parameter;
return(reportCondition);
}
private static void CheckCondition <TArg>(ReportCondition condition, string name, string expectedTypeName = null) where TArg : class, IEntity
{
Assert.IsNotNull(condition);
Assert.AreEqual(name, condition.Name);
Assert.IsNotNull(condition.ConditionExpression);
Assert.IsNotNull(condition.ConditionExpression.ReportExpressionResultType);
Assert.IsTrue(condition.ConditionExpression.ReportExpressionResultType.Is <TArg>());
if (expectedTypeName != null)
{
var rla = condition.ConditionExpression.ReportExpressionResultType.As <ResourceListArgument>();
Assert.IsNotNull(rla, "ResourceListArgument");
Assert.IsNotNull(rla.ConformsToType, "Conforms to type");
Assert.AreEqual(expectedTypeName, rla.ConformsToType.Name, "Conforms to type");
}
}
public List <OrderReportInfo> GetOrderReport(ReportCondition c)
{
using (var db = GetDbContext())
{
var orderPred = PredicateBuilder.New <ZZ_Order>(x => x.CheckOutDate != null);
if (c.FromDate.HasValue)
{
var f = c.FromDate.Value.Date;
orderPred = orderPred.And(x => x.CheckOutDate >= f);
}
if (c.ToDate.HasValue)
{
var to = c.ToDate.Value.Date.AddDays(1);
orderPred = orderPred.And(x => x.CheckOutDate < to);
}
var tmp = db.ZZ_Order.AsExpandable()
.Where(orderPred)
.Select(x => new { x.OrderId, x.CheckOutDate, x.TotalAmount, x.Quiantity })
.ToList()
.Select(x => new
{
x.OrderId,
x.TotalAmount,
x.Quiantity,
CheckOutTime = x.CheckOutDate.Value.ToString("yyyy-MM")
});
return(tmp.ToList().GroupBy(x => x.CheckOutTime)
.Select(x => new OrderReportInfo()
{
CheckOutTime = x.Key
,
Orders = x.Count()
,
Quiantity = x.Sum(y => y.Quiantity)
,
TotalAmount = x.Sum(t => t.TotalAmount)
}).ToList());
}
}
/// <summary>
/// Builds the condition parameter.
/// </summary>
/// <param name="reportCondition">The report condition.</param>
/// <param name="queryCondition">The query condition.</param>
/// <param name="context"></param>
internal static void BuildConditionParameter([NotNull] ReportCondition reportCondition, QueryCondition queryCondition, FromEntityContext context)
{
if (reportCondition == null)
{
throw new ArgumentNullException(nameof(reportCondition));
}
ActivityArgument activityArgument;
// Get the column expression for the analysable field. If this is a referenced column then use it's referenced column's expression.
ReportExpression reportExpression = reportCondition.ConditionExpression;
if (reportExpression != null && reportExpression.Is <ColumnReferenceExpression>())
{
reportExpression =
reportCondition.ConditionExpression.As <ColumnReferenceExpression>()
.ExpressionReferencesColumn.ColumnExpression;
}
if (reportCondition.ConditionParameter?.ParamTypeAndDefault != null)
{
activityArgument = reportCondition.ConditionParameter.ParamTypeAndDefault;
}
else if (reportExpression?.ReportExpressionResultType != null)
{
activityArgument = reportCondition.ConditionExpression.ReportExpressionResultType;
}
else
{
EventLog.Application.WriteWarning(context.DebugInfo + "condition parameter could not be processed");
return;
}
List <TypedValue> typedValues = TypedValueHelper.TypedValueFromEntity(activityArgument);
foreach (TypedValue typedValue in typedValues)
{
queryCondition.Arguments.Add(typedValue);
}
}
/// <summary>
/// Analysers the column for condition.
/// </summary>
/// <param name="report">The report.</param>
/// <param name="reportCondition">The report condition.</param>
/// <returns>
/// ReportAnalyserColumn.
/// </returns>
internal static ReportAnalyserColumn AnalyserColumnForCondition(Report report, ReportCondition reportCondition)
{
if (reportCondition.ConditionIsHidden ?? false)
{
// Do not include analyser conditions when they are hidden
return(null);
}
ReportAnalyserColumn reportAnalyserColumn = new ReportAnalyserColumn
{
Title = reportCondition.Name,
Ordinal = reportCondition.ConditionDisplayOrder ?? 0,
IsConditionLocked = reportCondition.ConditionIsLocked ?? false
};
if (reportCondition.Operator != null && reportCondition.Operator.ToString().Length > 4)
{
string[] conditionOperatorParts = reportCondition.Operator.Alias.Split(':');
string operatorString = conditionOperatorParts.Length == 2 ? conditionOperatorParts[1].Substring(4) : conditionOperatorParts[0].Substring(4);
Structured.ConditionType conditionType;
reportAnalyserColumn.Operator = Enum.TryParse(operatorString, true, out conditionType) ? conditionType : Structured.ConditionType.Unspecified;
}
else
{
reportAnalyserColumn.Operator = Structured.ConditionType.Unspecified;
}
if (reportCondition.ColumnForCondition != null)
{
reportAnalyserColumn.ReportColumnId = reportCondition.ColumnForCondition.Id;
}
if (reportCondition.ConditionExpression == null)
{
return(null);
}
// Get the argument
ActivityArgument reportExpressionResultType = reportCondition.ConditionExpression.Is <ColumnReferenceExpression>() ?
reportCondition.ConditionExpression.As <ColumnReferenceExpression>().ExpressionReferencesColumn.ColumnExpression.ReportExpressionResultType :
reportCondition.ConditionExpression.ReportExpressionResultType;
// Process the expression result associated to this condition
DatabaseType type; // scalar type of analyser expression
EntityType resourceType; // resource type of analyser expression
if (reportExpressionResultType == null || !PopulateTypeFromArgument(reportExpressionResultType, out type, out resourceType))
{
return(null);
}
reportAnalyserColumn.Type = type;
if (resourceType != null)
{
reportAnalyserColumn.TypeId = resourceType.Id;
}
reportAnalyserColumn.DefaultOperator = DefaultOperatorForType(reportExpressionResultType);
// Get the column expression for the analysable field. If this is a referenced column then use it's referenced column's expression.
ReportExpression reportExpression = reportCondition.ConditionExpression.Is <ColumnReferenceExpression>() ?
reportCondition.ConditionExpression.As <ColumnReferenceExpression>().ExpressionReferencesColumn.ColumnExpression : reportCondition.ConditionExpression;
// Track current user for a 'core:UserAccount' or any derivatives and 'core:Person' or any derivatives and if the source node
// is one of these and the report expression's field type is 'core:name' then fudge the analyser type to be 'UserString' which includes all
// string analyser operator definitions in addition to the 'Current User' operator.
PopulateAnalyserTypeForColumn(report, resourceType, reportExpression, reportAnalyserColumn);
// Process any values associated to this condition.
if (reportCondition.ConditionParameter != null && reportCondition.ConditionParameter.ParamTypeAndDefault != null)
{
ActivityArgument activityArgument = reportCondition.ConditionParameter.ParamTypeAndDefault;
PopulateValueFromArgument(activityArgument, reportAnalyserColumn);
}
// resource picker for condition parameter
if (reportCondition.ConditionParameterPicker != null)
{
reportAnalyserColumn.ConditionParameterPickerId = reportCondition.ConditionParameterPicker.Id;
}
return(reportAnalyserColumn);
}
public RequestResult <List <KeyValue> > GetDict(ReportCondition reportCondition)
{
return(Success(AnesQuery.GetDict(reportCondition)));
}
private void AddCondition()
{
ReportConditions conditions = ReportConditions;
ReportCondition condition = new ReportCondition();
condition.IsCustomField = IsValueCustomField(cmbFields.SelectedValue);
condition.FieldID = GetValueFieldID(cmbFields.SelectedValue);
condition.DisplayName = cmbFields.SelectedItem.Text;
condition.ConditionOperator = (ConditionOperator)int.Parse(cmbOperator.SelectedValue);
ReportDataType dataType = GetDataType(cmbFields.SelectedValue);
switch (dataType)
{
case ReportDataType.String:
/*if (textValue.Text == "")
* {
* _manager.Alert("Please enter a value.");
* return;
* }*/
condition.Value1 = textValue.Text;
break;
case ReportDataType.Int:
if (numValue1.Value == null)
{
_manager.Alert("Please enter a value.");
return;
}
if (numValue2.Visible && numValue2.Value == null)
{
_manager.Alert("Please enter the second value.");
return;
}
condition.Value1 = (int)numValue1.Value;
if (numValue2.Visible)
{
condition.Value2 = (int)numValue2.Value;
}
break;
case ReportDataType.Float:
if (numValue1.Value == null)
{
_manager.Alert("Please enter a value.");
return;
}
if (numValue2.Visible && numValue2.Value == null)
{
_manager.Alert("Please enter the second value.");
return;
}
condition.Value1 = (double)numValue1.Value;
if (numValue2.Visible)
{
condition.Value2 = (double)numValue2.Value;
}
break;
case ReportDataType.DateTime:
if (dateValue1.SelectedDate == null)
{
_manager.Alert("Please enter a date.");
return;
}
if (dateValue2.Visible && dateValue2.SelectedDate == null)
{
_manager.Alert("Please enter the second date.");
return;
}
condition.Value1 = (DateTime)dateValue1.SelectedDate;
if (dateValue2.Visible)
{
condition.Value2 = (DateTime)dateValue2.SelectedDate;
}
break;
case ReportDataType.Boolean:
condition.Value1 = cmbBool.SelectedIndex == 0;
break;
default:
break;
}
if (condition.Value1 == null)
{
_manager.Alert("Please enter a value.");
return;
}
if ((condition.ConditionOperator == ConditionOperator.IsNotInBetween || condition.ConditionOperator == ConditionOperator.IsInBetween) && condition.Value2 == null)
{
_manager.Alert("Please enter the second value.");
return;
}
conditions.Items.Add(condition);
ReportConditions = conditions;
litDisplayText.Text = conditions.ToString();
}
