public ActionResult MemberUploadDetails(MemberUploadDetailsListModelFilter filter = null, int pageNumber = 1)
        {
            try
            {
                int totalRecords;
                var model = _corporateUploadService.GetMemberUploadDetails(pageNumber, _pageSize, filter, out totalRecords) ?? new MemberUploadDetailsListModel();
                model.Filter = filter;

                var currentAction          = ControllerContext.RouteData.Values["action"].ToString();
                Func <int, string> urlFunc =
                    pn =>
                    Url.Action(currentAction,
                               new
                {
                    pageNumber = pn,
                    filter.FromUploadDate,
                    filter.ToUploadDate,
                    filter.SourceId
                });

                model.PagingModel = new PagingModel(pageNumber, _pageSize, totalRecords, urlFunc);
                return(View(model));
            }
            catch (Exception ex)
            {
                _logger.Error(string.Format(" Member Upload Details\nException occurred"));
                _logger.Error(string.Format("Exception message: {0}\n\tStackTrace:{1}", ex.Message, ex.StackTrace));

                var model = new MemberUploadDetailsListModel {
                    Filter = filter
                };
                return(View(model));
            }
        }
예제 #2
0
        public MemberUploadDetailsListModel GetMemberUploadDetails(int pageNumber, int pageSize, MemberUploadDetailsListModelFilter filter, out int totalRecords)
        {
            filter.SourceId = (long)MemberUploadSource.Aces;
            var corporateUploads = (IReadOnlyCollection <CorporateUpload>)_corporateUploadRepository.GetByFilter(pageNumber, pageSize, filter, out totalRecords);

            if (corporateUploads == null || !corporateUploads.Any())
            {
                return(null);
            }

            var successfileIds = corporateUploads.Select(s => s.FileId).ToArray();
            var failedfileIds  = corporateUploads.Where(x => x.LogFileId.HasValue).Select(s => s.LogFileId.Value).ToArray();
            var fileIds        = successfileIds.Concat(failedfileIds).ToArray();
            // var mediaLocation = filter.SourceId == (long)MemberUploadSource.Aces ? _mediaRepository.GetMemberUploadbyAcesFolderLocation() : _mediaRepository.GetUploadCsvMediaFileLocation();
            var mediaLocation = _mediaRepository.GetMemberUploadbyAcesFolderLocation();


            IEnumerable <FileModel> fileModels = null;

            if (fileIds != null && fileIds.Any())
            {
                var files = _fileRepository.GetByIds(fileIds);

                if (files != null && files.Any())
                {
                    fileModels = GetFileModelFromFile(files, mediaLocation);
                }
            }

            return(GetListModel(fileModels, corporateUploads));
        }
예제 #3
0
        public IEnumerable <CorporateUpload> GetByFilter(int pageNumber, int pageSize, MemberUploadDetailsListModelFilter filter, out int totalRecords)
        {
            using (var adapter = PersistenceLayer.GetDataAccessAdapter())
            {
                var linqMetaData = new LinqMetaData(adapter);

                if (filter == null)
                {
                    totalRecords = linqMetaData.CorporateUpload.Count();

                    var entities = linqMetaData.CorporateUpload.Where(x => x.SourceId == filter.SourceId).OrderByDescending(p => p.UploadTime).TakePage(pageNumber, pageSize).Select(x => x).ToArray();
                    return(Mapper.Map <IEnumerable <CorporateUploadEntity>, IEnumerable <CorporateUpload> >(entities));
                }
                else
                {
                    var query = (from c in linqMetaData.CorporateUpload where c.SourceId == filter.SourceId select c);

                    if (filter.FromUploadDate.HasValue)
                    {
                        query = (from c in query
                                 where c.UploadTime.Date >= filter.FromUploadDate.Value.Date
                                 select c);
                    }
                    if (filter.ToUploadDate.HasValue)
                    {
                        query = (from c in query
                                 where c.UploadTime.Date <= filter.ToUploadDate.Value.Date
                                 select c);
                    }

                    totalRecords = query.Count();
                    var entities = query.OrderByDescending(p => p.UploadTime).TakePage(pageNumber, pageSize).Select(x => x).ToArray();
                    return(Mapper.Map <IEnumerable <CorporateUploadEntity>, IEnumerable <CorporateUpload> >(entities));
                }
            }
        }