private ImportResult ImportFileThread(bool isTest) { DataImporter.ContentImporting += OnContentImporting; DataImporter.FileImporting += OnFileImporting; DataImporter dataImporter = new DataImporter(); dataImporter.Stream = new FileStream("e:\\temp\\SampleAssets.episerverdata", FileMode.Open); dataImporter.IsTest = false; dataImporter.DestinationRoot = ContentReference.GlobalBlockFolder; // .StartPage; dataImporter.KeepIdentity = true; // dataImporter.ContinueOnError = true; dataImporter.AutoCloseStream = true; dataImporter.IsTest = isTest; dataImporter.TransferType = TypeOfTransfer.Importing; dataImporter.Import(); ImportResult result = new ImportResult(); result.Errors = dataImporter.Log.Errors; result.Warnings = dataImporter.Log.Warnings; DataImporter.ContentImporting -= OnContentImporting; DataImporter.FileImporting -= OnFileImporting; return(result); }
/// <summary> /// After the page is imported /// </summary> public void DataImporter_ContentImported(DataImporter dataImported, ContentImportedEventArgs e) { PageData page = null; if (!ContentReference.IsNullOrEmpty(e.ContentLink)) { page = DataFactory.Instance.Get <PageData>(e.ContentLink).CreateWritableClone(); } if (page == null) { return; } page["PageSaved"] = _originalValues.PageSaved; page["PageChanged"] = _originalValues.PageChanged; page["PageChangedBy"] = _originalValues.PageChangedBy; page["PageCreatedBy"] = _originalValues.PageCreatedBy; page["PageChangedOnPublish"] = true; PrincipalInfo.CurrentPrincipal = PrincipalInfo.CreatePrincipal(_originalValues.PageChangedBy); try { global::EPiServer.BaseLibrary.Context.Current["PageSaveDB:PageSaved"] = true; DataFactory.Instance.Save(page, SaveAction.ForceCurrentVersion | SaveAction.Publish | SaveAction.SkipValidation, AccessLevel.NoAccess); } finally { global::EPiServer.BaseLibrary.Context.Current["PageSaveDB:PageSaved"] = null; } MigrationHook.Invoke(new AfterPageImportEvent(e), Log); }
public ActionResult ImportDefects() { DataImporter importer = new DataImporter(); importer.ImportDefect(Server.MapPath("~/App_Data/QueryResult.xls")); return(RedirectToAction("Index")); }
public ActionResult TemperatureChart() { var dataImporter = new DataImporter(); var filteredRecords = dataImporter.Import(); // DATA VISUALIZATION var timestamp = filteredRecords.Select(v => v.Timestamp); var tempForward = filteredRecords.Select(v => double.Parse(v.TempForward, CultureInfo.InvariantCulture)); var tempReturn = filteredRecords.Select(v => double.Parse(v.TempReturn, CultureInfo.InvariantCulture)); var energy = filteredRecords.Select(v => double.Parse(v.Energy, CultureInfo.InvariantCulture)); var tempDiff = filteredRecords.Select(v => double.Parse(v.TempDiff, CultureInfo.InvariantCulture)); new Chart(width: 1000, height: 300, ChartTheme.Blue) .AddTitle("Temperatures Chart") .AddSeries( chartType: "line", xValue: timestamp.ToArray(), yValues: tempReturn.ToArray(), name: "Temp Return") .AddSeries( chartType: "line", xValue: timestamp.ToArray(), yValues: tempForward.ToArray(), name: "Temp Forward") .AddLegend() .SetYAxis(min: 0.0, max: 85) .Write("png"); return(null); }
// Methods public NotificationXtraForm() { this.components = null; this.InitializeComponent(); importer = Program.Kernel.Get <DataImporter>(); importer.OnConflict += importer_OnConflict; }
// Methods public NotificationXtraForm() { this.components = null; this.InitializeComponent(); importer = Program.Kernel.Get<DataImporter>(); importer.OnConflict += importer_OnConflict; }
public void DataImportTest_vrp() { // Arrange DataImporter dataImporter = new DataImporter(); // Act // Parse vrp file and create DepotManager dataImporter.ImportFromFile(@".\A-n37-k6.vrp"); // Get DepotManager from DataImporter DepotManager dm = dataImporter.GetManager(); // Assert Assert.AreEqual(86, dm.GetClient(0).Position.X); Assert.AreEqual(22, dm.GetClient(0).Position.Y); Assert.AreEqual(0, dm.GetClient(0).Demande); Assert.AreEqual(29, dm.GetClient(1).Position.X); Assert.AreEqual(17, dm.GetClient(1).Position.Y); Assert.AreEqual(1, dm.GetClient(1).Demande); Assert.AreEqual(54, dm.GetClient(17).Position.X); Assert.AreEqual(39, dm.GetClient(17).Position.Y); Assert.AreEqual(14, dm.GetClient(17).Demande); Assert.AreEqual(83, dm.GetClient(35).Position.X); Assert.AreEqual(74, dm.GetClient(35).Position.Y); Assert.AreEqual(66, dm.GetClient(35).Demande); Assert.AreEqual(84, dm.GetClient(36).Position.X); Assert.AreEqual(2, dm.GetClient(36).Position.Y); Assert.AreEqual(21, dm.GetClient(36).Demande); }
public static DataTable AggregrateSoundData(DataTable dt_in, string emtpytable) { //DataTable dt = new DataTable(); var aggdata = from x in dt_in.AsEnumerable() group x by new { id = x.Field <string>("id"), studymeasid = x.Field <int>("studymeasid"), indexnum = x.Field <int>("indexnum"), senvs_datetime = x.Field <DateTime>("senvs_datetime"), } into g select new { id = g.Min(h => h.Field <string>("id")), studymeasid = g.Min(h => h.Field <int>("studymeasid")), indexnum = g.Min(h => h.Field <int>("indexnum")), senvs_datetime = g.Min(h => h.Field <DateTime>("senvs_datetime")), senvs_dbmin = g.Min(h => h.Field <double>("senvs_db")), senvs_db = g.Max(h => h.Field <double>("senvs_db")), senvs_dbsd = Math.Round(g.StdDev(h => h.Field <double>("senvs_db")), 4), }; DataTable dt_out = aggdata.CustomCopyToDataTable(); DataTable dt_empty = DataImporter.EmptyDataTable(emtpytable); dt_out.AddEmptyColumns(dt_empty); return(dt_out); }
public static void Main(string[] args) { var participants = Participant.Generate(100000, 100000, CompanyId).ToArray(); var actionBatchBlock = new BatchBlock <ActionParticipant>(7500); var insertActionParticipants = new ActionBlock <ActionParticipant[]>(items => { var bulkInsertAsync = DataImporter.BulkInsertAsync(items); Inserted += items.Length; Console.WriteLine($"Inserted {Inserted} out of { ActionCount}"); return(bulkInsertAsync); }); actionBatchBlock.LinkTo(insertActionParticipants); actionBatchBlock.Completion.ContinueWith(delegate { insertActionParticipants.Complete(); }); foreach (var actionParticipant in ActionParticipant.Generate(participants, ActionCount, 30000, CompanyId)) { actionBatchBlock.Post(actionParticipant); } actionBatchBlock.Complete(); insertActionParticipants.Completion.Wait(); }
public virtual void ImportContent(string packagePath, IMigrationLog logger) { logger.Log("Import package path: {0}", packagePath); logger.Log("Import root page: {0}", _importRoot); _importEvents.Log = logger; var assetMigrator = new AssetMigrator(_importRoot).Init(); var importer = new DataImporter(); if (string.IsNullOrEmpty(packagePath)) { logger.Log("ERROR: PackagePath must be set"); throw new ArgumentException("PackagePath must be set"); } DataImporter.ContentImporting += _importEvents.DataImporter_ContentImporting; DataImporter.ContentImported += _importEvents.DataImporter_ContentImported; DataImporter.FileImported += _importEvents.DataImporter_FileImported; DataImporter.FileImporting += _importEvents.DataImporter_FileImporting; try { logger.Log("Opening package"); using (var fs = new FileStream(packagePath, FileMode.Open, FileAccess.Read)) { importer.Stream = fs; importer.IsTest = false; importer.DestinationRoot = _importRoot; importer.KeepIdentity = false; logger.Log("Executing import"); importer.Import(); } } catch (Exception e) { logger.Log("Error executing export {0}", e); throw; } finally { DataImporter.ContentImporting -= _importEvents.DataImporter_ContentImporting; DataImporter.ContentImported -= _importEvents.DataImporter_ContentImported; DataImporter.FileImported -= _importEvents.DataImporter_FileImported; DataImporter.FileImporting -= _importEvents.DataImporter_FileImporting; } logger.Log("Import done"); logger.Log("Imported pages: {0}", importer.Log.Status.GetInformationLog(StatusInfo.StatusInfoAction.Imported).Count); logger.Log("Imported files: {0}", importer.Log.CountHandledFiles); logger.Log("Moving imported assets to site assets"); assetMigrator.MoveAssetsToSite(); logger.Log("Assets moved"); logger.Log("-- Import errors --"); foreach (var error in importer.Log.Errors) { logger.Log(error); } logger.Log("-- Import warnings --"); foreach (var warning in importer.Log.Warnings) { logger.Log(warning); } }
/// <summary> /// Execute this step. /// </summary> protected override void ExecuteMain() { StringBuilder sb = new StringBuilder(); try { this.Status = StepStatusEnum.Executing; bool success = true; Impersonator impersonator = new Impersonator( Properties.Settings.Default.DomainUserName, Properties.Settings.Default.Domain, Properties.Settings.Default.DomainPassword ); DataImporter importer = new DataImporter(); success = importer.DoSequence(Properties.Settings.Default.DataImporter_IsContinueRun); if (success) { if (importer.Exceptions == null || importer.Exceptions.Count <= 0) { if (importer.TargetDataFileInfoList.Count > 0) { this.Status = StepStatusEnum.Pass; this.ResultDetail = new StepResultDetail("Successfully imported data into databases. Total data file(s) processed: {0}".FormatWith(importer.TargetDataFileInfoList.Count)); } else { this.Status = StepStatusEnum.Warning; this.ResultDetail = new StepResultDetail("This step didn't meet any error, however, no data file has been found under the specified path '{0}' or '{1}'.".FormatWith(Microsoft.Scs.Test.RiskTools.RulePerf.Properties.Settings.Default.BedTransferFolder, Properties.Settings.Default.DataImporter_DataDirectory)); } } else { this.Status = StepStatusEnum.Failed; this.ResultDetail = new StepResultDetail("Met errors during importing. Total data file(s) processed: {0}".FormatWith(importer.TargetDataFileInfoList.Count), importer.Exceptions); } } else { this.Status = StepStatusEnum.Failed; this.ResultDetail = new StepResultDetail("Importing data failed. Please check logs for more detailed information."); } } catch (Exception ex) { this.Status = StepStatusEnum.Failed; this.ResultDetail = new StepResultDetail("Error has occurred, please check log.", ExceptionHelper.CentralProcessSingle2(ex)); } finally { if (this.ResultDetail != null) { string message = sb.ToString(); if (!string.IsNullOrEmpty(message)) { this.ResultDetail.Message += "Execution log: \r\n{0}".FormatWith(message); } } } }
/* IMPORT THE DATA */ protected void ImportREDCapToDB() { string info; DateTime startupload = DateTime.Now; info = String.Format("Begin. {0}<br/>", startupload.ToString()); string ID = cboSubject.Value.ToString(); int studymeasID = Convert.ToInt32(cboStudymeas.Value.ToString()); REDCap redcap = new REDCap(Master.Master_studyID); if (redcap.IsREDCapMeasure(studymeasID)) { DataTable dt_forms = DataImporter.LinkedREDCapForms(Master.Master_studyID, studymeasID, DbEntityType.studymeas); List <string> formnames = dt_forms.AsEnumerable().Select(f => f.Field <string>("form_name")).ToList(); DataImporter importer = new DataImporter(ID, studymeasID, formnames); info += importer.ResultsToString(); } double timeelapsed = Math.Round((DateTime.Now - startupload).TotalSeconds, 2); info += String.Format("<br/> End. {0} total seconds.", timeelapsed); DisplayImporterResults(info); }
public void Test_LoadEntityFromFile() { TestUser user = new TestUser(); user.ID = Guid.NewGuid(); user.FirstName = "Test"; user.LastName = "Test"; DataExporter exporter = (DataExporter)DataAccess.Data.InitializeDataExporter(); exporter.ExportDirectoryPath = TestUtilities.GetTestingPath(this) + Path.DirectorySeparatorChar + "Exported"; // Export the user to XML exporter.ExportEntity(user); string filePath = exporter.CreateEntityPath(user); DataImporter importer = (DataImporter)DataAccess.Data.InitializeDataImporter(); importer.ImportedDirectoryPath = TestUtilities.GetTestingPath(this) + Path.DirectorySeparatorChar + "Imported"; TestUser foundUser = (TestUser)importer.LoadEntityFromFile(filePath); Assert.IsNotNull(foundUser, "foundUser == null"); Assert.AreEqual(user.ID.ToString(), foundUser.ID.ToString(), "The ID of the found user doesn't have the same ID as the original."); }
public string Execute(string[] inputArgs) { Check.CheckLength(1, inputArgs); string filePath = inputArgs[0]; if (!File.Exists(filePath)) { throw new FileNotFoundException(string.Format(Constants.ErrorMessages.FileNotFound, filePath)); } List <Models.Team> teams; try { teams = DataImporter.GetTeamsFromXml(filePath); } catch (Exception e) { throw new FormatException(Constants.ErrorMessages.InvalidXmlFormat); } TeamService.AddTeams(teams); return($"You have successfully imported {teams.Count} teams!"); }
void Start() { dataImporter = GetComponent <DataImporter>(); cameraController = Camera.main.GetComponent <CameraController>(); uic = GetComponent <UIController>(); gs = GameState.Lock; }
public async Task <ActionResult <ImportMetadata> > GetMetadata(string id, [FromServices] DataImporter importer) { try { if (!importOptions.REDCap.Enabled) { return(NotFound()); } ImportMetadata meta = null; var isGuid = Guid.TryParse(id, out var guidId); if (isGuid) { // Get by leaf internal Id meta = await importer.GetImportMetadata(guidId); } else { // Get by sourceId meta = await importer.GetImportMetadata(id); } if (meta == null) { return(NotFound()); } return(Ok(meta)); } catch (Exception ex) { log.LogError("Failed get import metadata. Error:{Error}", ex.ToString()); return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public async Task Run_FileFormatError1() { // ARRANGE this.fixture.MoqElementRepository.Invocations.Clear(); DataImporterSettings settings = new DataImporterSettings() { BlockSize = 100, FileURI = nameof(FileResources.FileFormatError1), }; int contador = 0; this.fixture.MoqElementRepository .Setup(a => a.SaveCollection(It.IsAny <List <Element> >())) .Callback((List <Element> lst) => contador += lst.Count); DataImporter sut = new DataImporter( new Mock <ILogger <DataImporter> >().Object, this.fixture.ServiceProvider.GetRequiredService <IFileImporterRepository>(), this.fixture.ServiceProvider.GetRequiredService <IElementRepository>(), settings); // ACT Func <Task> actTodo = () => sut.Run(); // ASSERT await Assert.ThrowsAsync <FormatException>(actTodo); this.fixture.MoqElementRepository.Verify(a => a.Initialize(), Times.Once()); }
public async Task Run_FileOK1_BlockSize100() { await Task.Yield(); // ARRANGE this.fixture.MoqElementRepository.Invocations.Clear(); DataImporterSettings settings = new DataImporterSettings() { BlockSize = 100, FileURI = nameof(FileResources.FileOk1), }; int contador = 0; this.fixture.MoqElementRepository .Setup(a => a.SaveCollection(It.IsAny <List <Element> >())) .Callback((List <Element> lst) => contador += lst.Count); DataImporter sut = new DataImporter( new Mock <ILogger <DataImporter> >().Object, this.fixture.ServiceProvider.GetRequiredService <IFileImporterRepository>(), this.fixture.ServiceProvider.GetRequiredService <IElementRepository>(), settings); // ACT await sut.Run(); // ASSERT Assert.Equal(28793, contador); this.fixture.MoqElementRepository.Verify(a => a.Initialize(), Times.Once()); }
public void DataImportTest_dat() { // Arrange DataImporter dataImporter = new DataImporter(); // Act // Parse dat file and create DepotManager dataImporter.ImportFromFile(@".\1G2.DAT"); // Get DepotManager from DataImporter DepotManager dm = dataImporter.GetManager(); // Assert Assert.AreEqual(50, dm.GetClient(0).Position.X); Assert.AreEqual(50, dm.GetClient(0).Position.Y); Assert.AreEqual(0, dm.GetClient(0).Demande); Assert.AreEqual(5, dm.GetClient(1).Position.X); Assert.AreEqual(5, dm.GetClient(1).Position.Y); Assert.AreEqual(10, dm.GetClient(1).Demande); Assert.AreEqual(95, dm.GetClient(50).Position.X); Assert.AreEqual(45, dm.GetClient(50).Position.Y); Assert.AreEqual(10, dm.GetClient(50).Demande); Assert.AreEqual(85, dm.GetClient(99).Position.X); Assert.AreEqual(95, dm.GetClient(99).Position.Y); Assert.AreEqual(10, dm.GetClient(99).Demande); Assert.AreEqual(95, dm.GetClient(100).Position.X); Assert.AreEqual(95, dm.GetClient(100).Position.Y); Assert.AreEqual(10, dm.GetClient(100).Demande); }
private void DataImporter_ContentImporting(DataImporter dataImporting, ContentImportingEventArgs e) { if (!RunContentTransforms(dataImporting, e.TransferContentData)) { e.Cancel = true; } ; }
private static void Initialize() { var importer = new DataImporter(); Carriers = importer.ListAllCarriers(); Aircrafts = importer.ListAllAircrafts(); AirCrashes = importer.ListAllAirCrashes(); }
protected void CheckNs() { try { string ID = cboSubject.Value.ToString(); int studymeasID = Convert.ToInt32(cboStudymeas.Value.ToString()); string ns = new DataImporter(ID, studymeasID).LinkedTableInfo(); ////Handle REDCap elsewhere //REDCap redcap = new REDCap(Master.Master_studyID); //if (redcap.IsREDCapMeasure(studymeasID)) //{ // DataTable dt_forms = DataImporter.LinkedREDCapForms(Master.Master_studyID, studymeasID, DbEntityType.studymeas); // gridREDCapForms.DataSource = dt_forms; // gridREDCapForms.DataBind(); // panelREDCap_controls.Visible = true; //} //else //{ // panelREDCap_controls.Visible = false; //} if (ns.Contains("!")) { lblNrecs.Visible = true; lblNrecs.ForeColor = Color.Red; lblNrecs.Text = String.Format("{0}There are records already entered!", ns); FileUpload_Doc.Visible = false; btnDelete.Visible = true; btnContinue.Visible = true; btnShowREDCap.Visible = false; btnImportREDCap.Visible = false; } else { lblNrecs.Visible = true; lblNrecs.ForeColor = Color.ForestGreen; lblNrecs.Text = ns; FileUpload_Doc.Visible = true; // (redcap.IsREDCapMeasure(studymeasID)) ? false : true; // don't show if a REDCap measure, because you don't upload files for these btnDelete.Visible = false; btnContinue.Visible = false; btnShowREDCap.Visible = false; // (redcap.IsREDCapMeasure(studymeasID)) ? true : false; btnImportREDCap.Visible = false; //(redcap.IsREDCapMeasure(studymeasID)) ? true : false; } } catch (Exception ex) { Debug.WriteLine("ERROR in CheckNs"); Debug.WriteLine(ex.Message); } }
static async Task ImportDataIntoSystemFromFile(ICommandPublisher commandPublisher, Guid klantId, string filePath) { var lines = File.ReadAllLines(filePath); var exporter = new TextDataExporter(); var oefeningen = exporter.ReadAllOefeningenWithPrestatiesFromLines(lines); var importer = new DataImporter(commandPublisher); await importer.ImportOefeningenIntoSystem(oefeningen.ToList(), klantId); }
// [Test, Order(1)] public void ImportEmptyFile() { var path = TesFilesDirectory + "0000_Empty.mes"; var importer = new DataImporter(); var imported = importer.CsvFileImport(path); //Assert.AreEqual(0, imported.RowCount); //Assert.AreEqual(0, imported.ColumCount); }
public static string[][] Parse(string input) { DataImporter parser = new DataImporter(); using (StringReader reader = new StringReader(input)) { return(parser.Parse(reader)); } }
public static void Main() { var importer = new DataImporter(); importer.ImportCourses(100); importer.ImportStudents(1000); importer.ImportMaterials(10); importer.StudentCoursesConnect(15); importer.ImportHomeWorks(500); }
public void ShouldImportData() { var dataFile = "TestData/example_data.csv"; var dataImporter = new DataImporter(dataFile); var data = dataImporter.ImportStock(); data.Count.ShouldBeGreaterThan(0); data.First().ShouldBeFullyPopulated(); }
public static void Main() { Database.SetInitializer(new DropCreateDatabaseAlways <LogsDbContext>()); using (var db = new LogsDbContext()) { DataImporter dataImporter = new DataImporter(); dataImporter.ImportLogs(db); } }
protected virtual void IntializeContainerForImport(IContainer container, DataImporter dataImporter) { // Temporarily inject the current context (dataImporter) into the container var context = new DataImporterPackageReaderContext(dataImporter); container.Inject<IPackageReaderContext>(context); container.Inject<IContentTransferContext>(dataImporter); // Create a ContentMap object that will live over the current thread/request IContentMap contentMap = new ContentMap(); container.Inject<IContentMap>(contentMap); }
public override void CheckIfCompleted() { string formattedConversationName = DataImporter.GetNameFromDialogName(ConversationName); if (Conversations.Get.NumTimesInitiated(formattedConversationName) > 0) { HasCompleted = true; Status |= MissionStatus.Completed; } FinishedChecking = true; }
static GameData() { Cards = DataImporter.ImportCards(); Sets = (from c in Cards select c.Set).Distinct().OrderBy(s => s).ToArray(); PlayableSets = Sets.Except(new[] { "ANA", "ArenaSUP" }).ToArray(); Task.Run(() => { CardArtImporter.ImportCardArt(Sets); GC.Collect(); }); }
protected void DeleteRecs(object sender, EventArgs e) { string ID = cboSubject.Value.ToString(); int studymeasID = Convert.ToInt32(cboStudymeas.Value.ToString()); DataImporter importer = new DataImporter(ID, studymeasID); importer.DeleteRecs(); Response.Redirect(Request.Url.AbsolutePath); }
public ImportForm(DataImporter importer) { InitializeComponent(); this.importer = importer; importer.OnDone += importer_OnDone; importer.OnError += importer_OnError; importer.OnConflict += importer_OnConflict; importer.OnMessage += importer_OnMessage; importer.OnProgress += importer_OnProgress; importer.OnMissing += importer_OnMissing; }
internal DataSource(RrdDb parentDb, DataImporter reader, int dsIndex) : this(parentDb, null) { dsName.Set(reader.GetDataSourceName(dsIndex)); primitiveDsName = null; dsType.Set(reader.GetDataSourceType(dsIndex)); primitiveDsType = null; heartbeat.Set(reader.GetDataSourceHeartbeat(dsIndex)); minValue.Set(reader.GetDataSourceMinValue(dsIndex)); maxValue.Set(reader.GetDataSourceMaxValue(dsIndex)); lastValue.Set(reader.GetDataSourceLastValue(dsIndex)); accumValue.Set(reader.GetDataSourceAccumulatedValue(dsIndex)); nanSeconds.Set(reader.GetDataSourceNanSeconds(dsIndex)); }
internal Header(RrdDb parentDb, DataImporter reader) : this(parentDb, (RrdDef) null) { String version = reader.Version; int intVersion = int.Parse(version); if (intVersion > 3) { throw new RrdException("Could not unserialize xml version " + version); } signature.Set(DEFAULT_SIGNATURE); step.Set(reader.Step); dsCount.Set(reader.DataSourceCount); arcCount.Set(reader.ArchiveCount); lastUpdateTime.Set(reader.LastUpdateTime); }
public static void RunSample() { IList<CountryOrRegionGdpData> listData = new DataImporter().Import(); Func<BenchmarkComponentBase>[] benchmarkComponents = { () => new BenchmarkComponentKeyedCollection(listData), () => new BenchmarkComponentMultiplyIndexedKeyedCollection(listData), }; BenchmarkProcessor benchmarkProcessor = new BenchmarkProcessor(); BenchmarkProcessorConfiguration benchmarkProcessorConfiguration = new BenchmarkProcessorConfiguration(); IEnumerable<IBenchmarkComponentResult> benchmarkResults = benchmarkProcessor.Execute(benchmarkProcessorConfiguration, benchmarkComponents); foreach (IBenchmarkComponentResult benchmarkComponentResult in benchmarkResults) Console.WriteLine("Benchmark Component: {0}{1}{2}", benchmarkComponentResult.Name, Environment.NewLine, FormatBenchmarkResults(benchmarkComponentResult.RootOperationResult, 0)); Console.ReadLine(); }
protected virtual bool RunContentTransforms(DataImporter dataImporter, ITransferContentData content) { var transformers = ServiceLocator.Current.GetAllInstances<IImportTransform>(); Logger.Info("Running transforms on content"); foreach (var transformer in transformers) { if (!transformer.Transform(content)) { return false; } } return true; }
private void doImportEpiData(string importPackagePath) { if (string.IsNullOrEmpty(importPackagePath)) { return; } DataImporter importer = new DataImporter(); if (importPackagePath.Contains("StarterDemoB2CSite.episerverdata")) { importer.DestinationRoot = PageReference.RootPage; } else if (importPackagePath.Contains("SampleAssets.episerverdata")) { importer.DestinationRoot = ContentReference.GlobalBlockFolder; } importer.Stream = new FileStream(importPackagePath, FileMode.Open, FileAccess.Read, FileShare.Read); // Clear the cache to ensure setup is running in a controlled environment, if perhaps we're developing and have just cleared // the database. CacheManager.Clear(); importer.KeepIdentity = true; importer.Import(); String logError = ReportStatus(importer); if (importer.Log.Errors.Count == 0) { if (importPackagePath.Contains("StarterDemoB2CSite.episerverdata")) { if (SiteDefinition.Current.StartPage.ID <= 0) { UpdateLanguageBranches(importer); } UpdateSiteSettings(importer.CopiedContentLink.ToReferenceWithoutVersion()); } } else { throw new Exception(" Site Content Data could not be imported due to: " + logError); } }
private void UpdateLanguageBranches(DataImporter importer) { // Enable all language branches in the import package LanguageBranch languageBranch; foreach (string languageID in importer.ContentLanguages) { languageBranch = _languageBranchRepository.Load(languageID); if (languageBranch == null) { languageBranch = new LanguageBranch(languageID, null); _languageBranchRepository.Save(languageBranch); } else if (!languageBranch.Enabled) { languageBranch = new LanguageBranch(languageBranch.ID, languageBranch.LanguageID, languageBranch.Name, languageBranch.SortIndex, languageBranch.RawIconPath, languageBranch.URLSegment, true); _languageBranchRepository.Save(languageBranch); } } }
public DataImporterPackageReaderContext(DataImporter dataImporter) { _dataImporter = dataImporter; }
private void DataImporter_ContentImporting(DataImporter dataImporting, ContentImportingEventArgs e) { if (!RunContentTransforms(dataImporting, e.TransferContentData)) { e.Cancel = true; }; }
private void ImportAssets(string path) { var importer = new DataImporter { DestinationRoot = ContentReference.GlobalBlockFolder }; importer.Stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read); // Clear the cache to ensure setup is running in a controlled environment, if perhaps we're developing and have just cleared the database. EPiServer.CacheManager.Clear(); importer.KeepIdentity = true; importer.Import(); if (importer.Log.Errors.Count > 0) { throw new Exception("Content could not be imported. " + GetStatus(importer)); } }