public TicketExportController(
TicketDataContext context,
IWorkflowService workflowService,
IAuthService authService,
TicketFundQuotasController fundQuotaController,
TicketPrivateFixedIncomeController privateFixedIncomeController,
TicketPublicFixedIncomeController publicFixedIncomeController,
TicketFuturesController futuresController,
TicketMarginController marginController,
TicketContractedController contractedController,
TicketCurrencyTermController ticketCurrencyTermController,
TicketSwapCetipController swapCetipController,
TicketVariableIncomeController variableIncomeController,
IExportService exportService
)
{
this.context = context;
this.workflowService = workflowService;
this.authService = authService;
this.ticketFundQuotaService = fundQuotaController;
this.privateFixedService = privateFixedIncomeController;
this.publicFixedIncomeService = publicFixedIncomeController;
this.futuresService = futuresController;
this.marginService = marginController;
this.contractedService = contractedController;
this.currencyTermService = ticketCurrencyTermController;
this.swapCetipService = swapCetipController;
this.variableIncomeService = variableIncomeController;
this.exportService = exportService;
}
public PrazoService(IPrazoRepositorio prazoRepositorio,
IExecutorService executorService,
ICategoriaDeProfissionalService categoriaDeProfissioalService,
IProfissionalService profissionalService,
ITituloCobrancaService tituloCobrancaService,
IProcessoRepositorio processoRepositorio,
IClienteService clienteService,
IPastaService pastaService,
IProcessoService processoService,
IExportService exportService,
IMapper mapper)
{
_prazoRepositorio = prazoRepositorio;
_executorService = executorService;
_categoriaDeProfissioalService = categoriaDeProfissioalService;
_profissionalService = profissionalService;
_tituloCobrancaService = tituloCobrancaService;
_processoRepositorio = processoRepositorio;
_clienteService = clienteService;
_pastaService = pastaService;
_processoService = processoService;
_exportService = exportService;
_mapper = mapper;
}
public WordListsViewModel(IProjectService projectService, IDialogService dialogService, IImportService importService,
IExportService exportService, IAnalysisService analysisService, WordListsVarietyViewModel.Factory varietyFactory)
: base("Word lists")
{
_projectService = projectService;
_dialogService = dialogService;
_importService = importService;
_exportService = exportService;
_analysisService = analysisService;
_varietyFactory = varietyFactory;
Messenger.Default.Register <SwitchViewMessage>(this, HandleSwitchView);
_projectService.ProjectOpened += _projectService_ProjectOpened;
_findCommand = new RelayCommand(Find);
TaskAreas.Add(new TaskAreaItemsViewModel("Common tasks",
new TaskAreaCommandViewModel("Add a new variety", new RelayCommand(AddNewVariety)),
new TaskAreaCommandViewModel("Add a new meaning", new RelayCommand(AddNewMeaning)),
new TaskAreaCommandViewModel("Find words", _findCommand),
new TaskAreaCommandViewModel("Import word lists", new RelayCommand(Import))));
TaskAreas.Add(new TaskAreaItemsViewModel("Other tasks",
new TaskAreaCommandViewModel("Export word lists", new RelayCommand(Export)),
new TaskAreaCommandViewModel("Remove affixes from all words", new RelayCommand(RunStemmer))));
_isEmpty = true;
}
public ExamsViewModel(
IExamService examService,
ICourseService courseService,
IEnrolmentService enrolmentService,
IStudentExamService studentExamService,
ISemesterService semesterService,
IExportService exportService,
IDownloadFileService downloadFileService)
{
_examService = examService;
_courseService = courseService;
_enrolmentService = enrolmentService;
_studentExamService = studentExamService;
_semesterService = semesterService;
_exportService = exportService;
_downloadFileService = downloadFileService;
_startExportCommand = new DelegateCommand(OnStartExport, CanStartExport);
_exportCommand = new DelegateCommand(OnExport, CanExport);
_addStudentsCommand = new DelegateCommand(OnAddStudents, CanAddStudents);
_addStudentsSaveCommand = new DelegateCommand(OnAddStudentsSave, CanAddStudentsSave);
_addStudentsDiscardCommand = new DelegateCommand(OnAddStudentsDiscard, CanAddStudentsDiscard);
_studentsCommand = new DelegateCommand(OnStudents, CanStudents);
_saveEditStudentsCommand = new DelegateCommand(OnSaveEditStudents, CanSaveEditStudents);
_deleteStudentsCommand = new DelegateCommand(OnDeleteStudents, CanDeleteStudents);
_saveAllStudentsCommand = new DelegateCommand(OnSaveAllStudents, CanSaveAllStudents);
}
private void Dispose(bool disposing)
{
if (_IsDisposed)
{
throw new ObjectDisposedException("ExportService");
}
try
{
_ExportService.Unsubscribe();
Channel.Close();
}
catch { }
finally
{
_ExportService = null;
}
_IsDisposed = true;
if (disposing)
{
GC.SuppressFinalize(this);
}
}
public ExportController(IHostingEnvironment hostingEnvironment, ApplicationDbContext context, ILogger <ExportController> logger, IExportService exportService)
{
_hostingEnvironment = hostingEnvironment;
_context = context;
_logger = logger;
_exportService = exportService;
}
public async void TestExport()
{
//Prepare
TestingContext testingContext = new TestingContext();
testingContext.AddAdminPrincipalMock();
testingContext.AddBinaryServiceMock();
testingContext.AddInMemoryDb();
testingContext.AddUserService();
testingContext.AddBusinessSecurityService();
testingContext.AddLogServiceMock();
testingContext.AddGermanCultureServiceMock();
testingContext.AddQuestionService();
IExportService exportService = testingContext.GetService <ExportService>();
//Act
Stream stream = await exportService.Export();
//Assert
ZipArchive arch = new ZipArchive(stream);
ZipArchiveEntry entry = arch.GetEntry("questions.json");
Stream zipEntryStream = entry.Open();
using (var reader = new StreamReader(zipEntryStream, Encoding.UTF8))
{
string value = reader.ReadToEnd();
IList <QuestionDto> questions = JsonConvert.DeserializeObject <IList <QuestionDto> >(value);
Assert.True(questions.Count > 0);
}
Assert.True(arch.Entries.Count > 0);
}
/// <summary>
/// Prints the current document
/// </summary>
/// <param name="type"></param>
public void PrintAction(object parameter, object view, object service = null) //PrintCommand
{
try
{
if (service is IExportService)
{
IExportService exportService = service as IExportService;
TableView tv = view as TableView;
Enum.TryParse(parameter.ToString(), out PrintType type);
switch (type)
{
case PrintType.PREVIEW:
exportService.ShowPrintPreview(tv);
break;
case PrintType.PRINT:
exportService.Print(tv);
break;
}
}
}
catch (Exception ex)
{
MessageBox.Show("Error printing data:" + ex.Message);
}
}
public SimilarityMatrixViewModel(IProjectService projectService, IExportService exportService, IAnalysisService analysisService)
: base("Similarity Matrix")
{
_projectService = projectService;
_exportService = exportService;
_analysisService = analysisService;
_modelVarieties = new List<Variety>();
_projectService.ProjectOpened += _projectService_ProjectOpened;
Messenger.Default.Register<DomainModelChangedMessage>(this, msg =>
{
if (msg.AffectsComparison)
ResetVarieties();
});
Messenger.Default.Register<PerformingComparisonMessage>(this, msg => ResetVarieties());
Messenger.Default.Register<ComparisonPerformedMessage>(this, msg => CreateSimilarityMatrix());
TaskAreas.Add(new TaskAreaCommandGroupViewModel("Similarity metric",
new TaskAreaCommandViewModel("Lexical", new RelayCommand(() => SimilarityMetric = SimilarityMetric.Lexical)),
new TaskAreaCommandViewModel("Phonetic", new RelayCommand(() => SimilarityMetric = SimilarityMetric.Phonetic))));
TaskAreas.Add(new TaskAreaItemsViewModel("Common tasks",
new TaskAreaCommandViewModel("Compare all variety pairs", new RelayCommand(PerformComparison))));
TaskAreas.Add(new TaskAreaItemsViewModel("Other tasks",
new TaskAreaCommandViewModel("Export this matrix", new RelayCommand(Export))));
}
private void ExportMultpleWorker_DoWork(object sender, DoWorkEventArgs e)
{
try
{
var inputSystemsRaw = File.ReadAllLines(openFilename).ToList();
ProcessInputFile(inputSystemsRaw);
//TODO: need to re-think how to do this...
//Worksheets will be unorganized with many systems (e.g. Disks / Services)
//Can't make worksheets by system b/c dataset is excel sheet creates worksheets based on tables in DataSet
//Maybe need to create new excel file for each system????
DataSet dsMultiple = new DataSet();
foreach (var item in checkedListBoxExport.CheckedItems)
{
var exportItem = item.ToString().ToEnum <ExportOptions>();
foreach (var system in systemsList)
{
InitializeConnection(system.Username, system.Password, system.Hostname);
_export = new ExportService(_sysConnector.Scope, _sysConnector.Options);
AddInfoToDataSet(dsMultiple, exportItem);
}
}
e.Result = dsMultiple;
}
catch (Exception ex)
{
throw ex;
}
}
public MainViewModel(IDataService dataService, IMessageGroupService messageGroupService,
IExportService exportService)
{
_dataService = dataService;
_messageGroupService = messageGroupService;
_exportService = exportService;
}
public CasoService(
IEnvolvimentoRepositorio envolvimentoRepositorio,
IProcessoRepositorio processoRepositorio,
IProcessoService processoService,
IProfissionalService profissionalService,
IClienteService clienteService,
IAreaService areaService,
IMapper mapper,
IPastaService pastaService,
IExportService exportService,
IAudienciaRepositorio compromissoAudienciaRepositorio,
IPrazoRepositorio prazoRepositorio
)
{
_compromissoAudienciaRepositorio = compromissoAudienciaRepositorio;
_envolvimentoRepositorio = envolvimentoRepositorio;
_processoRepositorio = processoRepositorio;
_processoService = processoService;
_mapper = mapper;
_areaService = areaService;
_clienteService = clienteService;
_profissionalService = profissionalService;
_pastaService = pastaService;
_exportService = exportService;
_prazoRepositorio = prazoRepositorio;
}
public Reconciler(
ISapphireRepository sapphireRepository,
ICompanyRepository companyRepository,
IPurchaseOrderHeaderRepository purchaseOrderHeaderRepository,
IQueueRepository queueRepository,
IServiceLog serviceLog,
IConsoleLogger consoleLogger,
IImportService importService,
IExportService exportService,
IJobCostActivityService jobCostActivityService,
IJobService jobService,
IVariancePurchaseOrderService variancePurchaseOrderService)
{
_sapphireRepository = sapphireRepository;
_companyRepository = companyRepository;
_purchaseOrderHeaderRepository = purchaseOrderHeaderRepository;
_queueRepository = queueRepository;
_serviceLog = serviceLog;
_consoleLogger = consoleLogger;
_importService = importService;
_exportService = exportService;
_jobCostActivityService = jobCostActivityService;
_jobService = jobService;
_variancePurchaseOrderService = variancePurchaseOrderService;
}
private static void ExportAllTestObfuscate(object sender, ExecutedRoutedEventArgs e)
{
BackgroundWorker worker = new BackgroundWorker();
SaveFileDialog dialog = new SaveFileDialog();
dialog.DefaultExt = ".sql";
dialog.Filter = "SQL Files (.sql)|*.sql";
bool?result = dialog.ShowDialog();
if (result == true)
{
MainWindow mainWindow = (MainWindow)sender;
mainWindow.loadingAnimation.Visibility = Visibility.Visible;
worker.DoWork += delegate(object s, DoWorkEventArgs args)
{
IExportService exportService = ObjectLocator.GetInstance <IExportService>();
string filePath = args.Argument as string;
exportService.ExportTestTables(UIContext.Database.Tables, filePath, UIContext.Database.ConnectionString);
};
worker.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs args)
{
mainWindow.loadingAnimation.Visibility = Visibility.Collapsed;
};
worker.RunWorkerAsync(dialog.FileName);
}
}
public WordListsViewModel(IProjectService projectService, IDialogService dialogService, IImportService importService,
IExportService exportService, IAnalysisService analysisService, WordListsVarietyViewModel.Factory varietyFactory)
: base("Word lists")
{
_projectService = projectService;
_dialogService = dialogService;
_importService = importService;
_exportService = exportService;
_analysisService = analysisService;
_varietyFactory = varietyFactory;
Messenger.Default.Register <SwitchViewMessage>(this, HandleSwitchView);
Messenger.Default.Register <DomainModelChangedMessage>(this, HandleDomainModelChanged);
_projectService.ProjectOpened += _projectService_ProjectOpened;
_findCommand = new RelayCommand(Find);
TaskAreas.Add(new TaskAreaItemsViewModel("Common tasks",
new TaskAreaCommandViewModel("Add a new variety", new RelayCommand(AddNewVariety)),
new TaskAreaCommandViewModel("Add a new meaning", new RelayCommand(AddNewMeaning)),
new TaskAreaCommandViewModel("Find words", _findCommand),
new TaskAreaCommandViewModel("Import word lists from file", new RelayCommand(ImportFromFile)),
new TaskAreaCommandViewModel("Import word lists from clipboard", new RelayCommand(ImportFromClipboard, CanImportFromClipboard))));
TaskAreas.Add(new TaskAreaItemsViewModel("Other tasks",
new TaskAreaCommandViewModel("Export word lists", new RelayCommand(Export, CanExport)),
new TaskAreaCommandViewModel("Remove affixes from words in all varieties", new RelayCommand(RunStemmer, CanRunStemmer))));
AddNewVarietyCommand = new RelayCommand(AddNewVariety);
AddNewMeaningCommand = new RelayCommand(AddNewMeaning);
ImportWordListsCommand = new RelayCommand(ImportFromFile);
ShowGettingStartedCommand = new RelayCommand(ShowGettingStarted);
_isEmpty = true;
}
public AudienciaService(IAudienciaRepositorio audienciaRepositorio,
IExecutorService executorService,
ICategoriaDeProfissionalService categoriaDeProfissioalService,
IProfissionalService profissionalService,
ITituloCobrancaService tituloCobrancaService,
IProcessoRepositorio processoRepositorio,
Domain.Interfaces.Services.InfraServices.IHierarquiaService hierarquiaService,
IClienteService clienteService,
IPastaService pastaService,
IProcessoService processoService,
IExportService exportService,
IMapper mapper)
{
_audienciaRepositorio = audienciaRepositorio;
_executorService = executorService;
_categoriaDeProfissioalService = categoriaDeProfissioalService;
_profissionalService = profissionalService;
_tituloCobrancaService = tituloCobrancaService;
_processoRepositorio = processoRepositorio;
_mapper = mapper;
_hierarquiaService = hierarquiaService;
_clienteService = clienteService;
_pastaService = pastaService;
_processoService = processoService;
_exportService = exportService;
}
public CalendarController(ICalendarService calendarService, IMapper mapper, IUserService userService, IExportService exportService)
{
_calendarService = calendarService;
_mapper = mapper;
_userService = userService;
_exportService = exportService;
}
public DataController(ISecurityService securityService,
IBinaryService binaryService,
IQuestionService questionService,
IVersionService versionService,
ITagService tagService,
ICourseService courseService,
ICommentsService commentsService,
IUserProfileService userProfileService,
ICourseInstanceService courseInstanceService,
ITextService textService,
IExportService exportService,
INotificationService notificationService,
IFavoriteService favoriteService)
{
_securityService = securityService;
_binaryService = binaryService;
_questionService = questionService;
_tagService = tagService;
_courseService = courseService;
_commentsService = commentsService;
_userProfileService = userProfileService;
_courseInstanceService = courseInstanceService;
_textService = textService;
_exportService = exportService;
_versionService = versionService;
_notificationService = notificationService;
_favoriteService = favoriteService;
}
public WordListsViewModel(IProjectService projectService, IDialogService dialogService, IImportService importService,
IExportService exportService, IAnalysisService analysisService, WordListsVarietyViewModel.Factory varietyFactory)
: base("Word lists")
{
_projectService = projectService;
_dialogService = dialogService;
_importService = importService;
_exportService = exportService;
_analysisService = analysisService;
_varietyFactory = varietyFactory;
Messenger.Default.Register<SwitchViewMessage>(this, HandleSwitchView);
Messenger.Default.Register<DomainModelChangedMessage>(this, HandleDomainModelChanged);
_projectService.ProjectOpened += _projectService_ProjectOpened;
_findCommand = new RelayCommand(Find);
TaskAreas.Add(new TaskAreaItemsViewModel("Common tasks",
new TaskAreaCommandViewModel("Add a new variety", new RelayCommand(AddNewVariety)),
new TaskAreaCommandViewModel("Add a new meaning", new RelayCommand(AddNewMeaning)),
new TaskAreaCommandViewModel("Find words", _findCommand),
new TaskAreaCommandViewModel("Import word lists", new RelayCommand(Import))));
TaskAreas.Add(new TaskAreaItemsViewModel("Other tasks",
new TaskAreaCommandViewModel("Export word lists", new RelayCommand(Export, CanExport)),
new TaskAreaCommandViewModel("Remove affixes from words in all varieties", new RelayCommand(RunStemmer, CanRunStemmer))));
_addNewVarietyCommand = new RelayCommand(AddNewVariety);
_addNewMeaningCommand = new RelayCommand(AddNewMeaning);
_importWordListsCommand = new RelayCommand(Import);
_showGettingStartedCommand = new RelayCommand(ShowGettingStarted);
_isEmpty = true;
}
/// <summary>
/// Core service
/// </summary>
/// <param name="exportService">Export service</param>
/// <param name="loggingService">Logging service</param>
/// <param name="fileService">The file service</param>
/// <param name="cachingService">The caching service</param>
public CoreService(IExportService exportService, ILoggingService loggingService, IFileService fileService, ICachingService cachingService)
{
_exportService = exportService;
_loggingService = loggingService;
_fileService = fileService;
_cachingService = cachingService;
}
public SimilarityMatrixViewModel(IProjectService projectService, IExportService exportService, IAnalysisService analysisService)
: base("Similarity Matrix")
{
_projectService = projectService;
_exportService = exportService;
_analysisService = analysisService;
_modelVarieties = new List <Variety>();
_projectService.ProjectOpened += _projectService_ProjectOpened;
Messenger.Default.Register <DomainModelChangedMessage>(this, msg =>
{
if (msg.AffectsComparison)
{
ResetVarieties();
}
});
Messenger.Default.Register <PerformingComparisonMessage>(this, msg => ResetVarieties());
Messenger.Default.Register <ComparisonPerformedMessage>(this, msg => CreateSimilarityMatrix());
TaskAreas.Add(new TaskAreaCommandGroupViewModel("Similarity metric",
new TaskAreaCommandViewModel("Lexical", new RelayCommand(() => SimilarityMetric = SimilarityMetric.Lexical)),
new TaskAreaCommandViewModel("Phonetic", new RelayCommand(() => SimilarityMetric = SimilarityMetric.Phonetic))));
TaskAreas.Add(new TaskAreaItemsViewModel("Common tasks",
new TaskAreaCommandViewModel("Compare all variety pairs", new RelayCommand(PerformComparison))));
TaskAreas.Add(new TaskAreaItemsViewModel("Other tasks",
new TaskAreaCommandViewModel("Export matrix", new RelayCommand(Export, CanExport))));
_performComparisonCommand = new RelayCommand(PerformComparison);
}
public HomeController(ISessionService sessionTest, IClienteRepositorio clienteRepositorio, IExportService casoRepositorio, IFuncionarioRepositorio funcionarioRepositorio)
{
_clienteRepositorio = clienteRepositorio;
_funcionarioRepositorio = funcionarioRepositorio;
_casoRepositorio = casoRepositorio;
_sessionTest = sessionTest;
}
private void PerformIOC()
{
IoCContainer.ResoloveDependencies();
_exportService = IoCContainer.Resolve <IExportService>();
_documentService = IoCContainer.Resolve <IDocumentService>();
_appManCoEmailService = IoCContainer.Resolve <IAppManCoEmailService>();
}
public PurchaseOrderService(ISapphireRepository sapphireRepository, IPurchaseOrderHeaderRepository purchaseOrderHeaderRepository, IServiceLog serviceLog, IExportService exportService, IDateService dateService)
{
_sapphireRepository = sapphireRepository;
_purchaseOrderHeaderRepository = purchaseOrderHeaderRepository;
_serviceLog = serviceLog;
_exportService = exportService;
_dateService = dateService;
}
public AccountsController(IAccountService accountService, IPasswordService passwordService, ILoggingService logger, IExportService exportService, IExceptionHandler exceptionHandler)
{
_accountService = accountService;
_passwordService = passwordService;
_exportService = exportService;
_logger = logger;
_exceptionHandler = exceptionHandler;
}
public IndexModel(IConfiguration config, ILookup lookup, IImportService importService, IExportService exportService)
{
_config = config;
_lookup = lookup;
_importService = importService;
_exportService = exportService;
Accounts = new List <Person>();
}
public ProjectViewModelTests()
{
_dialogService = MockRepository.GenerateMock <IDialogService>();
_projectService = MockRepository.GenerateMock <IProjectService>();
_statusService = MockRepository.GenerateMock <IStatusService>();
_windowManager = MockRepository.GenerateMock <IWindowManager>();
_viewModelFactory = MockRepository.GenerateMock <IViewModelFactory>();
_exportService = MockRepository.GenerateMock <IExportService>();
}
private static void PerformTask(Options options)
{
if (!String.IsNullOrEmpty(options.ProjectFile))
{
IDatabaseProjectService databaseProjectService = ObjectLocator.GetInstance <IDatabaseProjectService>();
IEventAggregator eventAggregator = ObjectLocator.GetInstance <IEventAggregator>();
Console.WriteLine(string.Format("Loading the Dafuscator project: {0}", options.ProjectFile));
Database db = databaseProjectService.GetDatabaseProject(options.ProjectFile);
ConnectionString connetionString;
if (!String.IsNullOrEmpty(options.ConnectionString))
{
connetionString = new ConnectionString(options.ConnectionString);
}
else
{
connetionString = db.ConnectionString;
}
db.ConnectionString = connetionString;
eventAggregator.AddListener <StatusUpdateEvent>(e => Console.WriteLine(string.Format("{0}: {1}", DateTime.Now, e.Message)));
if (!String.IsNullOrEmpty(options.ExportFile))
{
Console.WriteLine(string.Format("Started exporting the Dafuscator project to {0}", options.ExportFile));
IExportService exportService = ObjectLocator.GetInstance <IExportService>();
exportService.ExportTables(db.Tables, options.ExportFile, connetionString);
Console.WriteLine("Finished exporting the Dafuscator project.");
}
else
{
Console.WriteLine(string.Format("Started the obfuscation of the {0} database.", db.ConnectionString.DatabaseName));
IRunService runService = ObjectLocator.GetInstance <IRunService>();
IReportService reportService = ObjectLocator.GetInstance <IReportService>();
ObfuscationResult result = runService.ObfuscateDatabase(db);
string path = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
path = path + "\\Dafuscator";
if (Directory.Exists(path) == false)
{
Directory.CreateDirectory(path);
}
path = path +
string.Format("\\DatabaseObfuscationReport_{0}_{1}_{2}-{3}_{4}.txt", DateTime.Now.Month, DateTime.Now.Day,
DateTime.Now.Year, DateTime.Now.Hour, DateTime.Now.Minute);
reportService.GenerateReportForObfucsationResult(result, path);
Console.WriteLine("Finished the obfuscation process in {0}", result.TimeElapsed);
}
}
}
public AdminController(ApplicationUserManager userManager, IExportService exportService, IUserService userService, ISnippetService snippetService, IEventService eventService, IGroupService groupService)
{
_userManager = userManager;
_exportService = exportService;
_userService = userService;
_snippetService = snippetService;
_eventService = eventService;
_groupService = groupService;
}
public IndexModel(IConfiguration configuration, IExportService exportService, IWebHostEnvironment hostingEnvironment)
{
_configuration = configuration;
_exportService = exportService;
_hostingEnvironment = hostingEnvironment;
StartDate = new DateTime(DateTime.Today.AddMonths(-1).Year, DateTime.Today.AddMonths(-1).Month, 3, 00, 00, 00);
EndDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 2, 23, 59, 59);
}
public ProjectViewModelTests()
{
_dialogService = MockRepository.GenerateMock<IDialogService>();
_projectService = MockRepository.GenerateMock<IProjectService>();
_statusService = MockRepository.GenerateMock<IStatusService>();
_windowManager = MockRepository.GenerateMock<IWindowManager>();
_viewModelFactory = MockRepository.GenerateMock<IViewModelFactory>();
_exportService = MockRepository.GenerateMock<IExportService>();
}
public DocumentManagementService(List <MetadataItem> documentList, IMessageBoxService messageBoxService, IImportService importService, IExportService exportService, IFileService fileService, ISearchService searchService)
{
_documentList = documentList;
_messageBoxService = messageBoxService;
_importService = importService;
_exportService = exportService;
_fileService = fileService;
_searchService = searchService;
}
public Program(ILogger <Program> logger, IMovieService movieService, IExportService exportService /*, IScraperService scraperService*/)
{
_logger = logger;
_movieService = movieService;
_exportService = exportService;
//_scraperService = scraperService;
_logger.LogInformation("Constructed!");
}
public ProjectViewModel(
IProjectService projectService,
IDialogService dialogService,
IStatusService statusService,
IExportService exportService,
IViewModelFactory viewModelFactory,
IWindowManager windowManager)
{
_projectService = projectService;
_dialogService = dialogService;
_statusService = statusService;
_exportService = exportService;
_viewModelFactory = viewModelFactory;
_windowManager = windowManager;
}
public VarietyPairsViewModel(IProjectService projectService, IBusyService busyService, IDialogService dialogService, IExportService exportService, IAnalysisService analysisService,
VarietyPairViewModel.Factory varietyPairFactory)
: base("Variety Pairs")
{
_projectService = projectService;
_busyService = busyService;
_dialogService = dialogService;
_exportService = exportService;
_analysisService = analysisService;
_varietyPairFactory = varietyPairFactory;
_projectService.ProjectOpened += _projectService_ProjectOpened;
_sortPropertyName = "PhoneticSimilarityScore";
_sortDirection = ListSortDirection.Descending;
Messenger.Default.Register<PerformingComparisonMessage>(this, msg =>
{
if (msg.VarietyPair == null)
ClearComparison();
});
Messenger.Default.Register<ComparisonPerformedMessage>(this, msg =>
{
if (msg.VarietyPair == null)
SetSelectedVarietyPair();
});
Messenger.Default.Register<DomainModelChangedMessage>(this, msg =>
{
if (msg.AffectsComparison)
ClearComparison();
});
Messenger.Default.Register<SwitchViewMessage>(this, HandleSwitchView);
_findCommand = new RelayCommand(Find);
_performComparisonCommand = new RelayCommand(PerformComparison);
_selectedWordPairsMonitor = new SimpleMonitor();
_varietyPairState = VarietyPairState.NotSelected;
TaskAreas.Add(new TaskAreaItemsViewModel("Common tasks",
new TaskAreaCommandViewModel("Compare variety pair", new RelayCommand(PerformComparison, CanPerformComparison)),
new TaskAreaCommandViewModel("Find words", _findCommand),
new TaskAreaItemsViewModel("Sort word pairs by", new TaskAreaCommandGroupViewModel(
new TaskAreaCommandViewModel("Similarity", new RelayCommand(() => SortWordPairsBy("PhoneticSimilarityScore", ListSortDirection.Descending))),
new TaskAreaCommandViewModel("Gloss", new RelayCommand(() => SortWordPairsBy("Meaning.Gloss", ListSortDirection.Ascending)))))));
TaskAreas.Add(new TaskAreaItemsViewModel("Other tasks",
new TaskAreaCommandViewModel("Export results for variety pair", new RelayCommand(ExportVarietyPair, CanExportVarietyPair))));
}
public SegmentsViewModel(IProjectService projectService, IDialogService dialogService, IBusyService busyService, IExportService exportService, WordsViewModel.Factory wordsFactory,
WordViewModel.Factory wordFactory)
: base("Segments")
{
_projectService = projectService;
_busyService = busyService;
_dialogService = dialogService;
_exportService = exportService;
_wordFactory = wordFactory;
_findCommand = new RelayCommand(Find);
TaskAreas.Add(new TaskAreaCommandGroupViewModel("Syllable position",
new TaskAreaCommandViewModel("Onset", new RelayCommand(() => SyllablePosition = SyllablePosition.Onset)),
new TaskAreaCommandViewModel("Nucleus", new RelayCommand(() => SyllablePosition = SyllablePosition.Nucleus)),
new TaskAreaCommandViewModel("Coda", new RelayCommand(() => SyllablePosition = SyllablePosition.Coda))));
TaskAreas.Add(new TaskAreaItemsViewModel("Common tasks",
new TaskAreaCommandViewModel("Find words", _findCommand),
new TaskAreaItemsViewModel("Sort words by", new TaskAreaCommandGroupViewModel(
new TaskAreaCommandViewModel("Meaning", new RelayCommand(() => SortWordsBy("Meaning.Gloss", ListSortDirection.Ascending))),
new TaskAreaCommandViewModel("Form", new RelayCommand(() => SortWordsBy("StrRep", ListSortDirection.Ascending)))))));
TaskAreas.Add(new TaskAreaItemsViewModel("Other tasks",
new TaskAreaCommandViewModel("Export segment frequencies", new RelayCommand(ExportSegmentFrequencies, CanExportSegmentFrequencies))));
_projectService.ProjectOpened += _projectService_ProjectOpened;
Messenger.Default.Register<DomainModelChangedMessage>(this, msg =>
{
if (msg.AffectsComparison)
PopulateSegments();
});
_currentWords = new BulkObservableList<WordViewModel>();
_observedWords = wordsFactory(new ReadOnlyBindableList<WordViewModel>(_currentWords));
_domainSegments = new BulkObservableList<Segment>();
_segments = new BulkObservableList<SegmentViewModel>();
_readonlySegments = new ReadOnlyBindableList<SegmentViewModel>(_segments);
_categories = new BulkObservableList<SegmentCategoryViewModel>();
_readonlyCategories = new ReadOnlyBindableList<SegmentCategoryViewModel>(_categories);
}
public MainWindowViewModel(IProjectService projectService, IDialogService dialogService, IImportService importService, IExportService exportService,
IImageExportService imageExportService, IAnalysisService analysisService, InputViewModel input, CompareViewModel compare, AnalyzeViewModel analyze)
: base("Cog", input, compare, analyze)
{
_dialogService = dialogService;
_importService = importService;
_exportService = exportService;
_imageExportService = imageExportService;
_projectService = projectService;
_analysisService = analysisService;
_newCommand = new RelayCommand(New);
_openCommand = new RelayCommand(Open);
_saveCommand = new RelayCommand(Save, CanSave);
_saveAsCommand = new RelayCommand(SaveAs);
_importWordListsCommand = new RelayCommand(ImportWordLists);
_importGeographicRegionsCommand = new RelayCommand(ImportGeographicRegions);
_exportWordListsCommand = new RelayCommand(ExportWordLists, CanExportWordLists);
_exportSimilarityMatrixCommand = new RelayCommand(ExportSimilarityMatrix, CanExportSimilarityMatrix);
_exportCognateSetsCommand = new RelayCommand(ExportCognateSets, CanExportCognateSets);
_exportSegmentFrequenciesCommand = new RelayCommand(ExportSegmentFrequencies, CanExportSegmentFrequencies);
_exportHierarchicalGraphCommand = new RelayCommand(ExportHierarchicalGraph, CanExportHierarchicalGraph);
_exportNetworkGraphCommand = new RelayCommand(ExportNetworkGraph, CanExportNetworkGraph);
_exportGlobalCorrespondencesChartCommand = new RelayCommand(ExportGlobalCorrespondencesChart, CanExportGlobalCorrespondencesChart);
_performComparisonCommand = new RelayCommand(PerformComparison, CanPerformComparison);
_runStemmerCommand = new RelayCommand(RunStemmer, CanRunStemmer);
_aboutCommand = new RelayCommand(ShowAbout);
_showTutorialCommand = new RelayCommand(() => Process.Start("https://github.com/sillsdev/cog/wiki/Cog-Tutorial"));
_showGettingStartedCommand = new RelayCommand(ShowGettingStarted);
foreach (ContainerViewModelBase childView in Views.OfType<ContainerViewModelBase>())
childView.PropertyChanging += childView_PropertyChanging;
PropertyChanging += OnPropertyChanging;
_nullCommand = new RelayCommand(() => {}, () => false);
_findCommand = _nullCommand;
Messenger.Default.Register<SwitchViewMessage>(this, HandleSwitchView);
Messenger.Default.Register<HookFindMessage>(this, msg => FindCommand = msg.FindCommand ?? _nullCommand);
}
public MultipleWordAlignmentViewModel(IProjectService projectService, IBusyService busyService, IExportService exportService, IAnalysisService analysisService)
: base("Multiple Word Alignment")
{
_projectService = projectService;
_busyService = busyService;
_exportService = exportService;
_analysisService = analysisService;
_projectService.ProjectOpened += _projectService_ProjectOpened;
var showCognateSets = new TaskAreaBooleanViewModel("Show cognate sets") {Value = true};
showCognateSets.PropertyChanged += _showCognateSets_PropertyChanged;
TaskAreas.Add(new TaskAreaItemsViewModel("Common tasks",
new TaskAreaItemsViewModel("Sort words by",
new TaskAreaCommandGroupViewModel(
new TaskAreaCommandViewModel("Form", new RelayCommand(() => SortBy("StrRep", ListSortDirection.Ascending))),
new TaskAreaCommandViewModel("Variety", new RelayCommand(() => SortBy("Variety", ListSortDirection.Ascending)))),
showCognateSets)));
TaskAreas.Add(new TaskAreaItemsViewModel("Other tasks",
new TaskAreaCommandViewModel("Export all cognate sets", new RelayCommand(ExportCognateSets, CanExportCognateSets))));
_words = new BindableList<MultipleWordAlignmentWordViewModel>();
_selectedWords = new BindableList<MultipleWordAlignmentWordViewModel>();
_showInVarietyPairsCommand = new RelayCommand(ShowInVarietyPairs, CanShowInVarietyPairs);
_performComparisonCommand = new RelayCommand(PerformComparison);
_groupByCognateSet = true;
_sortByProp = "StrRep";
Messenger.Default.Register<ComparisonPerformedMessage>(this, msg => AlignWords());
Messenger.Default.Register<DomainModelChangedMessage>(this, msg =>
{
if (msg.AffectsComparison)
ResetAlignment();
});
Messenger.Default.Register<PerformingComparisonMessage>(this, msg => ResetAlignment());
Messenger.Default.Register<SwitchViewMessage>(this, HandleSwitchView);
}
public ShellMainViewModel(IExportService exportService, IRegionManager regionManager,
IUnityContainer container, IEventAggregator eventAggregator, ISharedService shared)
{
_exportService = exportService;
_regionManager = regionManager;
_container = container;
_eventAggregator = eventAggregator;
_shared = shared;
ExportFilesCommand = new DelegateCommand(() =>
_exportService.ExportToFileSystem("c:\\ext\\todel"));
ExportZipCommand = new DelegateCommand(() =>
_exportService.ExportDoubleZipPasswordToFileSystem("c:\\ext\\todel\\conspector.zip", "123"));
ExportGitCommand = new DelegateCommand(() =>
{
var dlg = new GetPasswordDlg();
var result = dlg.ShowDialog();
if (result != null && result.Value)
_exportService.ExportDoubleZipPasswordToGit("c:\\Ext\\GIT\\Stumps", dlg.Password);
});
ExportGitPublicCommand = new DelegateCommand(() =>
{
var dlg = new GetPasswordDlg();
var result = dlg.ShowDialog();
if (result != null && result.Value)
_exportService.ExportPublicGit(dlg.Password);
});
ImportGitPublicCommand = new DelegateCommand(() =>
{
var res = MessageBox.Show(@"Подтверждение",
@"Вы уверены, что хотите импортировать данные из публичного репозитория?", MessageBoxButtons.YesNo);
if (res == DialogResult.Yes)
{
_exportService.ImportGitPublic();
_eventAggregator.GetEvent<DatabaseImportedEvent>().Publish("Imported");
}
});
ImportZipCommand = new DelegateCommand(() =>
{
var dlg = new GetPasswordDlg();
var result = dlg.ShowDialog();
if (result != null && result.Value)
{
_exportService.ImportDoubleZip(
"c:\\ext\\Git\\stumps\\conspector.zip", dlg.Password);
_eventAggregator.GetEvent<DatabaseImportedEvent>().Publish("Imported");
}
});
ImportFilesCommand = new DelegateCommand(() =>
{
_exportService.ImportFromFileSystem("c:\\ext\\todel");
_eventAggregator.GetEvent<DatabaseImportedEvent>().Publish("Imported");
});
ImportFolderCommand = new DelegateCommand(() =>
{
_exportService.ImportFolder("c:\\ext\\todel\\Conspector");
_eventAggregator.GetEvent<DatabaseImportedEvent>().Publish("Imported");
});
ActiveMaterialChangeCommand = new DelegateCommand<SelectedItemChangedEventArgs>(args =>
{
var a = args.Item as DocumentPanel;
if (a != null)
{
var b = a.Content as IItemRegionView;
if (b != null)
_shared.SetCurrentMaterial(b.PanelId);
}
});
var openFile =
new DelegateCommand<Guid?>
(s =>
{
var region = _regionManager.Regions[Top.RegionNames.DocumentViewRegion];
var view = region.Views
.OfType<IDocumentViewerRegionView>()
.FirstOrDefault(v => v.PanelId == s);
if (view != null)
region.Activate(view);
else
{
var newView = _container.Resolve<IDocumentViewerRegionView>();
newView.OpenMaterial(s ?? Guid.Empty);
region.Add(newView);
}
});
Interfaces.CompositeCommands.OpenSourceCommand.RegisterCommand(openFile);
var openBlock =
new DelegateCommand<Guid?>
(s =>
{
var region = _regionManager.Regions[Top.RegionNames.DocumentViewRegion];
var view = region.Views
.OfType<IBlockViewerRegionView>()
.FirstOrDefault(v => v.PanelId == s);
if (view != null)
region.Activate(view);
else
{
var newView = _container.Resolve<IBlockViewerRegionView>();
if (s != null)
{
newView.OpenBlock(s.Value);
region.Add(newView);
}
}
});
Interfaces.CompositeCommands.OpenBlockCommand.RegisterCommand(openBlock);
}
public TraySearch()
{
InitializeComponent();
packageStoreService = new PackageStoreService();
exportService = new ExportService();
}
private void Dispose(bool disposing)
{
if (_IsDisposed)
throw new ObjectDisposedException("ExportService");
try
{
_ExportService.Unsubscribe();
Channel.Close();
}
catch { }
finally
{
_ExportService = null;
}
_IsDisposed = true;
if (disposing)
GC.SuppressFinalize(this);
}
public void Open()
{
if (_IsDisposed)
throw new ObjectDisposedException("ExportService");
// Creating channel factory
var factory = new DuplexChannelFactory<IExportService>(
new InstanceContext(this),
new NetNamedPipeBinding());
// Creating server channel
_ExportService = factory.CreateChannel(new EndpointAddress(_ServiceAddress));
IClientChannel channel = (IClientChannel)_ExportService;
channel.Open();
_ExportService.Subscribe();
}
