/// <summary>
/// Initializes a new instance of the <see cref="SearchCommand" /> class.
/// </summary>
/// <param name="maxRunsText">The maximum runs text.</param>
/// <param name="city">The city.</param>
/// <param name="state">The state.</param>
/// <param name="zip">The zip.</param>
/// <param name="namesFilePath">The names text file path.</param>
/// <param name="options">The options.</param>
public SearchCommand(string maxRunsText, string city, string state, string zip, string namesFilePath, CommandLineOptions options)
{
int.TryParse(maxRunsText, out int maxRuns);
_maxRuns = maxRuns;
_city = city;
_state = state;
_zip = zip;
_namesFilePath = namesFilePath;
_resultOutputPath = Program.SearchResultsDirectory;
_options = options;
this.Repository = Program.Repository;
this.Configuration = Program.Configuration;
this.FindPersonController = new FindPersonController(this.Configuration);
this.Import = new Import();
this.Export = new Export();
this.Mapper = MapperFactory.Get();
this.SerializerSettings = JsonSerializerSettingsFactory.Get();
//Default Value
this.SearchWaitMs = 60000;
var waitMs = Configuration.GetValue <string>("SearchSettings:WaitMs");
int.TryParse(waitMs, out this.SearchWaitMs);
this.PeopleSearch = new PeopleSearch(Repository, FindPersonController, SerializerSettings, Mapper, Export, _resultOutputPath, SearchWaitMs);
}
public ImportControllerTest()
{
var provider = new ServiceCollection()
.AddMemoryCache()
.BuildServiceProvider();
var memoryCache = provider.GetService <IMemoryCache>();
var builder = new DbContextOptionsBuilder <ApplicationDbContext>();
builder.UseInMemoryDatabase("test");
var options = builder.Options;
var context = new ApplicationDbContext(options);
var services = new ServiceCollection();
_appSettings = new AppSettings();
// Add Background services
services.AddSingleton <IHostedService, UpdateBackgroundQueuedHostedService>();
services.AddSingleton <IUpdateBackgroundTaskQueue, UpdateBackgroundTaskQueue>();
var serviceProvider = services.BuildServiceProvider();
// get the background helper
_bgTaskQueue = serviceProvider.GetRequiredService <IUpdateBackgroundTaskQueue>();
_scopeFactory = serviceProvider.GetRequiredService <IServiceScopeFactory>();
_import = new FakeIImport(new FakeSelectorStorage(new FakeIStorage()));
}
public FileHandler(Window parent, IInfo info, ILastFileHandler lfh, UndoManager undo)
{
this.parent = parent;
this.info = info;
this.lfh = lfh;
this.undo = undo;
FileState = new FileState();
FileState.FileStateInternalChanged += (s, e) => OnFileStateChanged();
open = new XMLImport();
save = new XMLExport();
saveFileDialog = new SaveFileDialog();
openFileDialog = new OpenFileDialog();
exportFileDialog = new SaveFileDialog();
importFileDialog = new OpenFileDialog();
saveFileDialog.AddLegacyFilter(save.Filter);
openFileDialog.AddLegacyFilter(open.Filter);
FileOpened += (s, e) => MaybeUpgradeTtVersion();
SetLastPath(info.Settings.Get("files.lastpath", ""));
}
public static void Load(this Worksheet self, IImport import)
{
self.Cells[0, 0].Value = string.Empty;
var attributes = import.GetAttributes();
for (int i = 0; i < attributes.Count; i++)
{
self.Cells[0, i + 1].Value = attributes[i];
}
var obj = import.GetObjects();
for (int i = 0; i < obj.Count; i++)
{
self.Cells[i + 1, 0].Value = obj[i];
}
var context = import.GetContext();
for (int i = 0; i < context.Count; i++)
{
for (int j = 0; j < context[i].Count; j++)
{
self.Cells[i + 1, j + 1].Value = context[i][j];
}
}
}
public MainViewModel()
{
this._Logger = ServiceLocator.Current.GetInstance <ILog>();
this._resourceManager = ServiceLocator.Current.GetInstance <IResourceManager>();
this._resourceManager.InitialiseResources(false);
this._Settings = (Settings)this._resourceManager.GetResourcePayload(ResourceName.Mapping_Settings);
if (this._Settings == null)
{
this._Settings = new Settings();
}
else
{
this._LocalImportPath = this._Settings.ListOfSettings.Where(i => i.Name == "Import_Folder").Select(i => i.Data).FirstOrDefault();
this.RemoteImportPath = this._Settings.ListOfSettings.Where(i => i.Name == "Remote_Import_Folder").Select(i => i.Data).FirstOrDefault();
this.ExportPath = this._Settings.ListOfSettings.Where(i => i.Name == "Export_Folder").Select(i => i.Data).FirstOrDefault();
}
this.isPrecheckEnabled = true;
this.isAllChecked = false;
this.isReadCloud = true;
this._DBActions = ServiceLocator.Current.GetInstance <IDBActions>();
this.isFlushDB = true;
this.isImport = true;
this._Importer = ServiceLocator.Current.GetInstance <IImport>();
this._Exporter = ServiceLocator.Current.GetInstance <IExport>();
if (this._RemoteImportPath != null)
{
this.PreChecks();
}
}
static void DataImport(IImport import)
{
var cts = new CancellationTokenSource();
cts.CancelAfter(4000);
var ct = cts.Token;
Task importTask = import.ImportXmlFilesAsync(@"C:\data", ct);
while (!importTask.IsCompleted)
{
Console.Write(".");
if (Console.KeyAvailable && Console.ReadKey(true).Key == ConsoleKey.Q)
{
try
{
cts.Cancel();
importTask.Wait();
}
catch (AggregateException ex)
{
Console.WriteLine(ex.Flatten());
}
}
Console.WriteLine(importTask.Status);
Thread.Sleep(250);
}
}
public ImportCli(IImport importService, AppSettings appSettings, IConsole console, IExifToolDownload exifToolDownload)
{
_importService = importService;
_appSettings = appSettings;
_console = console;
_exifToolDownload = exifToolDownload;
}
public HttpResponseMessage Upload()
{
HttpPostedFile file = HttpContext.Current.Request.Files["school"];
ErrMsg msg = new ErrMsg();
IImport import = ExcelFactory.Instance().GetExcelImporter(new eh.impls.configurations.ExcelConfiguration(1, 0, 0), msg);
IList <School> list = SchoolDto.ToList(import.Import <SchoolDto>(file.InputStream));
if (msg.Count != 0)
{
return(ToJson(msg.GetErrors(), status_code: 0, msg: "fail"));
}
else
{
try
{
Service.Add(list);
return(ToJson("success"));
}
catch (SqlException ex)
{
msg.AddErrMsg(ex.Message);
return(ToJson(msg.GetErrors(), status_code: 0, msg: "fail"));
}
}
}
public void do_import_does_not_write_data_into_server_if_sourceConnectionString_empty()
{
_source.GetConnectionString().Returns(string.Empty);
sut = new Import(_source, _target, _reader, _writer);
sut.DoImport("ehasan", null);
Assert.AreEqual(false, _writer.IsDataSaved);
}
internal void Import()
{
var importers = info.GetRegistered <IImport>();
if (importers.Length == 0)
{
info.Logger.Error("Keine Importer gefunden, Import nicht möglich!");
return;
}
if (!NotifyIfUnsaved())
{
return;
}
if (importFileDialog.ShowDialog(parent) == DialogResult.Ok)
{
IImport import = importers[importFileDialog.CurrentFilterIndex - 1];
info.Logger.Info("Öffne Datei " + importFileDialog.FileName);
Timetable = import.Import(importFileDialog.FileName, info);
if (Timetable == null)
{
return;
}
info.Logger.Info("Datei erfolgeich geöffnet!");
FileState.Opened = true;
FileState.Saved = true;
FileState.FileName = importFileDialog.FileName;
undo.ClearHistory();
}
}
private void LoadLine()
{
if (tt.Stations.Count != 0)
{
return;
}
if (info.Timetable.Type == TimetableType.Network)
{
throw new Exception("Streckendateien können bei Netzwerk-Fahrplänen nicht geladen werden!");
}
IImport timport = new XMLImport();
IImport simport = new NonDefaultFiletypes.XMLStationsImport();
using (var ofd = new OpenFileDialog())
{
ofd.AddLegacyFilter(timport.Filter, simport.Filter);
if (ofd.ShowDialog(this) == DialogResult.Ok)
{
IImport import = Path.GetExtension(ofd.FileName) == ".fpl" ? timport : simport;
var ntt = import.Import(ofd.FileName, info);
foreach (var station in ntt.Stations)
{
tt.AddStation(station, Timetable.LINEAR_ROUTE_ID);
}
// ntt will be destroyed by decoupling stations, do not use afterwards!
}
}
UpdateStations();
}
public AppEngine(IExcel iExcel, IEventAggregator iAgregator, IOutput iOutput, IImport import, IBudgetRepository repository)
{
_IExcel = iExcel;
_iAggregator = iAgregator;
_iOutput = iOutput;
_import = import;
_repository = repository;
_iAggregator.SubsribeEvent(this);
string path = _repository.Options.Item.CategoryPath;
string reportPath = _repository.Options.Item.DocumentPath;
_repository.Categories.Load(path);
_repository.Reports.Load(reportPath);
_iOutput.ShowReports(_repository.Reports.Item.Reports);
_iAggregator.PublishEvent(new PathChangedEvent()
{
Path = path
});
MenuItem menuStructure = MenuFactory.GetMenu();
_iOutput.AttachMenu(menuStructure);
ProceedEditRules();
}
public async Task <IActionResult> Connect([Bind("ID, Credential, Issues")] Project project)
{
if (ModelState.IsValid)
{
importService = ImportFactory.GetImportFrom("jira");
//importService.Connect(new Credential()
//{
// Uri = "https://queryexport.atlassian.net",
// Username = "******",
// Password = "******"
//});
//if (project.ID == 0)
//{
// _context.Add(project);
// await _context.SaveChangesAsync();
//}
importService.Connect(new Credential()
{
Uri = project.Credential.Uri,
Username = project.Credential.Username,
Password = project.Credential.Password
});
var res = await importService.GetIssuesForProject();
project.Issues = res;
_context.Add(project);
await _context.SaveChangesAsync();
}
return(RedirectToAction("Index"));
}
public Import(VolumeDatabase db)
{
this.database = db;
this.import = null;
BuildGui();
btnImport.Sensitive = false; // will be enabled on file selection
}
/// <summary>
/// Sets the import location.
/// </summary>
/// <param name="importLocation">The import location.</param>
public virtual void SetImportLocation(IImport importLocation)
{
Debug.Assert(importLocation != null);
Debug.Assert(!IsLocationAssigned || ImportLocation == importLocation);
_ImportLocation = importLocation;
IsLocationAssigned = true;
}
public void Setup()
{
_source = Substitute.For <IData>();
_target = Substitute.For <IData>();
_reader = Substitute.For <IReader>();
_writer = new SqlBulkCopyDataWriterFake();
sut = new Import(_source, _target, _reader, _writer);
}
public Import(VolumeDatabase db)
{
this.database = db;
this.import = null;
BuildGui();
btnImport.Sensitive = false; // will be enabled on file selection
}
/// <summary>
/// 验证数据
/// </summary>
public virtual void ValidationValueAfter()
{
IImport <TEntity> import = ServiceContainer.GetService <IImport <TEntity> >();
if (import != null)
{
import.ValidationValueAfter(ExcelGlobalDTO);
}
}
private IEnumerable<Transaction> BuildTransaction(IImport import)
{
return
from row in import.GetData()
where row.Amount != 0M
let account = GetAccount(row) ?? row.IdentifyAccount(_context.Patterns) ?? UnclassifedDestination
let description = GetDescription(row)
where account != null
select AsTransaction(row, account, description);
}
public View(IImport dl, IDeclineData d, IMethod m, IChart c, IExport e)
{
dataImport = dl;
declineData = d;
method = m;
chart = c;
dataExport = e;
dataView = new SortedDictionary <DateTime, double>();
}
public EntriesController(ApplicationDbContext context,
IImport import,
IServiceProvider serviceProvider,
UserManager <AppUser> userManager)
{
_import = import;
_context = context;
_userManager = userManager;
_serviceProvider = serviceProvider;
}
public IEnumerable<Transaction> Process(IImport import, IDictionary<string, ImportRowOptions> mappings = null)
{
Result.Date = DateTimeServer.Now;
Result.Name = import.Name;
Result.ImportType = import.ImportType;
_mappings = mappings;
return BuildTransaction(import).Where(transaction => _context.General.Post(transaction));
}
public void do_import_does__write_data_into_server_if_all_above_conditions_met()
{
_source.GetConnectionString().Returns("ConnectiontionString");
_source.GetSql().Returns("Sql");
_target.GetConnectionString().Returns("ConnectiontionString");
sut = new Import(_source, _target, _reader, _writer);
sut.DoImport("ehasan", null);
Assert.AreEqual(true, _writer.IsDataSaved);
}
private void SaveImportToDatabase()
{
Import <T> temp = new Import <T>().Where("import_month ={0} AND import_year={1}".Format(_import.ImportMonth, _import.ImportYear)).FirstOrDefault();
if (temp == null)
{
_import.Add();
}
else
{
_import = temp;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ImportSearchesCommand" /> class.
/// </summary>
/// <param name="path">The path.</param>
/// <param name="options">The options.</param>
public ImportSearchesCommand(string path, CommandLineOptions options)
{
_path = path;
_options = options;
this.Repository = Program.Repository;
this.Import = new Import();
this.Export = new Export();
this.Mapper = MapperFactory.Get();
this.SerializerSettings = JsonSerializerSettingsFactory.Get();
this.ImportExport = new ImportExport(Repository, SerializerSettings, Mapper, Import, Export);
}
/// <summary>
/// Initializes a new instance of the <see cref="ExportPeopleCommand" /> class.
/// </summary>
/// <param name="options">The options.</param>
public ExportPeopleCommand(CommandLineOptions options)
{
_options = options;
this.Repository = Program.Repository;
this.Import = new Import();
this.Export = new Export();
this.Mapper = MapperFactory.Get();
this.SerializerSettings = JsonSerializerSettingsFactory.Get();
_fullPath = Path.Combine(Program.ExportDirectory, $"PeopleExport-{DateTime.Now}.csv");
this.ImportExport = new ImportExport(Repository, SerializerSettings, Mapper, Import, Export);
}
public ImportController(IImport import, AppSettings appSettings,
IUpdateBackgroundTaskQueue queue,
IHttpClientHelper httpClientHelper, ISelectorStorage selectorStorage,
IServiceScopeFactory scopeFactory, IWebLogger logger)
{
_appSettings = appSettings;
_import = import;
_bgTaskQueue = queue;
_httpClientHelper = httpClientHelper;
_selectorStorage = selectorStorage;
_hostFileSystemStorage = selectorStorage.Get(SelectorStorage.StorageServices.HostFilesystem);
_thumbnailStorage = selectorStorage.Get(SelectorStorage.StorageServices.Thumbnail);
_scopeFactory = scopeFactory;
_logger = logger;
}
public UploadController(IImport import, AppSettings appSettings,
ISelectorStorage selectorStorage, IQuery query,
IRealtimeConnectionsService connectionsService, IWebLogger logger,
IMetaExifThumbnailService metaExifThumbnailService)
{
_appSettings = appSettings;
_import = import;
_query = query;
_selectorStorage = selectorStorage;
_iStorage = selectorStorage.Get(SelectorStorage.StorageServices.SubPath);
_iHostStorage = selectorStorage.Get(SelectorStorage.StorageServices.HostFilesystem);
_connectionsService = connectionsService;
_logger = logger;
_metaExifThumbnailService = metaExifThumbnailService;
}
public static Timetable?SafeImport(this IImport imp, string filename, IReducedPluginInterface pluginInterface, ILog?replaceLog = null)
{
try
{
using (var stream = File.Open(filename, FileMode.OpenOrCreate, FileAccess.Read))
return(imp.Import(stream, pluginInterface, replaceLog));
}
catch (Exception ex)
{
var log = replaceLog ?? pluginInterface.Logger;
log.Error(imp.GetType().Name + ": " + ex.Message);
log.LogException(ex);
return(null);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ImportExport" /> class.
/// </summary>
/// <param name="repository">The repository.</param>
/// <param name="serializerSettings">The serializer settings.</param>
/// <param name="mapper">The mapper.</param>
/// <param name="import">The import.</param>
/// <param name="export">The export.</param>
public ImportExport(IEntityFrameworkRepository repository,
JsonSerializerSettings serializerSettings,
IMapper mapper,
IImport import,
IExport export)
{
this.Repository = repository;
this.SerializerSettings = serializerSettings;
this.Mapper = mapper;
this.Import = import;
this.Export = export;
this.PersonSearchResultHelper = new PersonSearchResultHelper(repository, serializerSettings, mapper);
this.PersonHelper = new PersonHelper(repository, mapper);
}
private static bool ImportHandler(YangStatement statement, IImport partial)
{
switch (statement.Keyword)
{
case "prefix":
partial.Prefix = statement.Argument;
return(true);
case "revision-date":
partial.Revision = statement.Argument;
return(true);
default:
return(false);
}
}
public static void DataImport(IImport import)
{
var tcs = new CancellationTokenSource();
CancellationToken ct = tcs.Token;
Task importTask = import.ImportXmlFilesAsync(@"C:\data", ct);
while (!importTask.IsCompleted)
{
Console.Write(".");
if (Console.KeyAvailable && Console.ReadKey(true).Key == ConsoleKey.Q)
{
tcs.Cancel();
}
Thread.Sleep(250);
}
}
public static void DataImport(IImport import)
{
var tcs = new CancellationTokenSource();
CancellationToken ct = tcs.Token;
Task importTask = import.ImportXmlFilesAsync(@"..\..\data", ct, new Progress <ImportProgress>(DisplayProgress));
while (!importTask.IsCompleted)
{
if (Console.KeyAvailable && Console.ReadKey(true).Key == ConsoleKey.Q)
{
tcs.Cancel();
}
Thread.Sleep(250);
}
Console.WriteLine(importTask.Status);
}
public void Init(ParsingContext context, ParseTreeNode parseNode, IGraphDS myGraphDS)
{
base.InitNode(context, parseNode, myGraphDS);
_pluginManager.Discover();
_componentName = parseNode.ChildNodes[1].Token.ValueString;
if (base.CheckForComponent<IImport>(_componentName, context, parseNode.ChildNodes[1].Token.Location))
{
Dictionary<String, String> options;
if (parseNode.ChildNodes[2].ChildNodes.Count > 0)
{
options = ((OptionsNode)(parseNode.ChildNodes[2].AstNode)).Options;
}
else
{
options = new Dictionary<String, String>();
}
_import = _pluginManager.GetAndInitializePlugin<IImport>(
_componentName,
base.PreparePluginOptions(options, _graphDS));
}
}
private void OnFcDatabaseSelectionChanged(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(fcDatabase.Filename)) {
import = null;
lblFormat.Text = LBL_FORMAT_EMPTY;
btnImport.Sensitive = false;
return;
}
string sourceDbPath = fcDatabase.Filename;
string dbDataPath = PathUtil.GetDbDataPath(database);
int buffSize = App.Settings.ScannerBufferSize;
string ext = System.IO.Path.GetExtension(sourceDbPath);
if (ext.Length == 0)
import = null;
else
import = AbstractImport.GetImportByExtension(ext.Substring(1), sourceDbPath,
database, dbDataPath, buffSize);
if (import == null) {
lblFormat.Text = S._("Unknown format.");
btnImport.Sensitive = false;
} else {
import.ProgressUpdate += OnImportProgressUpdate;
import.ImportCompleted += OnImportCompleted;
lblFormat.Text = import.Name;
btnImport.Sensitive = true;
}
}
public CatWebserviceWrapper(IImport service)
{
Webservice = service;
WebserviceState = WebserviceWrapperState.Disconnected;
RegisterServiceEvents();
}
