public async Task <ActionResult> SummaryByMaster(string token, int projectId)
{
var project = await ProjectRepository.GetProjectWithFinances(projectId);
var guid = new Guid(token.FromHexString());
var acl = project.ProjectAcls.SingleOrDefault(a => a.Token == guid);
if (acl == null)
{
return(Content("Unauthorized"));
}
var masterOperations = project.FinanceOperations.ToArray();
var masterTransfers = await FinanceReportRepository.GetAllMoneyTransfers(projectId);
var summary =
MasterBalanceBuilder.ToMasterBalanceViewModels(masterOperations, masterTransfers, projectId);
var generator = ExportDataService.GetGenerator(ExportType.Csv, summary,
new MoneySummaryByMasterExporter(UriService));
return(await ReturnExportResult(project.ProjectName + ": " + "money-summary", generator));
}
protected Task <FileContentResult> Export <T>(IEnumerable <T> select, string fileName, ExportType exportType = ExportType.Csv)
{
ExportDataService.BindDisplay <User>(user => user?.GetDisplayName());
var generator = ExportDataService.GetGenerator(exportType, select);
return(ReturnExportResult(fileName, generator));
}
public AccountManagementController(ICacheClient cache,
IServerSettings serverSettings,
IAccountDao accountDao,
IAccountNoteService accountNoteService,
ICreditCardDao creditCardDao,
ICommandBus commandBus,
IOrderDao orderDao,
IPromotionDao promoDao,
IPaymentService paymentService,
INotificationService notificationService,
BookingSettingsService bookingSettingsService,
ConfirmAccountService confirmAccountService,
ExportDataService exportDataService)
: base(cache, serverSettings)
{
_accountDao = accountDao;
_accountNoteService = accountNoteService;
_creditCardDao = creditCardDao;
_bookingSettingsService = bookingSettingsService;
_commandBus = commandBus;
_serverSettings = serverSettings;
_orderDao = orderDao;
_promoDao = promoDao;
_confirmAccountService = confirmAccountService;
_exportDataService = exportDataService;
_paymentService = paymentService;
_notificationService = notificationService;
_resources = new Resources(serverSettings);
}
public ImportDataService()
{
_exportDataService = new ExportDataService();
_crmRepository = new CRMRepository();
_eventRepository = new EventRepository();
_configurationRespository = new ConfigurationRepository();
_hostedControlRepository = new HostedControlRepository();
_entityTypeRepository = new EntityTypeRepository();
_scriptletRepository = new ScriptletRepository();
_importResults = new List <ImportResult>();
_entitySearchRepository = new EntitySearchRepository();
_sessionLineRepository = new SessionLineRepository();
_optionRepository = new OptionRepository();
_actionRepository = new ActionRepository();
_actionCallrepository = new ActionCallRepository();
_subActionCallsRepository = new SubActionCallsRepository();
_eventActionCallRepository = new EventActionCallRepository();
_toolbarRepository = new ToolbarRepository();
_toolbarButtonRepository = new ToolbarButtonRepository();
_toolbarButtonActionCallRepository = new ToolbarButtonActionCallRepository();
_toolbarHostedControlRepository = new ToolbarHostedControlRepository();
_wnrRepository = new WNRRepository();
_wnrActionCallrepository = new WNRActionCallRepository();
_agentScriptTaskRepository = new AgentScriptTaskRepository();
_taskActionCallRepository = new TaskActionCallRepository();
_taskAnswerRepository = new TaskAnswerRepository();
_agentScriptAnswerRepository = new AgentScriptAnswerRepository();
_answerActionCallRepository = new AnswerActionCallrepository();
}
private async Task <ActionResult> GetFinanceOperationsList(int projectid, string export, Func <FinanceOperation, bool> predicate)
{
var project = await ProjectRepository.GetProjectWithFinances(projectid);
var viewModel = new FinOperationListViewModel(project, UriService,
project.FinanceOperations.Where(predicate).ToArray());
var exportType = ExportTypeNameParserHelper.ToExportType(export);
if (exportType == null)
{
return(View("Operations", viewModel));
}
else
{
var frontend = new FinanceOperationExporter(project, UriService);
var generator = ExportDataService.GetGenerator(exportType.Value, viewModel.Items, frontend);
var fileName = project.ProjectName + ": Финансы";
return(File(await generator.Generate(), generator.ContentType,
Path.ChangeExtension(fileName.ToSafeFileName(), generator.FileExtension)));
}
}
public void StartExporter()
{
var svc = new ExportDataService <Task>();
Assert.DoesNotThrow(() => svc.Start(null));
Assert.DoesNotThrow(() => svc.ForceWait());
}
protected Task <FileContentResult> ExportWithCustomFronend <T>(IEnumerable <T> viewModel, string title,
ExportType exportType, IGeneratorFrontend frontend, string projectName)
{
var generator = ExportDataService.GetGenerator(exportType, viewModel,
frontend);
return(ReturnExportResult(projectName + ": " + title, generator));
}
public BaseGameController(
ApplicationService applicationService,
ImportDataService importDataService,
ExportDataService exportDataService)
{
_applicationService = applicationService ?? throw new ArgumentNullException(nameof(applicationService));
_importDataService = importDataService ?? throw new ArgumentNullException(nameof(importDataService));
_exportDataService = exportDataService ?? throw new ArgumentNullException(nameof(exportDataService));
}
public void SetSourceParamsNullAndStartExporter()
{
var svc = new ExportDataService <Task>();
Assert.DoesNotThrow(() => svc.PassSourceParams(null));
Assert.DoesNotThrow(() => svc.Start(null));
Assert.DoesNotThrow(() => svc.ForceWait());
Assert.DoesNotThrow(() => svc.Stop(null));
}
public void ExportDataService_Run()
{
var service = new ExportDataService <string, URIAdress>(loader, writer, converter);
service.Run();
Mock.Get(loader).Verify(loader => loader.Load(), Times.AtLeastOnce());
//Mock.Get(converter).Verify(converter => converter.Convert(uriStrings), Times.AtLeastOnce());
//Mock.Get(writer).Verify(writer => writer.Write(uriAdresses), Times.AtLeastOnce());
}
public void SetSourceParamsAndStartExporter()
{
var svc = new ExportDataService <Task>();
Assert.DoesNotThrow(() => svc.PassSourceParams(new List <TypedParameter>
{
new TypedParameter(typeof(int), 5)
}));
Assert.DoesNotThrow(() => svc.Start(null));
Assert.DoesNotThrow(() => svc.ForceWait());
Assert.DoesNotThrow(() => svc.Stop(null));
}
private async Task <FileContentResult> ExportWithCustomFrontend(
IEnumerable <ClaimListItemViewModel> viewModel, string title,
ExportType exportType, IGeneratorFrontend <ClaimListItemViewModel> frontend, string projectName)
{
var generator = ExportDataService.GetGenerator(exportType, viewModel,
frontend);
var fileName = projectName + ": " + title;
return(File(await generator.Generate(), generator.ContentType,
Path.ChangeExtension(fileName.ToSafeFileName(), generator.FileExtension)));
}
private async Task MigrateAsync()
{
string currentAppDirectory = AppDomain.CurrentDomain.BaseDirectory;
string jobFolderName = GetJobFolderName();
string jobFolderPath = Path.Combine(currentAppDirectory, jobFolderName);
string xmlDataPath = Path.Combine(jobFolderPath, "data.xml");
string logFilePath = Path.Combine(jobFolderPath, "Logs");
MigrationStatusMessage = "Migration in process...";
string migrationError = null;
await Task.Factory.StartNew(() =>
{
try
{
ExportDataService exportDataService = new ExportDataService();
CreateFolderIfNotExists(jobFolderPath);
CrmServiceClient sourceCrmService = GetCrmService(SelectedSourceConnection);
exportDataService.ExportData(sourceCrmService, SelectedConfiguration.Name, jobFolderPath);
CrmServiceClient targetCrmService = GetCrmService(SelectedTargetConnection);
ImportDataService importDataService = new ImportDataService();
CreateFolderIfNotExists(logFilePath);
importDataService.ImportData(targetCrmService, xmlDataPath, logFilePath, null);
}
catch (Exception ex)
{
migrationError = ex.Message;
}
});
if (!string.IsNullOrWhiteSpace(migrationError))
{
MigrationStatusMessage = "Migration failed. Error:- " + migrationError;
}
else
{
MigrationStatusMessage = "Migration complete! Please review the Logs for any errors encountered.";
Process.Start(jobFolderPath);
}
}
//[TestMethod]
public void TestExportData()
{
//Arrange
string connectionStr = ConfigurationManager.ConnectionStrings["CRMSource"].ConnectionString;
CrmServiceClient crmServiceClient = new CrmServiceClient(connectionStr);
string configurationToExport = ConfigurationManager.AppSettings["ConfigurationToExport"];
string exportConfigDataPath = ConfigurationManager.AppSettings["ExportDataFilePath"];
ExportDataService exportDataService = new ExportDataService();
//Act
exportDataService.ExportData(crmServiceClient, configurationToExport, exportConfigDataPath);
//Assert
// Assert.IsTrue(true);
}
//[TestMethod]
public void ShouldFilter_CustomExport_ASIN()
{
//Arrange
ExportDataService service = new ExportDataService(null, null);
ExportProduct param = new ExportProduct();
param.HasASIN = true;
param.IsAllProductItems = true;
//Act
var result = service.CustomExportProducts(param).ToList();
//Assert
Debug.WriteLine(result.Count);
// Assert.IsTrue(result.Count > 0, "No Items Found.");
}
private async Task <ActionResult> GetFinanceOperationsList(int projectid, string export, Func <FinanceOperation, bool> predicate)
{
var project = await ProjectRepository.GetProjectWithFinances(projectid);
var viewModel = new FinOperationListViewModel(project, UriService,
project.FinanceOperations.Where(predicate).ToArray());
var exportType = GetExportTypeByName(export);
if (exportType == null)
{
return(View("Operations", viewModel));
}
else
{
ExportDataService.BindDisplay <User>(user => user?.GetDisplayName());
var generator = ExportDataService.GetGenerator(exportType.Value, viewModel.Items);
return(File(
await generator.Generate(),
generator.ContentType,
Path.ChangeExtension("finance-export", generator.FileExtension)
));
}
}
public ExportDataController()
{
_service = new ExportDataService(unitOfWork);
_membersService = new CcgMembersService(unitOfWork);
_contactRecordsService = new ContactRecordsService(unitOfWork);
}
