public void Send(string command, ReqDTO dto)
    {
        SendData sendData = new SendData()
        {
            cmd  = command,
            data = dto
        };

        Send(sendData);
    }
        public ActionResult QueryByYear(ReqDTO req)
        {
            if (!req.Year.HasValue || req.Month.HasValue)
            {
                return(Json(OperationResult.Error("参数错误")));
            }

            var      statMonthes = new List <Tuple <DateTime, DateTime> >();
            DateTime monthStart  = DateTime.Now;
            DateTime monthEnd    = DateTime.Now;

            for (int i = 1; i <= 12; i++)
            {
                // 2017-04-01
                monthStart = new DateTime(year: req.Year.Value, month: i, day: 1);

                // 2017-5-01-00:00:01  =>   2017-04-30 23:59:59
                monthEnd = monthStart.AddMonths(1).AddSeconds(-1);

                statMonthes.Add(Tuple.Create(monthStart, monthEnd));
            }


            var startTime = statMonthes.First().Item1;
            var endTime   = statMonthes.Last().Item2;
            var dataQuery = _statService.Entities.Where(s => !s.IsDeleted && s.IsEnabled)
                            .Where(s => s.CreatedTime >= startTime && s.CreatedTime <= endTime)
                            .ToList()
                            //.Select(s => new { s.PartnerCount, s.OrderCount, s.OrderMoney, s.SaleCount, s.SaleMoney, s.MemberCount,s.CreatedTime })
                            .GroupBy(s => s.CreatedTime.Month)
                            .ToList();


            if (!dataQuery.Any())
            {
                return(Json(OperationResult.Error("没有数据"), JsonRequestBehavior.AllowGet));
            }

            List <ResDTO> monthlyData = new List <ResDTO>();

            //按月份统计出当月数据
            for (int i = 0; i < statMonthes.Count; i++)
            {
                var monthItem = statMonthes[i];

                var groupItem = dataQuery.FirstOrDefault(g => g.Key == monthItem.Item1.Month);
                if (groupItem == null)
                {
                    // 无信息
                    monthlyData.Add(new ResDTO()
                    {
                        IsAccumulate = req.IsAccumulate,
                        Year         = monthItem.Item1.Year,
                        Month        = monthItem.Item1.Month,
                        BeginTime    = monthItem.Item1.ToString("yyyy-MM-dd HH:mm:ss"),
                        EndTime      = monthItem.Item2.ToString("yyyy-MM-dd HH:mm:ss")
                    });
                }
                else
                {
                    var statData = new ResDTO
                    {
                        IsAccumulate = req.IsAccumulate,
                        Year         = monthItem.Item1.Year,
                        Month        = monthItem.Item1.Month,
                        BeginTime    = monthItem.Item1.ToString("yyyy-MM-dd HH:mm:ss"),
                        EndTime      = monthItem.Item2.ToString("yyyy-MM-dd HH:mm:ss"),
                        PartnerCount = groupItem.Sum(p => p.PartnerCount),
                        MemberCount  = groupItem.Sum(p => p.MemberCount),
                        OrderCount   = groupItem.Sum(p => p.OrderCount),
                        OrderMoney   = groupItem.Sum(p => (decimal)p.OrderMoney),
                        SaleCount    = groupItem.Sum(p => p.SaleCount),
                        SaleMoney    = groupItem.Sum(p => (decimal)p.SaleMoney),
                    };
                    monthlyData.Add(statData);
                }
            }



            if (!req.IsAccumulate)
            {
                //非累加模式,返回每月的数据

                return(Json(new OperationResult(OperationResultType.Success, string.Empty, monthlyData), JsonRequestBehavior.AllowGet));
            }
            else //累加模式
            {
                var orderedMonthData = monthlyData.OrderBy(r => r.Month).ToArray();
                var accumalatedData  = orderedMonthData.Select(i =>
                {
                    var query = orderedMonthData.Where(r => r.Month <= i.Month);
                    return(new ResDTO()
                    {
                        IsAccumulate = i.IsAccumulate,
                        BeginTime = i.BeginTime,
                        EndTime = i.EndTime,
                        Year = i.Year,
                        Month = i.Month,
                        MemberCount = query.Sum(q => q.MemberCount),
                        OrderCount = query.Sum(q => q.OrderCount),
                        OrderMoney = query.Sum(q => q.OrderMoney),
                        PartnerCount = query.Sum(q => q.PartnerCount),
                        SaleCount = query.Sum(q => q.SaleCount),
                        SaleMoney = query.Sum(q => q.SaleMoney)
                    });
                }).ToList();
                return(Json(new OperationResult(OperationResultType.Success, string.Empty, accumalatedData), JsonRequestBehavior.AllowGet));
            }
        }
Exemple #3
0
        public async Task <ReturnVal <GetCourseListRsp> > GetList(ReqDTO dto)
        {
            var ret = await this._query.QueryAsync(new Domain.DTOS.Queries.CourseParamters()
            {
                OrgId     = dto.OrgId,
                QueryType = '0',
                PageIndex = dto.PageNum - 1,
                PageSize  = dto.PageSize,
                //Status = (int)CourseStatus.RegionListed,
                OrgType = 'r',
            }, true);

            var rev = new GetCourseListRsp();

            if (ret.ItemCount == 0)
            {
                return(this.RetOk(rev));
            }

            var items = new List <CourseInfo>();


            var courseIdAry = ret.Data.Select(s => s.Id).ToList();



            var dict = await this._unitOfWork.GetRepositoryAsync <QuoteDsEntity>()
                       .Queryable(q => courseIdAry.Contains(q.ID))
                       .GroupBy(g => g.CourseId)
                       .Select(g => new
            {
                Id    = g.Key,
                Count = g.Count()
            })
                       .ToDictionaryAsync(q => q.Id, q => q.Count);



            foreach (var item in ret.Data)
            {
                CourseInfo info = new()
                {
                    Id           = item.Id,
                    CreateId     = item.CreatorCode.ToString(),
                    CreateName   = item.CreatorName,
                    Desc         = item.Intro,
                    JoinCount    = item.LearnerCount,
                    Name         = item.Name,
                    Status       = (int)CourseStatus.RegionListed,
                    GradeIds     = CourseInfo.GradeInfo(item.CatalogId, item.CatalogName),
                    Cover        = item.CoverUrl, //new string[] { item.CatalogName?.Split(new char[] { '/' }).FirstOrDefault() }
                    CreationTime = item.CreationTime.HasValue ? item.CreationTime.Value.ToString("yyyy-MM-dd HH:mm:ss") : null
                };

                if (dict != null && dict.TryGetValue(item.Id, out int val))
                {
                    item.LearnerCount = dict[item.Id];
                }

                items.Add(info);
            }

            rev.Courses    = items;
            rev.Totalcount = ret.ItemCount;

            return(this.RetOk(rev));
        }
    }