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);
}
}
public static void Main()
{
var importer = new DataImporter();
importer.ImportCourses(100);
importer.ImportStudents(1000);
importer.ImportMaterials(10);
importer.StudentCoursesConnect(15);
importer.ImportHomeWorks(500);
}
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));
}
}
