public ActionResult Index(ResultArchiveUploadListModelFilter filter, int pageNumber = 1)
{
var model = new ResultArchiveUploadListModel();
try
{
int totalRecords;
var resultArchives = _resultArchiveUploadRepository.GetByFilter(filter, pageNumber, _pageSize, out totalRecords);
if (resultArchives != null && resultArchives.Count() > 0)
{
var fileIds = resultArchives.Where(r => r.FileId.HasValue).Select(r => r.FileId.Value).ToArray();
var files = _fileRepository.GetByIds(fileIds);
var events = _eventRepository.GetEventswithPodbyIds(resultArchives.Select(r => r.EventId).ToArray());
var orgRoleUserIds = resultArchives.Select(r => r.UploadedByOrgRoleUserId).ToArray();
var userIdNamePairs = _organizationRoleUserRepository.GetNameIdPairofUsers(orgRoleUserIds);
var pods = _podRepository.GetPodsForEvents(events.Select(e => e.Id).ToArray());
model.ResultUploads = AutoMapper.Mapper.Map <IEnumerable <ResultArchive>, IEnumerable <ResultArchiveUploadViewModel> >(resultArchives);
foreach (var upload in model.ResultUploads)
{
var theEvent = events.Where(e => e.Id == upload.EventId).SingleOrDefault();
var eventPods = pods.Where(p => theEvent.PodIds.Contains(p.Id)).ToArray();
upload.EventDate = theEvent.EventDate;
upload.EventName = theEvent.Name;
upload.PodName = string.Join(", ", eventPods.Select(ep => ep.Name));
var userIdNamepair =
userIdNamePairs.Where(p => p.FirstValue == resultArchives.Where(r => r.Id == upload.Id).Select(r => r.UploadedByOrgRoleUserId).SingleOrDefault()).SingleOrDefault();
if (userIdNamepair != null)
{
upload.UploadedBy = userIdNamepair.SecondValue;
}
if (upload.File == null)
{
continue;
}
var file = files.Where(f => f.Id == upload.File.Id).SingleOrDefault();
if (file != null)
{
upload.File = file;
}
}
}
if (filter == null)
{
filter = new ResultArchiveUploadListModelFilter();
}
model.Filter = filter;
var currentAction = ControllerContext.RouteData.Values["action"].ToString();
Func <int, string> urlFunc =
pn =>
Url.Action(currentAction,
new
{
pageNumber = pn,
filter.EventId,
filter.FromEventDate,
filter.FromUploadDate,
filter.ToEventDate,
filter.ToUploadDate,
filter.ResultArchiveUploadStatus,
filter.UploadedBy,
filter.Pod
});
model.PagingModel = new PagingModel(pageNumber, _pageSize, totalRecords, urlFunc);
return(View(model));
}
catch (Exception)
{
return(View(model));
}
}
public void ArchivethePreviousFiles()
{
if (_settings.ResultArchiveWaitDays < 1)
{
return;
}
var dateForMovingtoArchives = DateTime.Now.Date.AddDays(-1 * _settings.ResultArchiveWaitDays);
var filter = new ResultArchiveUploadListModelFilter
{
ToUploadDate = dateForMovingtoArchives,
IsArchived = true
};
_logger.Info(
"\n\n ****************************************** Result Archive ****************************************");
_logger.Info("\nBatch Started -------------------------------------------------------------------\n");
while (true)
{
int totalRecords = 0;
var records = _resultArchiveUploadRepository.GetByFilter(filter, 1, 100, out totalRecords);
if (records == null || records.Count() < 1)
{
break;
}
foreach (ResultArchive resultArchive in records)
{
if (!resultArchive.FileId.HasValue)
{
continue;
}
var file = _fileRepository.GetById(resultArchive.FileId.Value);
var mediaLocation = _mediaRepository.GetResultArchiveMediaFileLocation(resultArchive.EventId);
try
{
var folder = _settings.ResultArchiveSharedDrivePath + resultArchive.EventId + @"\";
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
if (System.IO.File.Exists(mediaLocation.PhysicalPath + file.Path))
{
_logger.Info("\nMoving File For Event [" + resultArchive.EventId + "] [" + mediaLocation.PhysicalPath + file.Path + "].\n");
var destinationFilePath = folder + file.Path;
if (System.IO.File.Exists(destinationFilePath))
{
System.IO.File.Delete(destinationFilePath);
}
System.IO.File.Move(mediaLocation.PhysicalPath + file.Path, destinationFilePath);
//Removes inherited source directory permission and sets destination directory permission
var fs = System.IO.File.GetAccessControl(destinationFilePath);
fs.SetAccessRuleProtection(false, false);
System.IO.File.SetAccessControl(destinationFilePath, fs);
if (System.IO.File.Exists(mediaLocation.PhysicalPath + file.Path))
{
System.IO.File.Delete(mediaLocation.PhysicalPath + file.Path);
}
}
else
{
_logger.Info("\nFile Not Found For Event [" + resultArchive.EventId + "] [" + mediaLocation.PhysicalPath + file.Path + "]\n");
}
var files = Directory.GetFiles(mediaLocation.PhysicalPath, "*.zip");
if (files.Count() < 1)
{
Directory.Delete(mediaLocation.PhysicalPath, true);
}
((IFileRepository)_fileRepository).MarkasArchived(file.Id);
}
catch (Exception ex)
{
_logger.Error("\nResult Archive Id = " + resultArchive.Id + ". Path : [" + mediaLocation.PhysicalPath + file.Path + "]. \nMessage: " + ex.Message + "\n\tStack trace:" + ex.StackTrace);
}
}
}
_logger.Info("\nBatch Completed -------------------------------------------------------------------\n");
}
public IEnumerable <ResultArchive> GetByFilter(ResultArchiveUploadListModelFilter filter, int pageNumber, int pageSize, out int totalRecords)
{
using (var adapter = PersistenceLayer.GetDataAccessAdapter())
{
var linqMetaData = new LinqMetaData(adapter);
IEnumerable <ResultArchiveUploadEntity> entities = null;
if (filter == null)
{
totalRecords = linqMetaData.ResultArchiveUpload.Count();
entities =
linqMetaData.ResultArchiveUpload.OrderByDescending(ul => ul.ResultArchiveUploadId).TakePage(
pageNumber, pageSize).ToArray();
}
else
{
if (filter.EventId > 0)
{
var query = linqMetaData.ResultArchiveUpload.Where(ul => ul.EventId == filter.EventId);
totalRecords = query.Count();
entities = query.OrderByDescending(ul => ul.ResultArchiveUploadId).TakePage(pageNumber, pageSize).ToArray();
}
else
{
var query = from ul in linqMetaData.ResultArchiveUpload select ul;
if (filter.FromUploadDate.HasValue || filter.ToUploadDate.HasValue || filter.UploadedBy > 0 || filter.ResultArchiveUploadStatus > 0)
{
var fromDate = filter.FromUploadDate.HasValue ? filter.FromUploadDate.Value.Date : DateTime.Now;
var toDate = filter.ToUploadDate.HasValue ? filter.ToUploadDate.Value.AddDays(1).Date : DateTime.Now;
query = from ul in linqMetaData.ResultArchiveUpload
where (filter.FromUploadDate != null ? ul.UploadStartTime >= fromDate : true) &&
(filter.ToUploadDate != null ? ul.UploadStartTime < toDate : true) &&
(filter.UploadedBy > 0 ? ul.UploadedByOrgRoleUserId == filter.UploadedBy : true) &&
(filter.ResultArchiveUploadStatus > 0 ? ul.Status == filter.ResultArchiveUploadStatus : true)
select ul;
}
if (filter.FromEventDate.HasValue || filter.ToEventDate.HasValue)
{
var fromDate = filter.FromEventDate.HasValue ? filter.FromEventDate.Value.Date : DateTime.Now;
var toDate = filter.ToEventDate.HasValue ? filter.ToEventDate.Value.AddDays(1).Date : DateTime.Now;
query = from ul in query
join e in linqMetaData.Events on ul.EventId equals e.EventId
where (filter.FromEventDate.HasValue ? e.EventDate >= fromDate : true) &&
(filter.ToEventDate.HasValue ? e.EventDate < toDate : true)
select ul;
}
if (filter.IsArchived.HasValue && filter.IsArchived.Value)
{
query = from ul in query join f in linqMetaData.File on ul.FileId equals f.FileId where !f.IsArchived select ul;
}
if (!string.IsNullOrEmpty(filter.Pod))
{
query = from ul in query
join ep in linqMetaData.EventPod on ul.EventId equals ep.EventId
join p in linqMetaData.PodDetails on ep.PodId equals p.PodId
where ep.IsActive && p.Name.Contains(filter.Pod)
select ul;
}
totalRecords = query.Count();
entities = query.OrderByDescending(ul => ul.ResultArchiveUploadId).TakePage(pageNumber, pageSize).ToArray();
}
}
return(AutoMapper.Mapper.Map <IEnumerable <ResultArchiveUploadEntity>, IEnumerable <ResultArchive> >(entities));
}
}
