public bool ImportFilePackage(
ContentReference startNode,
string filePath)
{
try
{
if (!File.Exists(filePath))
{
_log.Error($"Can't find the import file in {filePath}");
return(false);
}
var fileStream = new FileStream(filePath, FileMode.Open);
var options = ImportOptions.DefaultOptions;
options.KeepIdentity = true;
options.ValidateDestination = true;
options.EnsureContentNameUniqueness = false;
options.IsTest = false;
_dataImporter.Import(fileStream, startNode, options);
}
catch (Exception ex)
{
_log.Error("Can't import data because, ", ex);
return(false);
}
return(true);
}
public static void ImportObjects <T> (IDataImporter importer, string file, PropertyMap propertyMap, long?locationId, ImporterCallback <T> callback)
{
string [] [] data = new string [0] [];
LicenseLimitationException llex = null;
try {
importer.Import(file, out data);
} catch (LicenseLimitationException ex) {
llex = ex;
}
for (int i = 0; i < data.Length; i++)
{
T obj = CreateImportedObject <T> (propertyMap, data [i]);
bool cancel;
callback(obj, locationId, i, data.Length, out cancel);
if (cancel)
{
break;
}
}
if (llex != null)
{
throw llex;
}
}
public void Scrape(uint numPosts)
{
if (numPosts == 0)
{
throw new ArgumentOutOfRangeException("Number of posts must be greater than zero.");
}
var posts = new List <Post>();
bool requiredPostsAdded = false;
int pageNumber = 1;
while (!requiredPostsAdded)
{
string page = _importer.Import(_uri + pageNumber);
IEnumerable <Post> pagePosts = _parser.Parse(page);
foreach (var post in pagePosts)
{
posts.Add(post);
if (posts.Count == numPosts)
{
requiredPostsAdded = true;
break;
}
}
pageNumber++;
}
string formattedPosts = _formatter.Format(posts);
_exporter.Export(formattedPosts);
}
public IActionResult Starting(ImportModel model)
{
_sessionService.Remove("importfile");
var result = _dataImporter.Import(model.ImportFileId);
return(JOk(new { result.ImportFileId, result.SuccessCount, result.FailureCount }));
}
public void Run()
{
var employeeDetails = _dataImporter.Import("input.csv");
foreach (var employeeDetail in employeeDetails)
{
var payslip = _payslipGenerator.GeneratePayslip(employeeDetail);
Console.WriteLine(payslip);
}
}
public void Execute(TaskExecutionContext ctx)
{
var profileId = ctx.ScheduleTask.Alias.ToInt();
var profile = _importProfileService.GetImportProfileById(profileId);
var request = new DataImportRequest(profile);
request.ProgressValueSetter = delegate (int val, int max, string msg)
{
ctx.SetProgress(val, max, msg, true);
};
_importer.Import(request, ctx.CancellationToken);
}
private static ContentReference ImportEmbeddedPackage(IDataImporter importer, string embeddedResourceName)
{
// Load content package from embedded resources
var resources = Assembly.GetExecutingAssembly().GetManifestResourceStream(embeddedResourceName);
var options = new ImportOptions
{
AutoCloseStream = true,
KeepIdentity = true,
TransferType = TypeOfTransfer.Importing,
ValidateDestination = false
};
importer.Import(resources, ContentReference.RootPage, options);
// Root of Imported pages will be our start page
return(importer.Status.ImportedRoot);
}
public ActionResult Upload(IEnumerable <HttpPostedFileBase> files)
{
try
{
foreach (HttpPostedFileBase file in files.Where(obj => obj.ContentLength > 0))
{
dataImporter.Import(file.InputStream);
}
dataImporter.Commit();
}
catch (Exception e)
{
Logger.Error(e);
}
return(RedirectToAction("Index"));
}
public IActionResult Post([FromBody] CSVModel model)
{
try
{
if (ModelState.IsValid)
{
_dataImporter.Import(model, EnumImportType.Coverholder);
return(Ok());
}
else
{
return(StatusCode(StatusCodes.Status400BadRequest, ModelState.GetErrors()));
}
}
catch (Exception ex)
{
LogHelper.Error(ex);
return(StatusCode(StatusCodes.Status400BadRequest, Messages.Unexpected_Error_Occurred));
}
}
public static bool ImportEpiserverContent(Stream stream,
ContentReference destinationRoot,
IDataImporter importer,
SiteDefinition siteDefinition = null)
{
var success = false;
try
{
var log = importer.Import(stream, destinationRoot, new ImportOptions
{
KeepIdentity = true,
EnsureContentNameUniqueness = false
});
var status = importer.Status;
if (status == null)
{
return(false);
}
UpdateLanguageBranches(status);
if (siteDefinition != null && !ContentReference.IsNullOrEmpty(status.ImportedRoot))
{
siteDefinition.StartPage = status.ImportedRoot;
_siteDefinitionRepository.Value.Save(siteDefinition);
SiteDefinition.Current = siteDefinition;
success = true;
}
}
catch (Exception exception)
{
LogManager.GetLogger().Error(exception.Message, exception);
success = false;
}
return(success);
}
public async Task <IActionResult> Import(IFormFile file)
{
if (file is null || file.Length == 0)
{
return(BadRequest("no or empty file uploaded"));
}
byte[] buffer;
using (var memStream = new MemoryStream())
{
await file.CopyToAsync(memStream);
memStream.Seek(0, SeekOrigin.Begin);
buffer = new byte[memStream.Length];
memStream.Read(buffer, 0, buffer.Length);
}
if (!buffer.Any())
{
return(BadRequest("no or empty file uploaded"));
}
var json = Encoding.UTF8.GetString(buffer);
ConfigExport export;
// try to strip utf8-byte-order-mark from the incoming text
var bom = Encoding.UTF8.GetString(Encoding.UTF8.GetPreamble());
if (json.StartsWith(bom))
{
json = json.TrimStart(bom.ToCharArray());
}
try
{
export = JsonSerializer.Deserialize <ConfigExport>(json);
if (export is null)
{
return(BadRequest("uploaded file can't be mapped to object"));
}
}
catch (JsonException e)
{
Logger.LogWarning($"uploaded file can't be deserialized to '{nameof(ConfigExport)}': {e}");
return(BadRequest("uploaded file can't be mapped to object"));
}
try
{
var result = await _importer.Import(export);
if (result.IsError)
{
return(ProviderError(result));
}
return(AcceptedAtAction(nameof(EnvironmentController.GetAvailableEnvironments),
RouteUtilities.ControllerName <EnvironmentController>(),
new { version = ApiVersions.V1 }));
}
catch (Exception e)
{
var targetEnvironments = string.Join(", ", export.Environments.Select(eid => $"{eid.Category}/{eid.Name}"));
KnownMetrics.Exception.WithLabels(e.GetType().Name).Inc();
Logger.LogError(e, $"failed to export '{export.Environments.Length}' environments ({targetEnvironments})");
return(StatusCode(HttpStatusCode.InternalServerError, $"failed to export environments '{targetEnvironments}'"));
}
}