static void Main(string[] args) { string source; string destination; Options options = new Options(); if (CommandLine.Parser.Default.ParseArguments(args, options)) { source = options.Source; destination = options.Destination; } else { Console.WriteLine("Source: "); source = Console.ReadLine(); Console.WriteLine("Destination: "); destination = Console.ReadLine(); } Importer importer = new Importer(); importer.ImportFiles(source, destination); Console.WriteLine("Press any key to exit..."); Console.ReadLine(); }
public void StandardExportInterfacesShouldWork() { // Export all interfaces except IDisposable, Export contracts on types without interfaces. except for disposable types var builder = new ConventionBuilder(); builder.ForTypesMatching((t) => true).ExportInterfaces(); builder.ForTypesMatching((t) => t.GetTypeInfo().ImplementedInterfaces.Where((iface) => iface != typeof(System.IDisposable)).Count() == 0).Export(); var container = new ContainerConfiguration() .WithPart<Standard>(builder) .WithPart<Dippy>(builder) .WithPart<Derived>(builder) .WithPart<BareClass>(builder) .CreateContainer(); var importer = new Importer(); container.SatisfyImports(importer); Assert.NotNull(importer.First); Assert.True(importer.First.Count() == 3); Assert.NotNull(importer.Second); Assert.True(importer.Second.Count() == 3); Assert.NotNull(importer.Third); Assert.True(importer.Third.Count() == 3); Assert.NotNull(importer.Fourth); Assert.True(importer.Fourth.Count() == 3); Assert.NotNull(importer.Fifth); Assert.True(importer.Fifth.Count() == 3); Assert.Null(importer.Base); Assert.Null(importer.Derived); Assert.Null(importer.Dippy); Assert.Null(importer.Standard); Assert.Null(importer.Disposable); Assert.NotNull(importer.BareClass); }
public static ImportNotificationOverview Load(ImportNotification notification, ImportNotificationAssessment assessment, Exporter exporter, Importer importer, Producer producer, FacilityCollection facilities, Shipment shipment, TransportRoute transportRoute, WasteOperation wasteOperation, WasteType wasteType) { return new ImportNotificationOverview { Notification = notification, Assessment = assessment, Exporter = exporter, Importer = importer, Producer = producer, Facilities = facilities, Shipment = shipment, TransportRoute = transportRoute, WasteOperation = wasteOperation, WasteType = wasteType }; }
public void BinaryTreeMustSortTheSameAsSortedDictionary() { // Arrange var asm = Assembly.GetExecutingAssembly(); var importer = new Importer(asm.GetManifestResourceStream("ClientImport.Tests.records.txt"), ','); var dictionary = new SortedDictionary<string, IPerson>(); var tree = new BinarySearchTree<string, IPerson>(); //Act importer.Data .ToList() .ForEach(record => { var person = new Person { FirstName = record.FirstName, Surname = record.Surname, Age = Convert.ToInt16(record.Age) }; var key = PersonRepository.BuildKey(person, SortKey.SurnameFirstNameAge); if (tree.Find(key) == null) tree.Add(key, person); } ); tree .ToList() .Shuffle() //Shuffle result from binary tree, to test sorting .ForEach(r => dictionary.Add(PersonRepository.BuildKey(r.KeyValue.Value, SortKey.SurnameFirstNameAge), r.KeyValue.Value)); var expected = dictionary.Select(r => r.Value).ToList(); var actual = tree.Select(n => n.KeyValue.Value).ToList(); // Assert CollectionAssert.AreEqual(expected, actual); }
internal static bool ScanMediaDirectories ( string[] mediaFolders, ref IList<string> extensionsToIgnore, string[] filmLocations, string[] tvShowsLocations,string[] musicLocations, string[] videoExtensions, string[] audioExtensions, IEnumerable<string> combinedSceneTags, IEnumerable<string> videoExtensionsCommon, Importer importer ) { string pluginpath = Debugger.GetPluginPath(); foreach (string importRootFolder in mediaFolders) if ( !CalculateExaminationtimeAndScanMediaFolder (MediaSectionsAllocator.MoviesSection, MediaSectionsAllocator.TvEpisodesSection, MediaSectionsAllocator.MusicSection, ref extensionsToIgnore, filmLocations, tvShowsLocations, musicLocations, videoExtensions, audioExtensions, importRootFolder, pluginpath, combinedSceneTags, videoExtensionsCommon ) ) return false; return true; }
public Parser(int optimization, IStylizer stylizer, Importer importer, bool noCache = false) { Stylizer = stylizer; Importer = importer; Tokenizer = new Tokenizer(optimization); NoCache = noCache; }
/// <summary> /// Create the DevirtualizedAttribute TypeDef, with a "default .ctor" that /// calls the base type's .ctor (System.Attribute). /// </summary> /// <returns>TypeDef</returns> TypeDef CreateDevirtualizedAttribute() { var importer = new Importer(this.Module); var attributeRef = this.Module.CorLibTypes.GetTypeRef("System", "Attribute"); var attributeCtorRef = importer.Import(attributeRef.ResolveTypeDefThrow().FindMethod(".ctor")); var devirtualizedAttr = new TypeDefUser( "eazdevirt.Injected", "DevirtualizedAttribute", attributeRef); //devirtualizedAttr.Attributes = TypeAttributes.Public | TypeAttributes.AutoLayout // | TypeAttributes.Class | TypeAttributes.AnsiClass; var emptyCtor = new MethodDefUser(".ctor", MethodSig.CreateInstance(this.Module.CorLibTypes.Void), MethodImplAttributes.IL | MethodImplAttributes.Managed, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName | MethodAttributes.ReuseSlot | MethodAttributes.HideBySig); var instructions = new List<Instruction>(); instructions.Add(OpCodes.Ldarg_0.ToInstruction()); instructions.Add(OpCodes.Call.ToInstruction(attributeCtorRef)); // Call the constructor .ctor instructions.Add(OpCodes.Ret.ToInstruction()); emptyCtor.Body = new CilBody(false, instructions, new List<ExceptionHandler>(), new List<Local>()); devirtualizedAttr.Methods.Add(emptyCtor); return devirtualizedAttr; }
/////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Showes process results with details in message window. /// </summary> /// <param name="importer">Importer object.</param> /// <param name="geocoder">Geocoder object (can be NULL).</param> /// <param name="storage">Storage object</param> /// <param name="status">Status text.</param> public void Inform(Importer importer, Geocoder geocoder, Storage storage, string status) { Debug.Assert(!string.IsNullOrEmpty(status)); // not empty Debug.Assert(null != importer); // created Debug.Assert(null != storage); // created var details = new List<MessageDetail>(); // add statistic string statistic = _CreateStatistic(importer, geocoder, storage); Debug.Assert(!string.IsNullOrEmpty(statistic)); var statisticDetail = new MessageDetail(MessageType.Information, statistic); details.Add(statisticDetail); // add geocoder exception if ((null != geocoder) && (null != geocoder.Exception)) { details.Add(_GetServiceMessage(geocoder.Exception)); } // add steps deatils details.AddRange(importer.Details); if (null != geocoder) details.AddRange(geocoder.Details); details.AddRange(storage.Details); // show status with details App.Current.Messenger.AddMessage(status, details); }
public void ImporterCallsConverterOnce() { var importer = new Importer(_source, _converter, _destination); importer.Run(); _converter.Received(1).ConvertData(Arg.Any<DataTable>()); }
public ImporterViewModel(Importer importer) { Address = new AddressViewModel(importer.Address); BusinessName = importer.BusinessName; Contact = new ContactViewModel(importer.Contact); RegistrationNumber = importer.RegistrationNumber; Type = importer.Type; }
/// <summary> /// /// </summary> protected void btnAddExampleContent_Click(object sender, EventArgs e) { Importer z = new Importer(); // z.ExportContentTree(1068, "HelpandExample.content"); z.ImportContentTree("HelpandExample.content"); importMessage.Text = "Example Content Imported - You should see this on the content node."; }
public void CanCreateImporter() { var business = ObjectFactory.CreateEmptyBusiness(); var address = ObjectFactory.CreateDefaultAddress(); var contact = ObjectFactory.CreateEmptyContact(); var importer = new Importer(Guid.NewGuid(), address, business, contact); Assert.NotNull(importer); }
public ImporterViewModel(Importer importer) { Name = importer.Business.Name; address = new AddressViewModel(importer.Address); ContactPerson = importer.Contact.FullName; Telephone = importer.Contact.Telephone.ToFormattedContact(); Fax = importer.Contact.Fax.ToFormattedContact(); Email = importer.Contact.Email; RegistrationNumber = importer.Business.RegistrationNumber; }
private Import(string path, Importer importer) { Importer = importer; var regex = new Regex(@"\.(le|c)ss$"); Path = regex.IsMatch(path) ? path : path + ".less"; Css = Path.EndsWith("css"); if(!Css) Importer.Import(this); }
public void AllDataIsLoadedFromTextFileIntoPersonBinaryTree() { // Arrange var repository = new PersonRepository(SortKey.SurnameFirstName); var asm = Assembly.GetExecutingAssembly(); var importer = new Importer(asm.GetManifestResourceStream("ClientImport.Tests.records.txt"), Delimiter); //Act repository.Import(importer.Data); // Assert Assert.AreEqual(49817, repository.Count()); }
public void DestinationReceivesConvertedData() { DataTable originalData = new DataTable("table1"); DataTable convertedData = new DataTable("table2"); _source.GetData().Returns(originalData); _converter.ConvertData(originalData).Returns(convertedData); var importer = new Importer(_source, _converter, _destination); importer.Run(); Assert.NotEqual(originalData, convertedData); _destination.Received(1).Receive(convertedData); }
public void ShouldLoadTextFileDataEvenWhenFileLayoutIsChanged() { //Arrange var asm = Assembly.GetExecutingAssembly(); //Act var importer = new Importer(asm.GetManifestResourceStream("ClientImport.Tests.recordsColumnChange.txt"), Delimiter); //Assert var data = importer.Data.ToList(); Assert.AreEqual("Adrie", data.First().FirstName); Assert.AreEqual("Ballingall", data.First().Surname); Assert.AreEqual("111", data.First().Age); }
public void ImportValues() { var container = ContainerFactory.Create(); Importer importer = new Importer(); Exporter exporter42 = new Exporter(42); CompositionBatch batch = new CompositionBatch(); batch.AddPart(importer); batch.AddPart(exporter42); CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport, ErrorId.ReflectionModel_ImportNotAssignableFromExport, RetryMode.DoNotRetry, () => { container.Compose(batch); }); }
static void Main(string[] args) { using (SPSite site = new SPSite(@"http://*****:*****@"C:\taxonomy.xml"); XElement termStoreCollectionElement = XElement.Parse(text); Importer importer = new Importer(); XElement termStoreElement = termStoreCollectionElement.Elements().First(); importer.ImportTermStore(session.TermStores, termStoreElement , true); } }
public void UpdateImporterReplacesFirst() { var business = Business.CreateBusiness("first", BusinessType.SoleTrader, "123", "456"); var address = ObjectFactory.CreateDefaultAddress(); var contact = ObjectFactory.CreateEmptyContact(); var importer = new Importer(Guid.NewGuid(), address, business, contact); var newBusiness = Business.CreateBusiness("second", BusinessType.SoleTrader, "123", "456"); var newAddress = ObjectFactory.CreateDefaultAddress(); var newContact = ObjectFactory.CreateEmptyContact(); importer.Update(newAddress, newBusiness, newContact); Assert.Equal("second", importer.Business.Name); }
private Import(string path, Importer importer) { Importer = importer; Path = path; if (path.EndsWith(".css")) { Css = true; } else { Css = !Importer.Import(this); // it is assumed to be css if it cannot be found as less if (Css && path.EndsWith(".less")) { throw new FileNotFoundException("You are importing a file ending in .less that cannot be found.", path); } } }
private Import(string path, Importer importer) { Importer = importer; var regex = new Regex(@"\.(le|c)ss$"); Path = regex.IsMatch(path) ? path : path + ".less"; Css = Path.EndsWith("css"); if (Css && Path.StartsWith(FORCE_IMPORT_PREFIX)) { Css = false; Path = Path.Substring(FORCE_IMPORT_PREFIX.Length); } if(!Css) Importer.Import(this); }
internal static bool DoImport(Importer importer, IMLSection section, IMLImportProgress progress) { try { #region INIT string pluginPath = Helpers.GetPluginPath(); string debugLogPath = pluginPath + "Debug.log"; //TODO: Replace ThisProgress with ImportProgress.CurrentProgress ThisProgress = progress; Settings.ImportingStarted = false; Settings.ImportingCompleted = false; ImportProgress.GeneralStatus = String.Empty; ImportProgress.SpecialStatus = String.Empty; ImportProgress.CurrentProgress = 0; #endregion Helpers.DeleteDebugLog(debugLogPath); if (!InternetConnectionDiagnostic.CheckOsDbAvailability()) return true; MediaSectionUpdater.UpdateMediaSection(section, pluginPath); ImportProgress.FinishImport(); return true; } catch (Exception e) { Helpers.LogMessageToFile( "An unexpected error ocurred " + "in Main Import Engine. " + "The error was: " + e); } return true; }
public static Importer Create(Guid notiificationId, Guid id, Business business = null, Address address = null, string name = "AnyName") { if (business == null) { business = ComplexTypeFactory.Create<Business>(); ObjectInstantiator<Business>.SetProperty(x => x.Name, name, business); } if (address == null) { address = ComplexTypeFactory.Create<Address>(); } var importer = new Importer(notiificationId, address, business, ComplexTypeFactory.Create<Contact>()); EntityHelper.SetEntityId(importer, id); return importer; }
internal static void StartMainImportingEngine (Importer importer, IMLSection section, IEnumerable<string> combinedSceneTags) { #region Media Importers GeneralStatus = "Performing media importing..."; SpecialStatus = String.Empty; //LibrarySynchronizerRestore // .LibrarySynchronizerRestoreFromBackup // (Settings.XmlBackupsDirectory); MediaImportingEngine.ImportMediaFilesMAIN(combinedSceneTags, importer); //var connectionresult = MediaImportingEngineHelpers.InitConnectionresult(); var connectionresult = Helpers.CheckInternetConnectionAndConnectToOSDb(); RssNewsImporter.ImportRssFeeds(connectionresult); #endregion #region Media Updaters if (MediaImportingEngineHelpers.RunMediaSectionsUpdatingEngine(importer, section, combinedSceneTags, connectionresult)) return; #endregion //#region Import Secquencer //ImportSequencer // .RunImports(); //#endregion }
public async Task<ActionResult> Index(Guid id, ImporterViewModel model) { if (!ModelState.IsValid) { return View(model); } var importer = new Importer(id) { Address = model.Address.AsAddress(), BusinessName = model.BusinessName, Type = model.Type, RegistrationNumber = model.RegistrationNumber, Contact = model.Contact.AsContact() }; await mediator.SendAsync(new SetDraftData<Importer>(id, importer)); return RedirectToAction("Index", "Producer"); }
private TypeDef GetArrayType(long size) { CreateOurType(); TypeDef arrayType; if (_arrayTypeDictionary.TryGetValue(size, out arrayType)) return arrayType; var importer = new Importer(_module); var valueTypeRef = importer.Import(typeof (ValueType)); arrayType = new TypeDefUser("", $"__StaticArrayInitTypeSize={size}", valueTypeRef); _module.UpdateRowId(arrayType); arrayType.Attributes = TypeAttributes.NestedPrivate | TypeAttributes.ExplicitLayout | TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.AnsiClass; _ourType.NestedTypes.Add(arrayType); _arrayTypeDictionary[size] = arrayType; arrayType.ClassLayout = new ClassLayoutUser(1, (uint) size); return arrayType; }
public static NotificationApplicationOverview Load(NotificationApplication notification, NotificationAssessment assessment, WasteRecovery.WasteRecovery wasteRecovery, WasteDisposal wasteDisposal, Exporter.Exporter exporter, Importer.Importer importer, int charge, NotificationApplicationCompletionProgress progress) { return new NotificationApplicationOverview { Exporter = exporter, Importer = importer, Notification = notification, NotificationAssessment = assessment, WasteRecovery = wasteRecovery, WasteDisposal = wasteDisposal, Charge = charge, Progress = progress }; }
public ActionResult Create(Importer importer) { if (ModelState.IsValid) { var is_exist = (from i in db.Importers where i.importer_mob_no == importer.importer_mob_no select i).Count(); if (is_exist > 0) { TempData["errorMessage"] = "This Mobile Number Already Exist"; } else { importer.status_id = 1; importer.created_date = Convert.ToDateTime(DateTime.Now.ToString()).ToString("yyyy-MM-dd"); importer.updated_date = Convert.ToDateTime(DateTime.Now.ToString()).ToString("yyyy-MM-dd"); db.Importers.Add(importer); db.SaveChanges(); TempData["errorMessage"] = "Importer Added Successfully"; } return RedirectToAction("Index"); } return RedirectToAction("Index"); }
public static ContentVersionRepository CreateVersionRepository(ref IPersister persister, ref ContentActivator activator, ref IRepository <ContentVersion> versionRepository, params Type[] definedTypes) { if (persister == null) { persister = SetupFakePersister(); } var definitions = SetupDefinitions(definedTypes); var parser = new UrlParser(persister, new ThreadContext(), new Host(new ThreadContext(), new HostSection()), new ConnectionMonitor(), new HostSection()); var proxyFactory = new InterceptingProxyFactory(); if (activator == null) { activator = new ContentActivator(new StateChanger(), new ItemNotifier(), proxyFactory); activator.Initialize(definitions.GetDefinitions()); } if (versionRepository == null) { versionRepository = new FakeRepository <ContentVersion>(); } var importer = new Importer(persister, new ItemXmlReader(definitions, activator, persister.Repository), new Fakes.FakeMemoryFileSystem()); var exporter = new Exporter( new ItemXmlWriter( definitions, parser, new FakeMemoryFileSystem())); return(new ContentVersionRepository( versionRepository, exporter, importer, parser, proxyFactory)); }
internal void Run() { var target = Context.TargetModule; if (_source.HasResources) { foreach (var r in _source.Resources) { if (r is LinkedResource lr && Context.MappedResources.TryGetValue(DnextFactory.NewTypeKey(_source, r), out var mapping) && mapping.Target is LinkedResource tlr && tlr.File == lr.File) { tlr.File = Clone(lr.File); } } } if (_source == Context.MainSourceModule) { if (_source.Win32Resources != null) { target.Win32Resources = _source.Win32Resources; } var sourceAssembly = _source.Assembly; var targetAssembly = target.Assembly; CopyCustomAttributes(_source, target); CopyCustomAttributes(sourceAssembly, targetAssembly); CopyCustomDebugInfo(_source, target); CopyCustomDebugInfo(sourceAssembly, targetAssembly); CopyDeclSecurities(sourceAssembly, targetAssembly); if (_source.IsEntryPointValid) { target.EntryPoint = Importer.Import(_source.EntryPoint).ResolveMethodDef(); } } }
public void StandardExportInterfacesShouldWork() { // Export all interfaces except IDisposable, Export contracts on types without interfaces. except for disposable types var builder = new ConventionBuilder(); builder.ForTypesMatching((t) => true).ExportInterfaces(); builder.ForTypesMatching((t) => t.GetTypeInfo().ImplementedInterfaces.Where((iface) => iface != typeof(System.IDisposable)).Count() == 0).Export(); var container = new ContainerConfiguration() .WithPart <Standard>(builder) .WithPart <Dippy>(builder) .WithPart <Derived>(builder) .WithPart <BareClass>(builder) .CreateContainer(); var importer = new Importer(); container.SatisfyImports(importer); Assert.IsNotNull(importer.First); Assert.IsTrue(importer.First.Count() == 3); Assert.IsNotNull(importer.Second); Assert.IsTrue(importer.Second.Count() == 3); Assert.IsNotNull(importer.Third); Assert.IsTrue(importer.Third.Count() == 3); Assert.IsNotNull(importer.Fourth); Assert.IsTrue(importer.Fourth.Count() == 3); Assert.IsNotNull(importer.Fifth); Assert.IsTrue(importer.Fifth.Count() == 3); Assert.IsNull(importer.Base); Assert.IsNull(importer.Derived); Assert.IsNull(importer.Dippy); Assert.IsNull(importer.Standard); Assert.IsNull(importer.Disposable); Assert.IsNotNull(importer.BareClass); }
public void StandardExportInterfacesInterfaceFilterDefaultContractShouldWork() { //Same test as above only using default export builder var builder = new ConventionBuilder(); builder.ForTypesMatching((t) => true).ExportInterfaces((iface) => iface != typeof(System.IDisposable)); builder.ForTypesMatching((t) => t.GetTypeInfo().ImplementedInterfaces.Where((iface) => iface != typeof(System.IDisposable)).Count() == 0).Export(); var container = new ContainerConfiguration() .WithPart <Standard>(builder) .WithPart <Dippy>(builder) .WithPart <Derived>(builder) .WithPart <BareClass>(builder) .CreateContainer(); var importer = new Importer(); container.SatisfyImports(importer); Assert.NotNull(importer.First); Assert.True(importer.First.Count() == 3); Assert.NotNull(importer.Second); Assert.True(importer.Second.Count() == 3); Assert.NotNull(importer.Third); Assert.True(importer.Third.Count() == 3); Assert.NotNull(importer.Fourth); Assert.True(importer.Fourth.Count() == 3); Assert.NotNull(importer.Fifth); Assert.True(importer.Fifth.Count() == 3); Assert.Null(importer.Base); Assert.Null(importer.Derived); Assert.Null(importer.Dippy); Assert.Null(importer.Standard); Assert.Null(importer.Disposable); Assert.NotNull(importer.BareClass); }
public void InitializeAssimp() { var flags = (ppsteps | aiPostProcessSteps.aiProcess_GenSmoothNormals | // generate smooth normal vectors if not existing aiPostProcessSteps.aiProcess_SplitLargeMeshes | // split large, unrenderable meshes into submeshes aiPostProcessSteps.aiProcess_Triangulate | // triangulate polygons with more than 3 edges aiPostProcessSteps.aiProcess_ConvertToLeftHanded | // convert everything to D3D left handed space aiPostProcessSteps.aiProcess_SortByPType | // make 'clean' meshes which consist of a single typ of primitives (aiPostProcessSteps)0); // default model var path = "../../../../../../test/models/3DS/test1.3ds"; importer = new Importer(); string[] args = Environment.GetCommandLineArgs(); if (args.Length > 1) { path = args[1]; } //var path = "man.3ds"; scene = importer.ReadFile(path, flags); if (scene != null) { directory = Path.GetDirectoryName(path); CacheMaterials(scene.mMaterials); CacheMeshes(scene.mMeshes); SetupCamera(scene.mCameras); } else { MessageBox.Show("Failed to open file: " + path + ". Either Assimp screwed up or the path is not valid."); Application.Exit(); } }
public string ImporterToString(Importer imp) { if (imp == Importer.Wav) { return("WawImporter"); } if (imp == Importer.Effect) { return("EffectImporter"); } if (imp == Importer.Font) { return("FontDescriptionImporter"); } if (imp == Importer.Texture) { return("TextureImporter"); } return("[UnknownImporter]"); }
private void DoImport() { XmlDocument doc = GetMindMapFromUser(); if (doc == null) { return; } var imp = new Importer(doc, _fb); ImportAnalysis results = imp.Analyze(); if (results.NothingToDo) { MessageBox.Show(@"No changes were detected. Nothing to import.", @"Import Mind Map", MessageBoxButtons.OK, MessageBoxIcon.Information); return; } var dlg = new ImportConfirmationDlg(results); if (dlg.ShowDialog() == DialogResult.Yes) { foreach (Case c in results.CaseToNewParent.Keys) { try { _fb.SetParent(c, results.CaseToNewParent[c].ID); } catch (Exception x) { Utils.LogError(x.ToString()); } } } }
static void Main(string[] args) { try { var specParser = new SpecParser(); var errorCount = 0; string outputFile = args[1] + ".output.csv"; using (var sr = new StreamReader(args[0])) using (var data = new FileStream(args[1], FileMode.Open, FileAccess.Read)) using (var output = new StreamWriter(args[1] + ".output.csv")) { var importer = new Importer(specParser.Parse(sr)); var listener = new CsvOutputListener(output); importer.Import(data, listener); listener.Task.Wait(); errorCount = listener.Errors; } if (errorCount > 0) { File.Delete(outputFile); WriteLine("No output created."); } else { WriteLine($"Output in in \"{outputFile}\""); } } catch (Exception ex) { WriteLine($"Error: {ex.Message}"); } #if DEBUG WriteLine("Press any key to continue"); ReadKey(); #endif }
private void ImportResourcesTest(string fileNameInCloud, Dictionary <string, string> settings) { Trace.WriteLine($"Processing {fileNameInCloud}."); string baseResourcePath = "resource"; using (ShimsContext.Create()) { ShiminRiverContext.AllInstances.SettingsGet = settingsGet => settings; ShiminRiverContext.AllInstances.LogLogLevelString = (cx, logLevel, message) => { Trace.WriteLine($"{logLevel.ToString().ToUpper().PadRight(12, ' ')} {message}"); }; ShiminRiverContext context = new ShiminRiverContext(); //Act Importer importer = new Importer(context); importer.ImportResources(fileNameInCloud, baseResourcePath, string.Empty); //Assert } }
private void WorkerRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { //change cursor back Cursor = Cursors.Arrow; //unsubscribe from the importer's progress updates _importer.OnProgressUpdate -= ImportStatusUpdate; if (e.Error != null) { //MessageBox.Show(string.Format("An error prevented the job from executing: {0}", e.Error.Message), "Fatal job error", MessageBoxButton.OK, MessageBoxImage.Error); JobError errorbox = new JobError(); errorbox.SetDetails(string.Format("An error prevented the job from executing: {0}", e.Error.Message), e.Error.ToString()); errorbox.Owner = this; errorbox.ShowDialog(); } else { int errorCount = _importer.ErrorCount; _importer = null; //clear the status label ImportStatusUpdate(""); //show a message to the user if (errorCount == 0) { MessageBox.Show("Job finished with no errors.", "Success", MessageBoxButton.OK, MessageBoxImage.Information); } else { MessageBox.Show("Job finished with errors. See the RecordError.log file for more details.", "Import errors", MessageBoxButton.OK, MessageBoxImage.Error); } } }
private bool HandleUnassignedThreat(IThreatModel target, Threat threat, IThreatType threatType, IPropertySchema schema) { bool result = false; using (var dialog = new ThreatAssignmentDialog(target)) { dialog.Initialize(threat.ToString(), threat.GetValueFromLabel("Description")); if (dialog.ShowDialog(Form.ActiveForm) == DialogResult.OK) { var identity = dialog.SelectedIdentity; if (identity != null) { if (identity is IEntity entity) { var threatEvent = entity.AddThreatEvent(threatType); if (threatEvent != null) { Importer.AddProperties(threatEvent, threat, schema); result = true; } } else if (identity is IDataFlow dataFlow) { var threatEvent = dataFlow.AddThreatEvent(threatType); if (threatEvent != null) { Importer.AddProperties(threatEvent, threat, schema); result = true; } } } } } return(result); }
private Dictionary <GroupInfo, List <UserInfo> > GetGroupsUsers(List <GroupInfo> ldapGroups, out List <UserInfo> uniqueLdapGroupUsers) { uniqueLdapGroupUsers = new List <UserInfo>(); var listGroupsUsers = new Dictionary <GroupInfo, List <UserInfo> >(); foreach (var ldapGroup in ldapGroups) { var ldapGroupUsers = Importer.GetGroupUsers(ldapGroup); listGroupsUsers.Add(ldapGroup, ldapGroupUsers); foreach (var ldapGroupUser in ldapGroupUsers) { if (!uniqueLdapGroupUsers.Any(u => u.Sid.Equals(ldapGroupUser.Sid))) { uniqueLdapGroupUsers.Add(ldapGroupUser); } } } return(listGroupsUsers); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void letImporterDecideAboutDatabaseExistence() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void LetImporterDecideAboutDatabaseExistence() { File report = _testDir.file("report"); Path homeDir = _testDir.directory("home").toPath(); PrintStream nullOutput = new PrintStream(NULL_OUTPUT_STREAM); OutsideWorld outsideWorld = new RealOutsideWorld(nullOutput, nullOutput, new MemoryStream(new sbyte[0])); Path confPath = _testDir.directory("conf").toPath(); ImportCommand importCommand = new ImportCommand(homeDir, confPath, outsideWorld); File nodesFile = CreateTextFile("nodes.csv", ":ID", "1", "2"); string[] arguments = new string[] { "--mode=csv", "--database=existing.db", "--nodes=" + nodesFile.AbsolutePath, "--report-file=" + report.AbsolutePath }; // First run an import so that a database gets created importCommand.Execute(arguments); // When ImporterFactory importerFactory = mock(typeof(ImporterFactory)); Importer importer = mock(typeof(Importer)); when(importerFactory.GetImporterForMode(any(), any(), any(), any())).thenReturn(importer); (new ImportCommand(homeDir, confPath, outsideWorld, importerFactory)).Execute(arguments); // Then no exception about database existence should be thrown }
public async Task <Guid> HandleAsync(SetImporterForNotification message) { var country = await context.Countries.SingleAsync(c => c.Id == message.Address.CountryId); var business = ValueObjectInitializer.CreateBusiness(message.Business); var address = ValueObjectInitializer.CreateAddress(message.Address, country.Name); var contact = ValueObjectInitializer.CreateContact(message.Contact); var importer = await repository.GetImporterOrDefaultByNotificationId(message.NotificationId); if (importer == null) { importer = new Importer(message.NotificationId, address, business, contact); repository.Add(importer); } else { importer.Update(address, business, contact); } await context.SaveChangesAsync(); return(importer.Id); }
public void LoadModel(string fileName) { var dialogViewModel = new DialogViewModel(); HelixToolkitScene scene = null; dialogViewModel.AddTask ( (taskContext) => { taskContext.UpdateMessage($"Loading model {Path.GetFileNameWithoutExtension(fileName)}"); var loader = new Importer(); scene = loader.Load(fileName); taskContext.UpdateProgress(100); } ); this.windowManager.ShowDialog(dialogViewModel); GroupModel.Clear(); if (scene != null) { this.sceneNode = scene.Root; GroupModel.AddNode(this.sceneNode); this.SetSceneMaterials(); } }
public void ImporterTests_ShortcutsWork() { string oldXml = "<folder version=\"36\" creator=\"Apsim 7.5-r3183\" name=\"simulations\">" + " <folder name=\"shared\">" + " <clock>" + " <start_date type=\"date\" description=\"Enter the start date of the simulation\">01/01/1940</start_date>" + " <end_date type=\"date\" description=\"Enter the end date of the simulation\">31/12/1950</end_date> " + " </clock>" + " </folder>" + " <simulation name=\"Continuous Wheat\">" + " <clock shortcut=\"/simulations/shared/Clock\">" + " </clock>" + " </simulation>" + "</folder>"; var importer = new Importer(); Simulations sims = importer.CreateSimulationsFromXml(oldXml); Clock c = sims.Children[1].Children[0] as Clock; Assert.AreEqual(c.StartDate, new DateTime(1940, 1, 1)); Assert.AreEqual(c.EndDate, new DateTime(1950, 12, 31)); }
public static void Import(XdImportSettings xdSettings, string[] xdFilePaths) { var stopWatch = Stopwatch.StartNew(); Logger = new AkyuiLogger("Akyui.Xd", xdSettings.LogType); var loaders = new List <IAkyuiLoader>(); Settings = xdSettings; using (Disposable.Create(() => Settings = null)) using (var progressBar = new AkyuiProgressBar("Akyui.Xd")) { progressBar.SetTotal(xdFilePaths.Length); foreach (var xdFilePath in xdFilePaths) { using (var progress = progressBar.TaskStart(Path.GetFileName(xdFilePath))) using (Logger.SetCategory(Path.GetFileName(xdFilePath))) { var(imported, skipped) = ImportedArtboards(xdSettings, Logger, xdFilePath, progress, loaders); if (imported == 0 && skipped == 0) { Logger.Warning($"The artboard to be imported was not found. Please set Mark for Export."); } } } } Importer.Import(xdSettings, loaders.ToArray()); ExportAkyui(xdSettings, loaders, Logger); foreach (var loader in loaders) { loader.Dispose(); } Logger.Log($"Xd Import Finish", ("Time", $"{stopWatch.Elapsed.TotalSeconds:0.00}s")); Logger = null; }
public void ImportCsv_ConversionRequired_ConverterSpecified_ImportSuccess() { // arrange var uut = new Importer(); // act var testFile = Path.Combine(TestContext.CurrentContext.TestDirectory, @"Data\TestDataCurrency.csv"); var data = uut.ImportCsv <TestDataStructure, TestDataStructureClassMap>(testFile).ToArray(); // assert Assert.AreEqual(4, data.Length); Assert.AreEqual("Alice", data[0].Name); Assert.AreEqual(100.0, data[0].Value); Assert.AreEqual("Bob", data[1].Name); Assert.AreEqual(20.0, data[1].Value); Assert.AreEqual("Charlotte", data[2].Name); Assert.AreEqual(45.0, data[2].Value); Assert.AreEqual("Dean", data[3].Name); Assert.AreEqual(89.7, data[3].Value); }
private void Import(Importer importer, IImportRecord record) { try { if (pnlNewName.Visible) { record.RootItem.Name = txtNewName.Text; } if (chkSkipRoot.Checked) { importer.Import(record, Selection.SelectedItem, ImportOption.Children); Refresh(Selection.SelectedItem, ToolbarArea.Both); } else { importer.Import(record, Selection.SelectedItem, ImportOption.All); Refresh(record.RootItem, ToolbarArea.Both); } ShowErrors(record); } catch (N2Exception ex) { cvImport.ErrorMessage = ex.Message; cvImport.IsValid = false; btnImportUploaded.Enabled = false; } finally { if (File.Exists(UploadedFilePath)) { File.Delete(UploadedFilePath); } } }
private static int[] GetAge(Image <Bgr, byte> face) { try { if (!isNetAgePopulated) { importerAge.PopulateNet(netAge); isNetAgePopulated = true; importerAge = null; } Blob inputBlob = new Blob(face.Resize(227, 227, Emgu.CV.CvEnum.Inter.Cubic)); lock (netAge) { netAge.SetBlob(".data", inputBlob); netAge.Forward(); Blob prob = netAge.GetBlob("prob"); int[] outData = new int[2]; GetMaxClass(prob, out outData[0], out outData[1]); inputBlob.Dispose(); prob.Dispose(); return(outData); } } catch { return(new int[0]); } }
public static void StructGenerator(MethodDef method, ref int i) { ITypeDefOrRef valueTypeRef = new Importer(method.Module).Import(typeof(System.ValueType)); TypeDef structDef = new TypeDefUser(Guid.NewGuid().ToString(), valueTypeRef); Tuple <TypeDef, int> outTuple; structDef.ClassLayout = new ClassLayoutUser(1, 0); structDef.Attributes |= TypeAttributes.Sealed | TypeAttributes.SequentialLayout | TypeAttributes.Public; List <Type> retList = new List <Type>(); int rand = rndsizevalues[rnd.Next(0, 6)]; retList.Add(GetType(rand)); retList.ForEach(x => structDef.Fields.Add(new FieldDefUser(Guid.NewGuid().ToString(), new FieldSig(new Importer(method.Module).Import(x).ToTypeSig()), FieldAttributes.Public))); int operand = method.Body.Instructions[i].GetLdcI4Value(); if (abc < 25) { method.Module.Types.Add(structDef); Dick.Add(abc++, new Tuple <TypeDef, int>(structDef, rand)); int conta = operand - rand; method.Body.Instructions[i].Operand = conta; method.Body.Instructions[i].OpCode = OpCodes.Ldc_I4; method.Body.Instructions.Insert(i + 1, Instruction.Create(OpCodes.Sizeof, structDef)); method.Body.Instructions.Insert(i + 2, Instruction.Create(OpCodes.Add)); } else { Dick.TryGetValue(rnd.Next(1, 24), out outTuple); int conta = operand - outTuple.Item2; method.Body.Instructions[i].Operand = conta; method.Body.Instructions[i].OpCode = OpCodes.Ldc_I4; method.Body.Instructions.Insert(i + 1, Instruction.Create(OpCodes.Sizeof, outTuple.Item1)); method.Body.Instructions.Insert(i + 2, Instruction.Create(OpCodes.Add)); } i += 2; }
// Import Button private void button5_Click(object sender, RoutedEventArgs e) { OpenFileDialog fileDialog = new OpenFileDialog(); fileDialog.Filter = "csv files (*.csv)|*.csv"; Nullable <bool> result = fileDialog.ShowDialog(); if (result == true) { string path = fileDialog.FileName; bool importResult = Importer.ImportArticleFromCsv(db, path); if (importResult) { MessageBox.Show("Artikel wurden importiert", "", MessageBoxButton.OK, MessageBoxImage.Information); } else { MessageBox.Show("Beim Importieren trat ein Fehler auf", "", MessageBoxButton.OK, MessageBoxImage.Error); } } updateGrid(); }
public void Preprocess() { preprocessThread = new Thread(() => { sw.Start(); Importer.CreateLog(); Importer.WriteLog("salam"); Importer importer = new Importer(); importer.ReadFiles(); DatabaseController.Instance.WriteTokensToDatabase(); DatabaseController.Instance.writer.Wait(); DatabaseController.Instance.CreateIndex(); sw.Stop(); preprocessTime = sw.ElapsedMilliseconds; }); preprocessThread.Start(); }
private void WorkerRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { //change cursor back Cursor = Cursors.Default; //unsubscribe from the importer's progress updates _importer.OnProgressUpdate -= ImportStatusUpdate; int errorCount = _importer.ErrorCount; _importer = null; //clear the status label ImportStatusUpdate(""); //show a message to the user if (errorCount == 0) { MessageBox.Show("Job finished with no errors."); } else { MessageBox.Show("Job finished with errors. See the RecordError.log file for more details."); } }
public static void LoadSavedSchemaInto(ISchemaProvider provider, IZetboxContext targetCtx) { if (provider == null) { throw new ArgumentNullException("provider"); } if (targetCtx == null) { throw new ArgumentNullException("targetCtx"); } string schema = provider.GetSavedSchema().TrimEnd((char)0); // Trim possible C++/Database/whatever ending 0 char if (!string.IsNullOrEmpty(schema)) { // Migration from Kist -> Zetbox schema = schema.Replace("Kistl", "Zetbox"); using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(schema))) { Importer.LoadFromXml(targetCtx, ms, "saved schema from " + provider.GetSafeConnectionString()); } } }
public static void Import(string excelFolder) { Gems = new Dictionary <string, Gem>(); var table = Importer.ReadTxtFileToDictionaryList(excelFolder + "/Gems.txt"); foreach (var row in table) { var numMods = Utility.ToNullableInt(row["nummods"]); if (!numMods.HasValue) { ExceptionHandler.LogException(new Exception($"Invalid nummods for '{row["name"]}' in Gems.txt")); } var gem = new Gem { Index = row["name"], Letter = row["letter"], Code = row["code"], NumMods = numMods.Value, }; // Add the properties var propList = new List <PropertyInfo>(); for (int i = 1; i <= 3; i++) { propList.Add(new PropertyInfo(row[$"weaponMod{i}Code"], row[$"weaponMod{i}Param"], row[$"weaponMod{i}Min"], row[$"weaponMod{i}Max"])); } try { var properties = ItemProperty.GetProperties(propList).OrderByDescending(x => x.ItemStatCost == null ? 0 : x.ItemStatCost.DescriptionPriority).ToList(); gem.WeaponProperties = properties; } catch (Exception e) { ExceptionHandler.LogException(new Exception($"Could not get weapon properties for gem '{gem.Index}' in Gems.txt", e)); } // Add the properties propList = new List <PropertyInfo>(); for (int i = 1; i <= 3; i++) { propList.Add(new PropertyInfo(row[$"helmMod{i}Code"], row[$"helmMod{i}Param"], row[$"helmMod{i}Min"], row[$"helmMod{i}Max"])); } try { var properties = ItemProperty.GetProperties(propList).OrderByDescending(x => x.ItemStatCost == null ? 0 : x.ItemStatCost.DescriptionPriority).ToList(); gem.HelmProperties = properties; } catch (Exception e) { ExceptionHandler.LogException(new Exception($"Could not get helm properties for gem '{gem.Index}' in Gems.txt", e)); } // Add the properties propList = new List <PropertyInfo>(); for (int i = 1; i <= 3; i++) { propList.Add(new PropertyInfo(row[$"shieldMod{i}Code"], row[$"shieldMod{i}Param"], row[$"shieldMod{i}Min"], row[$"shieldMod{i}Max"])); } try { var properties = ItemProperty.GetProperties(propList).OrderByDescending(x => x.ItemStatCost == null ? 0 : x.ItemStatCost.DescriptionPriority).ToList(); gem.ShieldProperties = properties; } catch (Exception e) { ExceptionHandler.LogException(new Exception($"Could not get shield properties for gem '{gem.Index}' in Gems.txt", e)); } Gems[gem.Index] = gem; } }
/// <summary> /// Link in the new created document to parent document. /// </summary> /// <param name="baseFileName">The full path to the IFC file.</param> /// <param name="ifcDocument">The newly imported IFC file document.</param> /// <param name="originalDocument">The document to contain the IFC link.</param> /// <param name="useExistingType">True if the RevitLinkType already exists.</param> /// <param name="doSave">True if we should save the document. This should only be false if we are reusing a cached document.</param> /// <returns>The element id of the RevitLinkType for this link operation.</returns> public static ElementId LinkInFile(string baseFileName, Document ifcDocument, Document originalDocument, bool useExistingType, bool doSave) { bool saveSucceded = true; string fileName = GenerateRevitFileName(baseFileName); if (doSave) { SaveAsOptions saveAsOptions = new SaveAsOptions(); saveAsOptions.OverwriteExistingFile = true; try { ifcDocument.SaveAs(fileName, saveAsOptions); } catch (Exception ex) { // We still want to close the document to prevent having a corrupt model in memory. Importer.TheLog.LogError(-1, ex.Message, false); saveSucceded = false; } } if (!ifcDocument.IsLinked) { ifcDocument.Close(false); } ElementId revitLinkTypeId = ElementId.InvalidElementId; if (!saveSucceded) { return(revitLinkTypeId); } bool doReloadFrom = useExistingType && !Importer.TheOptions.CreateLinkInstanceOnly; if (Importer.TheOptions.RevitLinkFileName != null) { FilePath originalRevitFilePath = new FilePath(Importer.TheOptions.RevitLinkFileName); revitLinkTypeId = RevitLinkType.GetTopLevelLink(originalDocument, originalRevitFilePath); } if (!doReloadFrom) { Transaction linkTransaction = new Transaction(originalDocument); linkTransaction.Start(Resources.IFCLinkFile); try { if (revitLinkTypeId == ElementId.InvalidElementId) { RevitLinkOptions options = new RevitLinkOptions(true); RevitLinkLoadResult loadResult = RevitLinkType.CreateFromIFC(originalDocument, baseFileName, fileName, false, options); if ((loadResult != null) && (loadResult.ElementId != ElementId.InvalidElementId)) { revitLinkTypeId = loadResult.ElementId; } } if (revitLinkTypeId != ElementId.InvalidElementId) { RevitLinkInstance.Create(originalDocument, revitLinkTypeId); } Importer.PostDelayedLinkErrors(originalDocument); linkTransaction.Commit(); } catch (Exception ex) { linkTransaction.RollBack(); throw ex; } } else // reload from { // For the reload from case, we expect the transaction to have been created in the UI. if (revitLinkTypeId != ElementId.InvalidElementId) { RevitLinkType existingRevitLinkType = originalDocument.GetElement(revitLinkTypeId) as RevitLinkType; if (existingRevitLinkType != null) { existingRevitLinkType.UpdateFromIFC(originalDocument, baseFileName, fileName, false); } } } return(revitLinkTypeId); }
public void TestThatImporterThrowsCorruptedFileExceptionOnWrongImageFileWithSupportedExtension(string fileName) { string imagePath = $"{Environment.CurrentDirectory}\\..\\..\\..\\ModelsTests\\IO\\{fileName}"; Assert.Throws <CorruptedFileException>(() => { Importer.ImportSurface(imagePath); }); }
public void TestThatImporterThrowsCorruptedFileExceptionOnWrongPixiFileWithSupportedExtension() { Assert.Throws <CorruptedFileException>(() => { Importer.ImportDocument(testCorruptedPixiImagePath); }); }
public void TestThatIsSupportedFile(string file) { Assert.True(Importer.IsSupportedFile(file)); }
public void InitializeAssimp() { var flags = ( ppsteps | aiPostProcessSteps.aiProcess_GenSmoothNormals | // generate smooth normal vectors if not existing aiPostProcessSteps.aiProcess_SplitLargeMeshes | // split large, unrenderable meshes into submeshes aiPostProcessSteps.aiProcess_Triangulate | // triangulate polygons with more than 3 edges aiPostProcessSteps.aiProcess_ConvertToLeftHanded | // convert everything to D3D left handed space aiPostProcessSteps.aiProcess_SortByPType | // make 'clean' meshes which consist of a single typ of primitives (aiPostProcessSteps)0); // default model var path = "../../../../../../test/models/3DS/test1.3ds"; importer = new Importer(); string[] args = Environment.GetCommandLineArgs(); if (args.Length > 1) { path = args[1]; } //var path = "man.3ds"; scene = importer.ReadFile(path, flags); if (scene != null) { directory = Path.GetDirectoryName(path); CacheMaterials(scene.mMaterials); CacheMeshes(scene.mMeshes); SetupCamera(scene.mCameras); } else { MessageBox.Show("Failed to open file: " + path + ". Either Assimp screwed up or the path is not valid."); Application.Exit(); } }