[HttpGet, Route("SearchActivityEventLogAllReport"), AllowAnonymous]//AmigoTenantClaimsAuthorize(ActionCode = ConstantsSecurity.ActionCode.WeeklyReportSearch)
        public HttpResponseMessage SearchActivityEventLogAllReport([FromUri] ActivityEventLogSearchRequest search)
        {
            var response = Request.CreateResponse();

            response.Content = new PushStreamContent((outputStream, httpContent, transportContext)
                                                     => _activityEventLogApplicationService.GenerateDataCsvToReportExcel(outputStream, httpContent, transportContext, search), new MediaTypeHeaderValue("text/csv"));
            response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
            {
                FileName        = "ActivityLog.csv",
                DispositionType = "inline"
            };
            return(response);
        }
Example #2
0
        private Expression <Func <ActivityEventLogDTO, bool> > GetQueryFilter(ActivityEventLogSearchRequest search)
        {
            Expression <Func <ActivityEventLogDTO, bool> > queryFilter = p => true;

            queryFilter = queryFilter.And(p => p.RowStatus == true);

            if (search.ActivityTypeIds != null && search.ActivityTypeIds.Count() > 0)
            {
                queryFilter = queryFilter.And(p => search.ActivityTypeIds.Contains(p.ActivityTypeId));
            }

            if (!string.IsNullOrEmpty(search.UserName))
            {
                queryFilter = queryFilter.And(p => p.Username.Contains(search.UserName));
            }

            if (!string.IsNullOrEmpty(search.ResultCode))
            {
                queryFilter = queryFilter.And(p => p.LogType.Contains(search.ResultCode));
            }

            if (search.ReportedActivityDateFrom.HasValue && search.ReportedActivityDateTo.HasValue)
            {
                var toPlusADay = search.ReportedActivityDateTo.Value.AddDays(1);
                queryFilter = queryFilter.And(p => p.ReportedActivityDate.Value >= search.ReportedActivityDateFrom);
                queryFilter = queryFilter.And(p => p.ReportedActivityDate.Value < toPlusADay);
            }
            else if (search.ReportedActivityDateFrom.HasValue && !search.ReportedActivityDateTo.HasValue)
            {
                queryFilter = queryFilter.And(p => p.ReportedActivityDate.Value >= search.ReportedActivityDateFrom);
            }
            else if (!search.ReportedActivityDateFrom.HasValue && search.ReportedActivityDateTo.HasValue)
            {
                var toPlusADay = search.ReportedActivityDateTo.Value.AddDays(1);
                queryFilter = queryFilter.And(p => p.ReportedActivityDate.Value < toPlusADay);
            }

            if (!string.IsNullOrEmpty(search.chargeNumber))
            {
                queryFilter = queryFilter.And(p => p.ChargeNo.Contains(search.chargeNumber));
            }

            return(queryFilter);
        }
        public async Task ActivityEventLogSearchRequest_Call_PagedList_in_repository()
        {
            var request = new ActivityEventLogSearchRequest()
            {
                //ActivityTypeIds = 0,
                UserName = "******",
                ReportedActivityDateFrom = new DateTime(2017, 2, 3),
                PageSize = 10,
                Page     = 1
            };

            A.CallTo(() => _repo.ListPagedAsync(null, 0, 0, null, null))
            .WithAnyArguments()
            .Returns(Task.FromResult(new Query.Common.PagedList <ActivityEventLogDTO>()));
            //Act
            var resp = await appService.SearchActivityEventLogAll(request);

            //Assert
            Assert.NotNull(resp);
            A.CallTo(() => _repo.ListPagedAsync(null, 0, 0, null, null))
            .WithAnyArguments()
            .MustHaveHappened(Repeated.NoMoreThan.Once);
        }
        public Task <ResponseDTO <PagedList <ActivityEventLogDTO> > > SearchActivityEventLogAll([FromUri] ActivityEventLogSearchRequest search)
        {
            var resp = _activityEventLogApplicationService.SearchActivityEventLogAll(search);

            return(resp);
        }
Example #5
0
        public async Task <ResponseDTO <PagedList <ActivityEventLogDTO> > > SearchActivityEventLogAll(ActivityEventLogSearchRequest search)
        {
            List <OrderExpression <ActivityEventLogDTO> > orderExpressionList = new List <OrderExpression <ActivityEventLogDTO> >();

            orderExpressionList.Add(new OrderExpression <ActivityEventLogDTO>(OrderType.Desc, p => p.ReportedActivityDate));

            var queryFilter = GetQueryFilter(search);
            var result      = await _activityEventLogDataAccess.ListPagedAsync(queryFilter, search.Page, search.PageSize, orderExpressionList.ToArray());

            var pagedResult = new PagedList <ActivityEventLogDTO>()
            {
                Items    = result.Items,
                PageSize = result.PageSize,
                Page     = result.Page,
                Total    = result.Total
            };

            return(ResponseBuilder.Correct(pagedResult));
        }
Example #6
0
        public async void GenerateDataCsvToReportExcel(Stream outputStream, HttpContent httpContent, TransportContext transportContext, ActivityEventLogSearchRequest search)
        {
            var list = await SearchActivityEventLogAll(search);

            try
            {
                if (list.Data.Items.Count > 0)
                {
                    using (var writer = new StreamWriter(outputStream))
                    {
                        var headers = new List <string> {
                            "Activity Name", "Driver Id", "Charge Number", "From Block", "To Block", "Equipment Number", "Product", "Reported Activity Date", "Result", "Details", "Location Provider"
                        };
                        await writer.WriteLineAsync(ExcelHelper.GetHeaderDetail(headers));

                        foreach (var item in list.Data.Items)
                        {
                            await writer.WriteLineAsync(GetRowDetail(item));
                        }
                    }
                }
            }
            catch (HttpException ex)
            {
                return;
            }
            finally
            {
                outputStream.Close();
            }
        }