public virtual void DeleteExportProfile(ExportProfile profile, bool force = false)
{
if (profile == null)
{
throw new ArgumentNullException("profile");
}
if (!force && profile.IsSystemProfile)
{
throw new SmartException(_localizationService.GetResource("Admin.DataExchange.Export.CannotDeleteSystemProfile"));
}
int scheduleTaskId = profile.SchedulingTaskId;
var folder = profile.GetExportFolder();
var deployments = profile.Deployments.Where(x => !x.IsTransientRecord()).ToList();
if (deployments.Any())
{
_exportDeploymentRepository.DeleteRange(deployments);
_exportDeploymentRepository.Context.SaveChanges();
}
_exportProfileRepository.Delete(profile);
var scheduleTask = _scheduleTaskService.GetTaskById(scheduleTaskId);
_scheduleTaskService.DeleteTask(scheduleTask);
if (System.IO.Directory.Exists(folder))
{
FileSystemHelper.ClearDirectory(folder, true);
}
}
public virtual void DeleteExportProfile(ExportProfile profile, bool force = false)
{
if (profile == null)
{
throw new ArgumentNullException("profile");
}
if (!force && profile.IsSystemProfile)
{
throw new SmartException(_localizationService.GetResource("Admin.DataExchange.Export.CannotDeleteSystemProfile"));
}
int scheduleTaskId = profile.SchedulingTaskId;
var folder = profile.GetExportFolder();
_exportProfileRepository.Delete(profile);
var scheduleTask = _scheduleTaskService.GetTaskById(scheduleTaskId);
_scheduleTaskService.DeleteTask(scheduleTask);
_eventPublisher.EntityDeleted(profile);
if (System.IO.Directory.Exists(folder))
{
FileSystemHelper.ClearDirectory(folder, true);
}
}
public void Seed(SmartObjectContext context)
{
context.MigrateLocaleResources(MigrateLocaleResources);
// migrate folder name to folder path
var rootPath = "~/App_Data/ExportProfiles/";
var exportProfiles = context.Set <ExportProfile>().ToList();
foreach (var profile in exportProfiles)
{
if (!profile.FolderName.EmptyNull().StartsWith(rootPath))
{
profile.FolderName = rootPath + profile.FolderName;
}
}
context.SaveChanges();
// migrate public file system deployment to new public deployment
if (context.ColumnExists("ExportDeployment", "IsPublic"))
{
var fileSystemDeploymentTypeId = (int)ExportDeploymentType.FileSystem;
var publicFolderDeploymentTypeId = (int)ExportDeploymentType.PublicFolder;
context.ExecuteSqlCommand("Update [ExportDeployment] Set DeploymentTypeId = {0} Where DeploymentTypeId = {1} And IsPublic = 1",
true, null, publicFolderDeploymentTypeId, fileSystemDeploymentTypeId);
context.ColumnDelete("ExportDeployment", "IsPublic");
}
var oldFileManagerPath = CommonHelper.MapPath("~/Content/filemanager");
FileSystemHelper.ClearDirectory(oldFileManagerPath, true);
}
public override void Uninstall()
{
ConnectionCache.Remove();
_services.Settings.DeleteSetting <ShopConnectorSettings>();
_services.Localization.DeleteLocaleStringResources(PluginDescriptor.ResourceRootKey);
InsertProfile(ShopConnectorProductXmlExportProvider.SystemName, false);
InsertProfile(ShopConnectorCategoryXmlExportProvider.SystemName, false);
var migrator = new DbMigrator(new Configuration());
migrator.Update(DbMigrator.InitialDatabase);
FileSystemHelper.ClearDirectory(ShopConnectorFileSystem.GetDirectory(null), true);
base.Uninstall();
}
private void DownloadDir(string path)
{
path = GetRelativePath(path);
if (!_fileSystem.FolderExists(path))
{
throw new Exception(LangRes("E_CreateArchive"));
}
var folder = _fileSystem.GetFolder(path);
// copy files from file storage to temp folder
var tempDir = FileSystemHelper.TempDirTenant("roxy " + folder.Name);
FileSystemHelper.ClearDirectory(tempDir, false);
var files = GetFiles(path, null);
foreach (var file in files)
{
var bytes = _fileSystem.ReadAllBytes(file.Path);
if (bytes != null && bytes.Length > 0)
{
System.IO.File.WriteAllBytes(Path.Combine(tempDir, file.Name), bytes);
}
}
// create zip from temp folder
var tempZip = Path.Combine(FileSystemHelper.TempDirTenant(), folder.Name + ".zip");
FileSystemHelper.DeleteFile(tempZip);
ZipFile.CreateFromDirectory(tempDir, tempZip, CompressionLevel.Fastest, false);
Response.Clear();
Response.Headers.Add("Content-Disposition", "attachment; filename=\"" + folder.Name + ".zip\"");
Response.ContentType = "application/zip";
Response.TransmitFile(tempZip);
Response.Flush();
FileSystemHelper.DeleteFile(tempZip);
FileSystemHelper.ClearDirectory(tempDir, true);
Response.End();
}
public static void CleanupDirectories()
{
Throttle.Check("Cleanup temporary Shop-Connector files", TimeSpan.FromHours(12), () =>
{
try
{
var olderThan = TimeSpan.FromHours(12);
foreach (var name in new string[] { "Export", "About" })
{
var dir = GetDirectory(name);
FileSystemHelper.ClearDirectory(new DirectoryInfo(dir), false, olderThan);
}
}
catch { }
return(true);
});
}
public virtual void DeleteImportProfile(ImportProfile profile)
{
if (profile == null)
{
throw new ArgumentNullException("profile");
}
var scheduleTaskId = profile.SchedulingTaskId;
var folder = profile.GetImportFolder();
_importProfileRepository.Delete(profile);
var scheduleTask = _scheduleTaskService.GetTaskById(scheduleTaskId);
_scheduleTaskService.DeleteTask(scheduleTask);
if (System.IO.Directory.Exists(folder))
{
FileSystemHelper.ClearDirectory(folder, true);
}
}
private async Task UploadAsync(string path, bool external = false)
{
path = GetRelativePath(path);
string message = null;
var hasError = false;
var width = 0;
var height = 0;
string url = null;
int.TryParse(GetSetting("MAX_IMAGE_WIDTH"), out width);
int.TryParse(GetSetting("MAX_IMAGE_HEIGHT"), out height);
var tempDir = FileSystemHelper.TempDirTenant("roxy " + CommonHelper.GenerateRandomInteger().ToString());
try
{
var notify = Request.Files.Count < 4;
// copy uploaded files to temp folder and resize them
for (var i = 0; i < Request.Files.Count; ++i)
{
var file = Request.Files[i];
var extension = Path.GetExtension(file.FileName);
if (IsAllowedFileType(extension))
{
var dest = Path.Combine(tempDir, file.FileName);
file.SaveAs(dest);
if (GetFileContentType(extension) == "image" && extension != ".svg")
{
ImageResize(dest, dest, width, height, notify);
}
}
else
{
message = LangRes("E_UploadNotAll");
}
}
// Copy files to file storage
foreach (var tempPath in Directory.EnumerateFiles(tempDir, "*", SearchOption.TopDirectoryOnly))
{
using (var stream = new FileStream(tempPath, FileMode.Open, FileAccess.Read))
{
var name = Path.GetFileName(tempPath);
var newPath = _fileSystem.Combine(path, name);
if (_fileSystem.CheckFileUniqueness(newPath, out var file))
{
newPath = file.Path;
}
await _fileSystem.SaveStreamAsync(newPath, stream);
url = _fileSystem.GetPublicUrl(newPath);
}
}
}
catch (Exception ex)
{
hasError = true;
message = ex.Message;
}
finally
{
FileSystemHelper.ClearDirectory(tempDir, true);
}
if (IsAjaxUpload())
{
if (external)
{
var result = new
{
Success = !hasError,
Url = url,
Message = message
};
Response.ContentType = "text/json";
Response.Write(JsonConvert.SerializeObject(result));
}
else
{
if (message.HasValue())
{
Response.Write(GetResultString(message, hasError ? "error" : "ok"));
}
}
}
else
{
Response.Write("<script>");
Response.Write("parent.fileUploaded(" + GetResultString(message, hasError ? "error" : "ok") + ");");
Response.Write("</script>");
}
}
public ActionResult MaintenanceDeleteFiles(MaintenanceModel model)
{
if (!_services.Permissions.Authorize(StandardPermissionProvider.ManageMaintenance))
{
return(AccessDeniedView());
}
DateTime?startDateValue = (model.DeleteExportedFiles.StartDate == null) ? null
: (DateTime?)_dateTimeHelper.Value.ConvertToUtcTime(model.DeleteExportedFiles.StartDate.Value, _dateTimeHelper.Value.CurrentTimeZone);
DateTime?endDateValue = (model.DeleteExportedFiles.EndDate == null) ? null
: (DateTime?)_dateTimeHelper.Value.ConvertToUtcTime(model.DeleteExportedFiles.EndDate.Value, _dateTimeHelper.Value.CurrentTimeZone).AddDays(1);
model.DeleteExportedFiles.NumberOfDeletedFiles = 0;
model.DeleteExportedFiles.NumberOfDeletedFolders = 0;
var appPath = this.Request.PhysicalApplicationPath;
string[] paths = new string[]
{
appPath + @"Content\files\exportimport\",
appPath + @"Exchange\",
appPath + @"App_Data\ExportProfiles\"
};
foreach (var path in paths)
{
foreach (var fullPath in System.IO.Directory.GetFiles(path))
{
try
{
var fileName = Path.GetFileName(fullPath);
if (fileName.Equals("index.htm", StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
if (fileName.Equals("placeholder", StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
var info = new FileInfo(fullPath);
if ((!startDateValue.HasValue || startDateValue.Value < info.CreationTimeUtc) &&
(!endDateValue.HasValue || info.CreationTimeUtc < endDateValue.Value))
{
if (FileSystemHelper.Delete(fullPath))
{
++model.DeleteExportedFiles.NumberOfDeletedFiles;
}
}
}
catch (Exception exc)
{
NotifyError(exc, false);
}
}
var dir = new DirectoryInfo(path);
foreach (var dirInfo in dir.GetDirectories())
{
if ((!startDateValue.HasValue || startDateValue.Value < dirInfo.LastWriteTimeUtc) &&
(!endDateValue.HasValue || dirInfo.LastWriteTimeUtc < endDateValue.Value))
{
FileSystemHelper.ClearDirectory(dirInfo.FullName, true);
++model.DeleteExportedFiles.NumberOfDeletedFolders;
}
}
}
// clear unreferenced profile folders
var importProfileFolders = _importProfileService.Value.GetImportProfiles()
.Select(x => x.FolderName)
.ToList();
var infoImportProfiles = new DirectoryInfo(CommonHelper.MapPath("~/App_Data/ImportProfiles"));
foreach (var infoSubFolder in infoImportProfiles.GetDirectories())
{
if (!importProfileFolders.Contains(infoSubFolder.Name))
{
FileSystemHelper.ClearDirectory(infoSubFolder.FullName, true);
++model.DeleteExportedFiles.NumberOfDeletedFolders;
}
}
return(View(model));
}
public async Task <IQueryable <UploadImportFile> > ImportFiles()
{
if (!Request.Content.IsMimeMultipartContent())
{
throw this.ExceptionUnsupportedMediaType();
}
ImportProfile profile = null;
string identifier = null;
var tempDir = FileSystemHelper.TempDir(Guid.NewGuid().ToString());
var provider = new MultipartFormDataStreamProvider(tempDir);
try
{
await Request.Content.ReadAsMultipartAsync(provider);
}
catch (Exception exception)
{
FileSystemHelper.ClearDirectory(tempDir, true);
throw this.ExceptionInternalServerError(exception);
}
// find import profile
if (provider.FormData.AllKeys.Contains("Id"))
{
identifier = provider.FormData.GetValues("Id").FirstOrDefault();
profile = _importProfileService.Value.GetImportProfileById(identifier.ToInt());
}
else if (provider.FormData.AllKeys.Contains("Name"))
{
identifier = provider.FormData.GetValues("Name").FirstOrDefault();
profile = _importProfileService.Value.GetImportProfileByName(identifier);
}
if (profile == null)
{
FileSystemHelper.ClearDirectory(tempDir, true);
throw this.ExceptionNotFound(WebApiGlobal.Error.EntityNotFound.FormatInvariant(identifier.NaIfEmpty()));
}
var deleteExisting = false;
var result = new List <UploadImportFile>();
var unzippedFiles = new List <MultipartFileData>();
var importFolder = profile.GetImportFolder(true, true);
var csvTypes = new string[] { ".csv", ".txt", ".tab" };
if (provider.FormData.AllKeys.Contains("deleteExisting"))
{
var strDeleteExisting = provider.FormData.GetValues("deleteExisting").FirstOrDefault();
deleteExisting = (strDeleteExisting.HasValue() && strDeleteExisting.ToBool());
}
// unzip files
foreach (var file in provider.FileData)
{
var import = new UploadImportFile(file.Headers);
if (import.FileExtension.IsCaseInsensitiveEqual(".zip"))
{
var subDir = Path.Combine(tempDir, Guid.NewGuid().ToString());
ZipFile.ExtractToDirectory(file.LocalFileName, subDir);
FileSystemHelper.Delete(file.LocalFileName);
foreach (var unzippedFile in Directory.GetFiles(subDir, "*.*"))
{
var content = CloneHeaderContent(unzippedFile, file);
unzippedFiles.Add(new MultipartFileData(content.Headers, unzippedFile));
}
}
else
{
unzippedFiles.Add(new MultipartFileData(file.Headers, file.LocalFileName));
}
}
// copy files to import folder
if (unzippedFiles.Any())
{
using (_rwLock.GetWriteLock())
{
if (deleteExisting)
{
FileSystemHelper.ClearDirectory(importFolder, false);
}
foreach (var file in unzippedFiles)
{
var import = new UploadImportFile(file.Headers);
var destPath = Path.Combine(importFolder, import.FileName);
import.Exists = File.Exists(destPath);
switch (profile.FileType)
{
case ImportFileType.XLSX:
import.IsSupportedByProfile = import.FileExtension.IsCaseInsensitiveEqual(".xlsx");
break;
case ImportFileType.CSV:
import.IsSupportedByProfile = csvTypes.Contains(import.FileExtension, StringComparer.OrdinalIgnoreCase);
break;
}
import.Inserted = FileSystemHelper.Copy(file.LocalFileName, destPath);
result.Add(import);
}
}
}
FileSystemHelper.ClearDirectory(tempDir, true);
return(result.AsQueryable());
}
public async Task <IHttpActionResult> ImportFiles()
{
if (!Request.Content.IsMimeMultipartContent())
{
return(StatusCode(HttpStatusCode.UnsupportedMediaType));
}
ImportProfile profile = null;
string identifier = null;
var tempDir = FileSystemHelper.TempDirTenant(Guid.NewGuid().ToString());
var provider = new MultipartFormDataStreamProvider(tempDir);
try
{
await Request.Content.ReadAsMultipartAsync(provider);
}
catch (Exception ex)
{
FileSystemHelper.ClearDirectory(tempDir, true);
return(InternalServerError(ex));
}
// Find import profile.
if (provider.FormData.AllKeys.Contains("Id"))
{
identifier = provider.FormData.GetValues("Id").FirstOrDefault();
profile = _importProfileService.Value.GetImportProfileById(identifier.ToInt());
}
else if (provider.FormData.AllKeys.Contains("Name"))
{
identifier = provider.FormData.GetValues("Name").FirstOrDefault();
profile = _importProfileService.Value.GetImportProfileByName(identifier);
}
if (profile == null)
{
FileSystemHelper.ClearDirectory(tempDir, true);
throw Request.NotFoundException(WebApiGlobal.Error.EntityNotFound.FormatInvariant(identifier.NaIfEmpty()));
}
var startImport = false;
var deleteExisting = false;
var result = new List <UploadImportFile>();
var unzippedFiles = new List <MultipartFileData>();
var importFolder = profile.GetImportFolder(true, true);
var csvTypes = new string[] { ".csv", ".txt", ".tab" };
if (provider.FormData.AllKeys.Contains("deleteExisting"))
{
var strDeleteExisting = provider.FormData.GetValues("deleteExisting").FirstOrDefault();
deleteExisting = strDeleteExisting.HasValue() && strDeleteExisting.ToBool();
}
if (provider.FormData.AllKeys.Contains("startImport"))
{
var strStartImport = provider.FormData.GetValues("startImport").FirstOrDefault();
startImport = strStartImport.HasValue() && strStartImport.ToBool();
}
// Unzip files.
foreach (var file in provider.FileData)
{
var import = new UploadImportFile(file.Headers);
if (import.FileExtension.IsCaseInsensitiveEqual(".zip"))
{
var subDir = Path.Combine(tempDir, Guid.NewGuid().ToString());
ZipFile.ExtractToDirectory(file.LocalFileName, subDir);
FileSystemHelper.DeleteFile(file.LocalFileName);
foreach (var unzippedFile in Directory.GetFiles(subDir, "*.*"))
{
var content = CloneHeaderContent(unzippedFile, file);
unzippedFiles.Add(new MultipartFileData(content.Headers, unzippedFile));
}
}
else
{
unzippedFiles.Add(new MultipartFileData(file.Headers, file.LocalFileName));
}
}
// Copy files to import folder.
if (unzippedFiles.Any())
{
using (_rwLock.GetWriteLock())
{
if (deleteExisting)
{
FileSystemHelper.ClearDirectory(importFolder, false);
}
foreach (var file in unzippedFiles)
{
var import = new UploadImportFile(file.Headers);
var destPath = Path.Combine(importFolder, import.FileName);
import.Exists = File.Exists(destPath);
switch (profile.FileType)
{
case ImportFileType.XLSX:
import.IsSupportedByProfile = import.FileExtension.IsCaseInsensitiveEqual(".xlsx");
break;
case ImportFileType.CSV:
import.IsSupportedByProfile = csvTypes.Contains(import.FileExtension, StringComparer.OrdinalIgnoreCase);
break;
}
import.Inserted = FileSystemHelper.CopyFile(file.LocalFileName, destPath);
result.Add(import);
}
}
}
FileSystemHelper.ClearDirectory(tempDir, true);
if (startImport)
{
var customer = _workContext.Value.CurrentCustomer;
if (_permissionService.Value.Authorize(Permissions.System.ScheduleTask.Execute, customer))
{
_taskScheduler.Value.RunSingleTask(profile.SchedulingTaskId, new Dictionary <string, string>
{
{ TaskExecutor.CurrentCustomerIdParamName, customer.Id.ToString() },
{ TaskExecutor.CurrentStoreIdParamName, _storeContext.Value.CurrentStore.Id.ToString() }
});
}
}
return(Ok(result.AsQueryable()));
}
private void Upload(string path)
{
path = GetRelativePath(path);
string message = null;
var hasError = false;
var width = 0;
var height = 0;
int.TryParse(GetSetting("MAX_IMAGE_WIDTH"), out width);
int.TryParse(GetSetting("MAX_IMAGE_HEIGHT"), out height);
var tempDir = FileSystemHelper.TempDirTenant("roxy " + CommonHelper.GenerateRandomInteger().ToString());
try
{
// copy uploaded files to temp folder and resize them
for (var i = 0; i < Request.Files.Count; ++i)
{
var file = Request.Files[i];
var extension = Path.GetExtension(file.FileName);
if (IsAllowedFileType(extension))
{
var dest = Path.Combine(tempDir, file.FileName);
file.SaveAs(dest);
if (GetFileContentType(extension).IsCaseInsensitiveEqual("image"))
{
ImageResize(dest, dest, width, height);
}
}
else
{
message = LangRes("E_UploadNotAll");
}
}
// copy files to file storage
foreach (var tempPath in Directory.EnumerateFiles(tempDir, "*", SearchOption.TopDirectoryOnly))
{
using (var stream = new FileStream(tempPath, FileMode.Open, FileAccess.Read))
{
var name = GetUniqueFileName(path, Path.GetFileName(tempPath));
var newPath = _fileSystem.Combine(path, name);
_fileSystem.SaveStream(newPath, stream);
}
}
}
catch (Exception exception)
{
hasError = true;
message = exception.Message;
}
finally
{
FileSystemHelper.ClearDirectory(tempDir, true);
}
if (IsAjaxUpload())
{
if (message.HasValue())
{
Response.Write(GetResultString(message, hasError ? "error" : "ok"));
}
}
else
{
Response.Write("<script>");
Response.Write("parent.fileUploaded(" + GetResultString(message, hasError ? "error" : "ok") + ");");
Response.Write("</script>");
}
}
