public string CustomerScheduleExport(CustomerScheduleModelFilter filter, long userId)
{
var fileName = GetExportableFileName("CustomerSchedule");
var csvFilePath = Path.Combine(ExportableMediaLocation.PhysicalPath, fileName);
var dataGen = new ExportableDataGenerator <EventCustomerScheduleModel, CustomerScheduleModelFilter>(_eventCustomerReportingService.GetCustomerScheduleModel, Logger);
var model = dataGen.GetData(filter);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <CustomerScheduleModel>();
var csvStringBuilder = _customerScheduleCsvHelper.GetPatientScheduledReport(model.Collection, exporter);
var request = new GenericReportRequest {
CsvFilePath = csvFilePath, Model = csvStringBuilder.ToString()
};
var isGenerated = _baseReportService.GetResponse(request);
if (!isGenerated)
{
return("CSV File Export failed!");
}
return(_baseReportService.DownloadZipFile(ExportableMediaLocation, fileName, userId, Logger));
}
private void UpdateEligibilityUploadDetail(EligibilityUpload eligibilityUploadDomain, List <EligibilityUploadLogViewModel> failedRecordsList, string fileName)
{
if (failedRecordsList.Any())
{
try
{
var location = _mediaRepository.GetEligibilityUploadMediaFileLocation();
var failedFilePath = location.PhysicalPath + Path.GetFileNameWithoutExtension(fileName) + "_Failed.csv";
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <EligibilityUploadLogViewModel>();
WriteCsv(failedFilePath, exporter, failedRecordsList);
var failedRecords = new FileInfo(failedFilePath);
var file = new File
{
Path = failedRecords.Name,
FileSize = failedRecords.Length,
Type = FileType.Csv,
UploadedBy = new OrganizationRoleUser(1),
UploadedOn = DateTime.Now
};
file = _fileRepository.Save(file);
eligibilityUploadDomain.FailedUploadCount = failedRecordsList.Count();
eligibilityUploadDomain.LogFileId = file.Id;
}
catch (Exception ex)
{
_logger.Error("Exception Raised while creating failed records CSV\n message: " + ex.Message + " stacktrace: " + ex.StackTrace);
}
}
_eligibilityUploadRepository.Save(eligibilityUploadDomain);
}
private bool GenerateReport(string destinationFolder, string fileName, GiftCertificateReportFilter filter)
{
var completePath = Path.Combine(destinationFolder, fileName);
var dataGen = new ExportableDataGenerator <GiftCertificateReportOptumViewModel, GiftCertificateReportFilter>(_giftCerificateOptumReportService.GetGiftCertificateOptumReport, _logger);
var model = dataGen.GetData(filter);
if (model != null && !model.Collection.IsNullOrEmpty())
{
_logger.Info("Writing Gift Certificate Report");
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <GiftCertificateReportOptumViewModel>();
_logger.Info("Record count" + model.Collection.Count());
DirectoryOperationsHelper.CreateDirectoryIfNotExist(destinationFolder);
DirectoryOperationsHelper.DeleteFileIfExist(completePath);
_baseExportableReportHelper.GenerateCsv(completePath, exporter, model.Collection);
_logger.Info("completed Gift Certificate Report for account tag " + filter.Tag);
_logger.Info("Destination Path: " + completePath);
return(true);
}
return(false);
}
private long GenerateFailedCustomerLogFile(IEnumerable <MergeCustomerUploadLog> failedCustomerList, string fileName)
{
try
{
var location = _mediaRepository.GetMergeCustomerUploadMediaFileLocation();
var failedFilePath = location.PhysicalPath + Path.GetFileNameWithoutExtension(fileName) + "_FailedCustomer.csv";
var modelData = Mapper.Map <IEnumerable <MergeCustomerUploadLog>, IEnumerable <MergeCustomerUploadLogViewModel> >(failedCustomerList);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <MergeCustomerUploadLogViewModel>();
WriteCsv(failedFilePath, exporter, modelData);
var failedRecords = new FileInfo(failedFilePath);
var file = new File
{
Path = failedRecords.Name,
FileSize = failedRecords.Length,
Type = FileType.Csv,
UploadedBy = new OrganizationRoleUser(1),
UploadedOn = DateTime.Now
};
file = _fileRepository.Save(file);
return(file.Id);
}
catch (Exception ex)
{
_logger.Error("Error while creating failed customers log file \n message: " + ex.Message + " stacktrace: " + ex.StackTrace);
}
return(0);
}
public string ExcludedCusomerReportExport(OutboundCallQueueFilter filter, long userId)
{
var dataGen = new ExportableDataGenerator <GmsExcludedCustomerViewModel, OutboundCallQueueFilter>(_excludedCustomerService.GetExcludedCustomers, Logger);
var model = dataGen.GetData(filter);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <GmsExcludedCustomerViewModel>();
return(WriteCsv(GetExportableFileName("ExcludedCustomerReport"), exporter, model.Collection, userId));
}
public string CallSkippedReportExport(CallSkippedReportFilter filter, long userId)
{
var dataGen = new ExportableDataGenerator <CallSkippedReportViewModel, CallSkippedReportFilter>(_callSkippedReportService.GetCallSkippedReport, Logger);
var model = dataGen.GetData(filter);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <CallSkippedReportViewModel>();
return(WriteCsv(GetExportableFileName("CallSkippedReport"), exporter, model.Collection, userId));
}
public string EventArchiveStatsExport(EventArchiveStatsFilter filter, long userId)
{
var dataGen = new ExportableDataGenerator <EventArchiveStatsViewModel, EventArchiveStatsFilter>(_eventArchiveStatsService.GetEventArchiveStats, Logger);
var model = dataGen.GetData(filter);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <EventArchiveStatsViewModel>();
return(WriteCsv(GetExportableFileName("EventArchiveStats"), exporter, model.Collection, userId));
}
public string DisqualifiedTestReportExport(DisqualifiedTestReportFilter filter, long userId)
{
var dataGen = new ExportableDataGenerator <DisqualifiedTestReportViewModel, DisqualifiedTestReportFilter>(_eventCustomerQuestionAnswerServcie.GetDisqualifiedTestReport, Logger);
var model = dataGen.GetData(filter);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <DisqualifiedTestReportViewModel>();
return(WriteCsv(GetExportableFileName("DisqualifiedTestReport"), exporter, model.Collection, userId));
}
public string CustomerWithNoEventsInAreaReportExport(CustomerWithNoEventsInAreaReportModelFilter filter, long userId)
{
var dataGen = new ExportableDataGenerator <CustomerWithNoEventsInAreaReportModel, CustomerWithNoEventsInAreaReportModelFilter>(_callQueueService.GetCustomerWithNoEventsInArea, Logger);
var model = dataGen.GetData(filter);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <CustomerWithNoEventsInAreaReportModel>();
return(WriteCsv(GetExportableFileName("CustomerWithNoEventsInAreaReport"), exporter, model.Collection, userId));
}
public string PcpTrackingReportExport(PcpTrackingReportFilter pcpTrackingReportFilter, long userId)
{
var dataGen = new ExportableDataGenerator <PcpTrackingReportViewModel, PcpTrackingReportFilter>(_pcpTrackingReportService.GetPcpTrackingReport, Logger);
var model = dataGen.GetData(pcpTrackingReportFilter);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <PcpTrackingReportViewModel>();
return(WriteCsv(GetExportableFileName("PcpTrackingReport"), exporter, model.Collection, userId));
}
public string TestBookedReportExport(TestsBookedListModelFilter filter, long userId)
{
var dataGen = new ExportableDataGenerator <TestsBookedModel, TestsBookedListModelFilter>(_eventCustomerReportingService.GetTestsBooked, Logger);
var model = dataGen.GetData(filter);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <TestsBookedModel>();
return(WriteCsv(GetExportableFileName("TestBookedReport"), exporter, model.Collection, userId));
}
private void MemberReportForCustomerNoTags(CorporateAccount account, DateTime dateFrom, DateTime dateTo, string directoryPath, IEnumerable <long> shippintOptionId)
{
var fileName = string.Format("MemberReport_{0}.csv", dateTo.ToString("yyyyMMdd"));
var tagToExlude = new List <string>();
if (!_bcbsMiGapPatinetTags.IsNullOrEmpty())
{
tagToExlude.AddRange(_bcbsMiGapPatinetTags);
}
if (!_bcbsMiRiskPatientTags.IsNullOrEmpty())
{
tagToExlude.AddRange(_bcbsMiRiskPatientTags);
}
var filter = new MemberResultMailedReportFilter
{
DateFrom = dateFrom,
DateTo = dateTo,
HealthPlanId = account.Id,
CustomTags = tagToExlude.ToArray(),
ExcludeCustomerWithCustomTag = true,
ShippingOptions = shippintOptionId,
Tag = account.Tag
};
_logger.Info("Generating MemberReport for " + account.Tag);
var dataGen = new ExportableDataGenerator <BcbsMiMemberResultMailedReportViewModel, MemberResultMailedReportFilter>(_bcbsMiMemberResultMailedReportService.GetBcbsMiMemberResultMailedReport, _logger);
var model = dataGen.GetData(filter);
if (model != null && !model.Collection.IsNullOrEmpty())
{
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <BcbsMiMemberResultMailedReportViewModel>();
_logger.Info("Record count" + model.Collection.Count());
if (File.Exists(directoryPath + fileName))
{
File.Delete(directoryPath + fileName);
}
_baseExportableReportHelper.GenerateCsv(directoryPath + fileName, exporter, model.Collection);
_logger.Info("Destination file " + directoryPath + fileName);
}
else
{
_logger.Info("No Record Found for Tag" + account.Tag);
}
_logger.Info("Completed MemberReport for " + account.Tag);
}
public string CallQueueCustomersReportExport(OutboundCallQueueFilter filter, long userId)
{
var dataGen = new ExportableDataGenerator <CallQueueCustomersReportModel, OutboundCallQueueFilter>(_callQueueCustomerReportService.GetCallQueueCustomers, Logger);
var model = dataGen.GetData(filter);
var listModel = model as CallQueueCustomersReportModelListModel;
listModel = listModel ?? new CallQueueCustomersReportModelListModel();
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <CallQueueCustomersReportModel>();
var fileName = "CallQueueCustomers_" + listModel.HealthPlanName + "_" + listModel.CallQueueName + (model.Filter.EventId > 0 ? "_" + listModel.Filter.EventId : "");
return(WriteCsv(GetExportableFileName(fileName), exporter, model.Collection, userId));
}
public void PollForDiabeticRetinopathyParserlog()
{
try
{
if (DateTime.Today.DayOfWeek != _dayOfWeek)
{
_logger.Info(string.Format("todays day : {0}, export set to run on {1}", DateTime.Today.DayOfWeek, _dayOfWeek));
return;
}
var fromDate = DateTime.Today.AddDays(-1 * _numberOfDays);
var toDate = DateTime.Today;
_logger.Info("Diabetic Retinopathy Parser Log Report Started");
var filter = new DiabeticRetinopathyParserlogListModelFilter
{
DateFrom = fromDate,
DateTo = toDate
};
_logger.Info(string.Format("Generating report for filter diabetic retinopathy parser log : DateFrom: {0}, DateTo {1} ", filter.DateFrom, filter.DateTo));
var dataGen = new ExportableDataGenerator <DiabeticRetinopathyParserlogViewModel, DiabeticRetinopathyParserlogListModelFilter>(_diabeticRetinopathyParserlogService.GetDiabeticRetinopathyParserlog, _logger);
var model = dataGen.GetData(filter);
if (model != null)
{
var fileName = GetCsvFileName(filter);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <DiabeticRetinopathyParserlogViewModel>();
if (model.Collection != null && model.Collection.Any())
{
_baseExportableReportHelper.GenerateCsv(fileName, exporter, model.Collection);
}
}
_logger.Info(string.Format("Report Generation Completed. "));
}
catch (Exception ex)
{
_logger.Error("Some Error Exception Occured while Generating Report");
_logger.Error("Message: " + ex.Message);
_logger.Error("StackTrace: " + ex.StackTrace);
_logger.Error(string.Format("Report Generation Completed "));
}
}
private void UpdateMedicationUploadDetail(MedicationUpload medicationUpload, IReadOnlyCollection <MedicationUploadLog> failedRecordsList, string fileName)
{
if (failedRecordsList.Any())
{
try
{
var location = _mediaRepository.GetMedicationUploadMediaFileLocation();
var failedFilePath = location.PhysicalPath + Path.GetFileNameWithoutExtension(fileName) + "_Failed.csv";
var modelData = Mapper.Map <IEnumerable <MedicationUploadLog>, IEnumerable <MedicationUploadLogViewModel> >(failedRecordsList);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <MedicationUploadLogViewModel>();
WriteCsv(failedFilePath, exporter, modelData);
var failedRecords = new FileInfo(failedFilePath);
var file = new File
{
Path = failedRecords.Name,
FileSize = failedRecords.Length,
Type = FileType.Csv,
UploadedBy = new OrganizationRoleUser(1),
UploadedOn = DateTime.Now
};
file = _fileRepository.Save(file);
medicationUpload.FailedUploadCount = failedRecordsList.Count();
medicationUpload.LogFileId = file.Id;
}
catch (Exception ex)
{
_logger.Error("Exception raised while creating failed customer records \n Message: " + ex.Message + "\n\tStack trace: " + ex.StackTrace);
}
}
try
{
_medicationUploadRepository.Save(medicationUpload);
}
catch (Exception ex)
{
_logger.Error("Exception raised while saving medicationUpload \n Message: " + ex.Message + "\n\tStack trace: " + ex.StackTrace);
}
}
private void GenerateTestNotPerformedCsvByFilter(TestNotPerformedListModelFilter filter, CorporateAccount healthPlan)
{
_logger.Info(string.Format("Generating Report for filter : EventDateFrom: {0}, EventDateTo {1}, HealthPlanId {2} ", filter.EventDateFrom, filter.EventDateTo, filter.HealthPlanId));
var dataGen = new ExportableDataGenerator <TestNotPerformedViewModel, TestNotPerformedListModelFilter>(_testNotPerformedService.GetTestNotPerformed, _logger);
var model = dataGen.GetData(filter);
if (model != null)
{
var fileName = GetCsvFileName(filter, healthPlan);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <TestNotPerformedViewModel>();
if (model.Collection != null && model.Collection.Any())
{
_baseExportableReportHelper.GenerateCsv(fileName, exporter, model.Collection);
}
}
}
public ActionResult UncontactedCustomersReportCompleted(string id, UncontactedCustomersReportListModel model)
{
if (id == null)
{
return(Content("Model can't be null."));
}
if (model == null || model.Collection == null || model.Collection.Count() < 1)
{
return(Content("Model can't be null."));
}
RemoveProcess(id);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <UncontactedCustomersReportModel>();
var message = WriteCsv(string.Format("UncontactedCustomersReport_{0}.csv", id), exporter, model.Collection, RequestSubcriberChannelNames.UncontactedCustomersReportQueue, RequestSubcriberChannelNames.UncontactedCustomersReportChannel);
return(Content(message));
}
public ActionResult ExcludedCustomersCompleted(string id, ExcludedCustomerListModel model)
{
if (id == null)
{
return(Content("Model can't be null."));
}
if (model == null || model.Collection == null || !model.Collection.Any())
{
return(Content("Model can't be null."));
}
RemoveProcess(id);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <GmsExcludedCustomerViewModel>();
var message = WriteCsv(string.Format("ExcludedCustomerReport{0}.csv", Guid.NewGuid()), exporter, model.Collection, RequestSubcriberChannelNames.ExcludedCustomerReportQueue, RequestSubcriberChannelNames.ExcludedCustomerReportChannel);
return(Content(message));
}
private void GenerateMemberStatusListCsvByFilter(MemberStatusListModelFilter filter, CorporateAccount account)
{
_logger.Info(string.Format("Generating Member Status Report for filter : Tag {0}", filter.Tag));
var dataGen = new ExportableDataGenerator <MemberStatusModel, MemberStatusListModelFilter>(_eventCustomerReportingService.GetMemberStatusReport, _logger);
var model = dataGen.GetData(filter);
if (model != null)
{
var fileName = GetCsvFileName(account);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <MemberStatusModel>();
if (model.Collection != null && model.Collection.Any())
{
_baseExportableReportHelper.GenerateCsv(fileName, exporter, model.Collection);
}
}
}
public ActionResult CdImageStatusCompleted(string id, CdImageStatusListModel model)
{
if (id == null)
{
return(Content("Model can't be null."));
}
if (model == null || model.Collection == null || model.Collection.Count() < 1)
{
return(Content("Model can't be null."));
}
RemoveProcess(id);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <CdImageStatusModel>();
var message = WriteCsv("CdImageStatus.csv", exporter, model.Collection, RequestSubcriberChannelNames.CdImageStatusQueue, RequestSubcriberChannelNames.CdImageStatusChannel);
return(Content(message));
}
public ActionResult StaffEventScheduleCompleted(string id, StaffEventSchedulingListModel model)
{
if (id == null)
{
return(Content("Model can't be null."));
}
if (model == null || model.Collection == null || !model.Collection.Any())
{
return(Content("Model can't be null."));
}
RemoveProcess(id);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <StaffEventSchedulingModel>();
var message = WriteCsv("StaffEventSchedule.csv", exporter, model.Collection, RequestSubcriberChannelNames.StaffEventAssignmentExportQueue, RequestSubcriberChannelNames.StaffEventAssignmentExportChannel);
return(Content(message));
}
private void ServiceReportForRiskCustomer(CorporateAccount account, DateTime dateFrom, DateTime dateTo, string directoryPath)
{
var fileName = string.Format("R_ServicesReport_{0}.csv", dateTo.ToString("yyyyMMdd"));
var filter = new CustomTestPerformedReportFilter
{
DateFrom = dateFrom,
DateTo = dateTo,
HealthPlanId = account.Id,
CustomTags = _bcbsMiRiskPatientTags,
ExcludeCustomerWithCustomTag = false,
Tag = account.Tag
};
_logger.Info("generating R-ServicesReport for " + account.Tag);
var dataGen = new ExportableDataGenerator <CustomTestPerformedViewModel, CustomTestPerformedReportFilter>(_customTestPerformedReportService.CustomTestPerformedReport, _logger);
var model = dataGen.GetData(filter);
if (model != null && !model.Collection.IsNullOrEmpty())
{
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <CustomTestPerformedViewModel>();
_logger.Info("Record count" + model.Collection.Count());
if (File.Exists(directoryPath + fileName))
{
File.Delete(directoryPath + fileName);
}
_baseExportableReportHelper.GenerateCsv(directoryPath + fileName, exporter, model.Collection);
_logger.Info("CSV Generated at " + directoryPath + fileName);
}
else
{
_logger.Info("No Record Found for Tag" + account.Tag);
}
_logger.Info("Completed R-ServicesReport for " + account.Tag);
}
private void PcpResultMailedReportForGapCustomer(CorporateAccount account, DateTime dateFrom, DateTime dateTo, string directoryPath)
{
var fileName = string.Format("Q_MOBILE_PCPReport_{0}.csv", dateTo.ToString("yyyyMMdd"));
var filter = new PcpResultMailedReportModelFilter
{
DateFrom = dateFrom,
DateTo = dateTo,
HealthPlanId = account.Id,
CustomTags = _bcbsMiGapPatinetTags,
ExcludeCustomerWithCustomTag = false,
Tag = account.Tag
};
_logger.Info("Generating Q_MOBILE_PCPReport for " + account.Tag);
var dataGen = new ExportableDataGenerator <BcbsMiPcpResultMailedReportModel, PcpResultMailedReportModelFilter>(_bcbsMipcpResultMailedReportService.GetBcbsMiPcpResultMailedResultReport, _logger);
var model = dataGen.GetData(filter);
if (model != null && !model.Collection.IsNullOrEmpty())
{
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <BcbsMiPcpResultMailedReportModel>();
_logger.Info("Record count" + model.Collection.Count());
if (File.Exists(directoryPath + fileName))
{
File.Delete(directoryPath + fileName);
}
_baseExportableReportHelper.GenerateCsv(directoryPath + fileName, exporter, model.Collection);
_logger.Info("Destination file " + directoryPath + fileName);
}
else
{
_logger.Info("No Record Found for Tag" + account.Tag);
}
_logger.Info("Completed Q_MOBILE_PCPReport for " + account.Tag);
}
public ActionResult AgentConversionReportCompleted(string id, AgentConversionReportListModel model)
{
if (id == null)
{
return(Content("Model can't be null."));
}
if (model == null || model.Collection.IsNullOrEmpty())
{
return(Content("Model can't be null."));
}
RemoveProcess(id);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <AgentConversionReportViewModel>();
var message = WriteCsv(string.Format("AgentConversionReport_{0}.csv", id), exporter, model.Collection, RequestSubcriberChannelNames.AgentConversionReportQueue, RequestSubcriberChannelNames.AgentConversionReportChannel);
return(Content(message));
}
public void PollForDailyVolumeReport()
{
try
{
_logger.Info("Setting filter to pull data for Daily Volume Report");
var filter = new DailyVolumeListModelFilter
{
FromDate = new DateTime(DateTime.Today.Year, 1, 1),
ToDate = new DateTime(DateTime.Today.Year, 12, 31)
};
_logger.Info("fetching Daily Volume Report");
var dataGen = new ExportableDataGenerator <DailyVolumeModel, DailyVolumeListModelFilter>(_eventReportingService.GetDailyVolumeReport, _logger);
var model = dataGen.GetData(filter);
if (model != null && !model.Collection.IsNullOrEmpty())
{
_logger.Info("Writing Daily volume Report");
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <DailyVolumeModel>();
_logger.Info("Record count" + model.Collection.Count());
var dailyVolumeReportPath = Path.Combine(_settings.DailyVolumeReportPath, DateTime.Today.Year.ToString());
DirectoryOperationsHelper.CreateDirectoryIfNotExist(dailyVolumeReportPath);
var reportName = "HF_DailyVolume_" + DateTime.Today.ToString("yyyyMMdd") + ".csv";
var reportfilePath = Path.Combine(dailyVolumeReportPath, reportName);
DirectoryOperationsHelper.DeleteFileIfExist(reportfilePath);
_baseExportableReportHelper.GenerateCsv(reportfilePath, exporter, model.Collection);
_logger.Info("Daily Volume Report File Posted " + reportfilePath);
}
}
catch (Exception exception)
{
_logger.Error("Some error occurred ");
_logger.Error("Message: " + exception.Message);
_logger.Error("Stack Trace: " + exception.StackTrace);
}
}
public ActionResult CallQueueCustomersCompleted(string id, CallQueueCustomersReportModelListModel model)
{
if (id == null)
{
return(Content("Model can't be null."));
}
if (model == null || model.Collection.IsNullOrEmpty())
{
return(Content("Model can't be null."));
}
RemoveProcess(id);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <CallQueueCustomersReportModel>();
var fileName = "CallQueueCustomers_" + model.HealthPlanName.Replace(" ", string.Empty) + "_" + model.CallQueueName.Replace(" ", string.Empty) + "_" + (model.Filter.EventId > 0 ? model.Filter.EventId + "_" : "") + id + ".csv";
var message = WriteCsv(fileName, exporter, model.Collection, RequestSubcriberChannelNames.CallQueueCustomersReportQueue, RequestSubcriberChannelNames.CallQueueCustomersReportChannel);
return(Content(message));
}
private void PcpSummaryLogReport(CorporateAccount account, DateTime dateFrom, DateTime dateTo, string directoryPath, string fileName)
{
var filter = new PcpSummaryLogReportModelFilter
{
DateFrom = dateFrom,
DateTo = dateTo,
HealthPlanId = account.Id,
Tag = account.Tag
};
_logger.Info("Generating Summary Log for " + account.Tag);
var dataGen = new ExportableDataGenerator <PcpSummaryLogReportModel, PcpSummaryLogReportModelFilter>(_pcpSummaryLogReportService.GetPcpSummaryLogReport, _logger);
var model = dataGen.GetData(filter);
if (model != null && !model.Collection.IsNullOrEmpty())
{
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <PcpSummaryLogReportModel>();
_logger.Info("Record count" + model.Collection.Count());
if (File.Exists(directoryPath + fileName) && !FirstReportGenerated)
{
File.Delete(directoryPath + fileName);
}
FirstReportGenerated = _baseExportableReportHelper.GenerateCsv(directoryPath + fileName, exporter, model.Collection, skipHeader: FirstReportGenerated);
_logger.Info("Destination file " + directoryPath + fileName);
}
else
{
_logger.Info("No Record Found for Tag" + account.Tag);
}
_logger.Info("Completed Summary Log for " + account.Tag);
}
private void UpdateStaffScheduleUploadDetail(StaffEventScheduleUpload staffEventScheduleUploadDomain, List <StaffEventScheduleUploadLogViewModel> failedRecordsList, string fileName,
IEnumerable <StaffEventScheduleUploadLog> staffEventScheduleUploadLogCollection)
{
if (failedRecordsList.Any())
{
try
{
var location = _mediaRepository.GetStaffScheduleUploadMediaFileLocation();
var failedFilePath = location.PhysicalPath + Path.GetFileNameWithoutExtension(fileName) + "_Failed.csv";
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <StaffEventScheduleUploadLogViewModel>();
WriteCsv(failedFilePath, exporter, failedRecordsList);
var failedRecords = new FileInfo(failedFilePath);
var file = new File
{
Path = failedRecords.Name,
FileSize = failedRecords.Length,
Type = FileType.Csv,
UploadedBy = new OrganizationRoleUser(1),
UploadedOn = DateTime.Now
};
file = _fileRepository.Save(file);
staffEventScheduleUploadDomain.FailedUploadCount = failedRecordsList.Count();
staffEventScheduleUploadDomain.LogFileId = file.Id;
if (!staffEventScheduleUploadLogCollection.IsNullOrEmpty())
{
staffEventScheduleUploadLogCollection.ForEach(x => x.UploadId = staffEventScheduleUploadDomain.Id);
_staffEventScheduleUploadLogRepository.Save(staffEventScheduleUploadLogCollection);
}
}
catch (Exception ex)
{
_logger.Error("Exception Raised while creating failed records CSV\n message: " + ex.Message + " stacktrace: " + ex.StackTrace);
}
}
_staffEventScheduleUploadRepository.Save(staffEventScheduleUploadDomain);
}
private void UpdateRapsUploadDetail(RapsUpload rapsUpload, List <RapsUploadLog> failedCustomerList, string fileName)
{
if (failedCustomerList.Any())
{
try
{
var location = _mediaRepository.GetRapsUploadMediaFileLocation();
var failedFilePath = location.PhysicalPath + Path.GetFileNameWithoutExtension(fileName) + "_FailedRaps.csv";
var modelData = Mapper.Map <IEnumerable <RapsUploadLog>, IEnumerable <RapsUploadLogViewModel> >(failedCustomerList);
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <RapsUploadLogViewModel>();
WriteCsv(failedFilePath, exporter, modelData);
var failedRecords = new FileInfo(failedFilePath);
var file = new File
{
Path = failedRecords.Name,
FileSize = failedRecords.Length,
Type = FileType.Csv,
UploadedBy = new OrganizationRoleUser(1),
UploadedOn = DateTime.Now
};
file = _fileRepository.Save(file);
rapsUpload.FailedUploadCount = failedCustomerList.Count();
rapsUpload.LogFileId = file.Id;
}
catch (Exception ex)
{
_logger.Error("exception Raised While Creating Failed Customer Records \n message: " + ex.Message + " stack trace: " + ex.StackTrace);
}
}
_rapsUploadRepository.Save(rapsUpload);
}
public void PollMailRoundCustomersReport()
{
try
{
_logger.Info("Entering Matrix Report Polling Agent");
var healthPlans = _corporateAccountRepository.GetAllHealthPlan();
var callQueues = _callQueueRepository.GetAll(false, true);
if (callQueues.IsNullOrEmpty())
{
_logger.Info("No call queue found.");
return;
}
var mailRoundCallQueue = callQueues.FirstOrDefault(x => x.Category == HealthPlanCallQueueCategory.MailRound);
var fillEventCallQueue = callQueues.FirstOrDefault(x => x.Category == HealthPlanCallQueueCategory.FillEventsHealthPlan);
var languageBarrierCallQueue = callQueues.FirstOrDefault(x => x.Category == HealthPlanCallQueueCategory.LanguageBarrier);
foreach (var healthPlan in healthPlans)
{
try
{
_logger.Info(string.Format("Generating Matrix Report for accountId {0} and account tag {1}. ", healthPlan.Id, healthPlan.Tag));
var destinationPath = _settings.MailRoundCustomersReportDestinantionPath;
var filePath = Path.Combine(destinationPath, string.Format(@"MatrixReport_{0}_{1}.csv", healthPlan.Tag, DateTime.Now.ToString("MMddyyyy")));
DirectoryOperationsHelper.CreateDirectory(destinationPath);
var customers = new List <MailRoundCustomersReportViewModel>();
_logger.Info("Fetching customers for fill event call queue");
var fillEventCustomers = GetCustomersForMatrixReport(healthPlan.Id, fillEventCallQueue);
if (!fillEventCustomers.IsNullOrEmpty())
{
customers.AddRange(fillEventCustomers);
}
else
{
_logger.Info("No customers found for fill event call queue");
}
_logger.Info("Fetching customers for mail round call queue");
var mailRoundCustomers = GetCustomersForMatrixReport(healthPlan.Id, mailRoundCallQueue);
if (!mailRoundCustomers.IsNullOrEmpty())
{
if (!customers.IsNullOrEmpty())
{
var existingCustomerIds = customers.Select(c => c.CustomerID);
mailRoundCustomers = mailRoundCustomers.Where(x => !existingCustomerIds.Contains(x.CustomerID)).ToList();
}
customers.AddRange(mailRoundCustomers);
}
else
{
_logger.Info("No customers found for mail round call queue");
}
_logger.Info("Fetching customers for language barrier call queue");
var languageBarrierCustomers = GetCustomersForMatrixReport(healthPlan.Id, languageBarrierCallQueue);
if (!languageBarrierCustomers.IsNullOrEmpty())
{
if (!customers.IsNullOrEmpty())
{
var existingCustomerIds = customers.Select(c => c.CustomerID);
languageBarrierCustomers = languageBarrierCustomers.Where(x => !existingCustomerIds.Contains(x.CustomerID)).ToList();
}
customers.AddRange(languageBarrierCustomers);
}
else
{
_logger.Info("No customers found for language barrier call queue");
}
if (customers.Any())
{
var exporter = ExportableDataGeneratorProcessManager <ViewModelBase, ModelFilterBase> .GetCsvExporter <MailRoundCustomersReportViewModel>();
DirectoryOperationsHelper.DeleteFileIfExist(filePath);
_baseExportableReportHelper.GenerateCsv(filePath, exporter, customers);
_logger.Error(string.Format("Successfully Matrix Report Generated for AccountId {0} and Account Tag {1}.", healthPlan.Id, healthPlan.Tag));
}
else
{
_logger.Error(string.Format("No records found for AccountId {0} and Account Tag {1}. \n\n", healthPlan.Id, healthPlan.Tag));
}
}
catch (Exception ex)
{
_logger.Error(string.Format("Error occured while generating Matrix Report for AccountId {0} and Account Tag {1} : \n Error {2} \n Trace: {3} ", healthPlan.Id, healthPlan.Tag, ex.Message, ex.StackTrace));
}
}
}
catch (Exception ex)
{
_logger.Error(string.Format("Error occured while generating Matrix Report : \n Error {0} \n Trace: {1} ", ex.Message, ex.StackTrace));
}
}
