private void InitializeCodeActivity_ExecuteCode(object sender, EventArgs e)
{
FormsWorkflow workflow = this.GetRoot <FormsWorkflow>();
string parentFolderPath;
string storeId;
if (this.EntityToken is MediaRootFolderProviderEntityToken)
{
MediaRootFolderProviderEntityToken token = (MediaRootFolderProviderEntityToken)this.EntityToken;
parentFolderPath = "/";
storeId = token.Id;
}
else
{
DataEntityToken token = (DataEntityToken)this.EntityToken;
IMediaFileFolder parentFolder = (IMediaFileFolder)token.Data;
parentFolderPath = parentFolder.Path;
storeId = parentFolder.StoreId;
}
string providerName = DataFacade.GetData <IMediaFileStore>().Where(x => x.Id == storeId).First().DataSourceId.ProviderName;
UploadedFile file = new UploadedFile();
workflow.Bindings.Add("UploadedFile", file);
workflow.Bindings.Add("RecreateFolders", true);
workflow.Bindings.Add("OverwriteExisting", false);
workflow.Bindings.Add("ParentFolderPath", parentFolderPath);
workflow.Bindings.Add("ProviderName", providerName);
}
private void deleteCodeActivity_ExecuteCode(object sender, EventArgs e)
{
DeleteTreeRefresher treeRefresher = this.CreateDeleteTreeRefresher(this.EntityToken);
DataEntityToken token = (DataEntityToken)this.EntityToken;
using (TransactionScope transactionScope = TransactionsFacade.CreateNewScope())
{
IMediaFileFolder folder = DataFacade.GetDataFromDataSourceId(token.DataSourceId, false) as IMediaFileFolder;
// Media folder may already be deleted at this point
if (folder != null)
{
if (!DataFacade.WillDeleteSucceed(folder))
{
this.ShowMessage(
DialogType.Error,
StringResourceSystemFacade.GetString("Composite.Management", "DeleteMediaFolderWorkflow.CascadeDeleteErrorTitle"),
StringResourceSystemFacade.GetString("Composite.Management", "DeleteMediaFolderWorkflow.CascadeDeleteErrorMessage")
);
return;
}
DataFacade.Delete(folder);
}
transactionScope.Complete();
}
treeRefresher.PostRefreshMesseges();
}
private void codeActivity1_ExecuteCode(object sender, EventArgs e)
{
DataEntityToken token = (DataEntityToken)this.EntityToken;
IMediaFileFolder folder = (IMediaFileFolder)token.Data;
string storeId = folder.StoreId;
string parentPath = folder.Path;
StoreIdFilterQueryable <IMediaFileFolder> folderQueryable = new StoreIdFilterQueryable <IMediaFileFolder>(DataFacade.GetData <IMediaFileFolder>(), storeId);
StoreIdFilterQueryable <IMediaFile> fileQueryable = new StoreIdFilterQueryable <IMediaFile>(DataFacade.GetData <IMediaFile>(), storeId);
string innerElementsPathPrefix = string.Format("{0}/", parentPath);
bool anyFiles =
(from item in fileQueryable
where item.FolderPath.StartsWith(innerElementsPathPrefix) || item.FolderPath == parentPath
select item).Any();
bool anyFolders =
(from item in folderQueryable
where item.Path.StartsWith(innerElementsPathPrefix)
select item).Any();
if ((anyFiles == false) && (anyFolders == false))
{
this.Bindings.Add("MessageText", StringResourceSystemFacade.GetString("Composite.Management", "Website.Forms.Administrative.DeleteMediaFolder.Text"));
}
else
{
this.Bindings.Add("MessageText", StringResourceSystemFacade.GetString("Composite.Management", "Website.Forms.Administrative.DeleteMediaFolder.HasChildringText"));
}
}
private void initializeAddNewfolderCodeActivity_ExecuteCode(object sender, EventArgs e)
{
FormsWorkflow workflow = this.GetRoot <FormsWorkflow>();
string parentFolderPath;
string storeId;
if (this.EntityToken is MediaRootFolderProviderEntityToken)
{
MediaRootFolderProviderEntityToken token = (MediaRootFolderProviderEntityToken)this.EntityToken;
storeId = token.Id;
parentFolderPath = "/";
}
else
{
DataEntityToken token = (DataEntityToken)this.EntityToken;
IMediaFileFolder parentFolder = (IMediaFileFolder)token.Data;
storeId = parentFolder.StoreId;
parentFolderPath = parentFolder.Path;
}
IMediaFileStore store = DataFacade.GetData <IMediaFileStore>(x => x.Id == storeId).First();
IMediaFileFolder folder = DataFacade.BuildNew <IMediaFileFolder>();
folder.Path = parentFolderPath;
workflow.Bindings.Add("NewFolder", folder);
workflow.Bindings.Add("FolderName", "");
workflow.Bindings.Add("ProviderName", store.DataSourceId.ProviderName);
workflow.Bindings.Add("ProvidesMetaData", false);
workflow.BindingsValidationRules.Add("FolderName", new List <ClientValidationRule> {
new NotNullClientValidationRule()
});
}
private IWatermarkConfiguration GetWatermarkConfigOrDefault(NameValueCollection queryString)
{
try
{
IMediaFile mediaFile = MediaUrlHelper.GetFileFromQueryString(queryString);
using (var connection = new DataConnection())
{
IQueryable <IWatermarkConfiguration> configs = connection.Get <IWatermarkConfiguration>();
foreach (IWatermarkConfiguration config in configs)
{
IMediaFileFolder mediaFolder =
connection.Get <IMediaFileFolder>().SingleOrDefault(mf => mf.KeyPath == config.TargetMediaFolderPath);
if (mediaFolder != null && mediaFile.CompositePath.StartsWith(mediaFolder.CompositePath))
{
return(config);
}
}
}
}
// ReSharper disable once EmptyGeneralCatchClause
catch (Exception)
{
}
return(null);
}
/*private string CreateFolderPath(IMediaFileFolder folder)
* {
* string folderName = this.GetBinding<string>("FolderName");
*
* string folderPath = folder.Path;
*
* if (folderPath == "/")
* {
* folderPath = folderPath + folderName;
* }
* else
* {
* folderPath = folderPath + "/" + folderName;
* }
*
* folderPath = folderPath.Replace('\\', '/');
* while (folderPath.Contains("//"))
* {
* folderPath.Replace("//", "/");
* }
*
* if ((folderPath != "/") && (folderPath.StartsWith("/")))
* {
* folderPath.Remove(0, 1);
* }
*
* return folderPath;
* }*/
private void finalizeCodeActivity_ExecuteCode(object sender, EventArgs e)
{
AddNewTreeRefresher addNewTreeRefresher = this.CreateAddNewTreeRefresher(this.EntityToken);
IMediaFileFolder folder = this.GetBinding <IMediaFileFolder>("NewFolder");
string folderName = this.GetBinding <string>("FolderName");
string providerName = this.GetBinding <string>("ProviderName");
string folderPath = folder.CreateFolderPath(folderName);
folder.Path = folderPath;
if (folder.Title == string.Empty)
{
folder.Title = folderPath.GetFolderName('/');
}
CreateParentFolder(folder.GetParentFolderPath(), providerName);
folder = DataFacade.AddNew <IMediaFileFolder>(folder, providerName);
addNewTreeRefresher.PostRefreshMesseges(folder.GetDataEntityToken());
SelectElement(folder.GetDataEntityToken());
}
public IData GetParent(IData data)
{
IData parent = null;
if (data is IMediaFile)
{
IMediaFile file = (IMediaFile)data;
parent = (from item in DataFacade.GetData <IMediaFileFolder>()
where item.Path == file.FolderPath && item.StoreId == file.StoreId
select item).FirstOrDefault();
}
else if (data is IMediaFileFolder)
{
IMediaFileFolder folder = (IMediaFileFolder)data;
int lastIndex = folder.Path.LastIndexOf('/');
if (lastIndex == 0)
{
return(null);
}
string parentPath = folder.Path.Substring(0, lastIndex);
parent = (from item in DataFacade.GetData <IMediaFileFolder>()
where item.Path == parentPath && item.StoreId == folder.StoreId
select item).FirstOrDefault();
}
else
{
throw new ArgumentException("Must be either of type IMediaFile or IMediaFileFolder", "data");
}
return(parent);
}
private void ValidateInputs(object sender, ConditionalEventArgs e)
{
IMediaFileFolder folder = this.GetDataItemFromEntityToken <IMediaFileFolder>();
string oldFolderPath = this.GetBinding <string>("OldFolderPath");
string folderPath = CreateFolderPath();
if (oldFolderPath != folderPath)
{
Guid folderId = folder.Id;
if (DataFacade.GetData <IMediaFileFolder>()
.Any(f => string.Compare(f.Path, folderPath, StringComparison.OrdinalIgnoreCase) == 0 &&
f.Id != folderId))
{
ShowFieldMessage("FolderName", StringResourceSystemFacade.GetString("Composite.Management", "Website.Forms.Administrative.AddNewMediaFolder.FolderNameAlreadyUsed"));
e.Result = false;
return;
}
IEnumerable <string> filenames = DataFacade.GetData <IMediaFile>().Where(f => f.FolderPath == oldFolderPath).Select(f => f.FileName);
foreach (string filename in filenames)
{
string compositePath = IMediaFileExtensions.GetCompositePath(folder.StoreId, folderPath, filename);
if (compositePath.Length > 2048)
{
this.ShowFieldMessage("FolderName", "${Composite.Management, Website.Forms.Administrative.EditMediaFolder.TotalFilenameToLong.Message}");
e.Result = false;
return;
}
}
}
e.Result = true;
}
public static IEnumerable <DataReferenceLabelPair <IImageFile> > GenerateSelectorOptions(DataReference <IMediaFileFolder> folderReference)
{
IMediaFileFolder folder = null;
if (folderReference.IsSet)
{
try
{
folder = folderReference.Data;
}
catch (Exception)
{
string reference = folderReference.Serialize() ?? string.Empty;
LoggingService.LogError(LogTitle, "Failed to get media folder by referece: '{0}'".FormatWith(reference));
}
}
if (folder != null)
{
int pathLength = folder.Path.Length;
return
(from mediaFile in DataFacade.GetData <IImageFile>()
where mediaFile.StoreId == folder.StoreId && mediaFile.FolderPath.StartsWith(folder.Path)
orderby mediaFile.StoreId, mediaFile.FolderPath, mediaFile.FileName
select new DataReferenceLabelPair <IImageFile>(mediaFile, mediaFile.FolderPath.Substring(pathLength) + "/" + mediaFile.FileName));
}
// Returning all of the images
return
(from mediaFile in DataFacade.GetData <IImageFile>()
orderby mediaFile.StoreId, mediaFile.FolderPath, mediaFile.FileName
select new DataReferenceLabelPair <IImageFile>(mediaFile, mediaFile.StoreId + ":" + mediaFile.FolderPath + "/" + mediaFile.FileName));
}
public static IEnumerable <DataReferenceLabelPair <IMediaFile> > GenerateSelectorOptions(string key)
{
string folderString = key.Split('?')[0];
string extensionFilter = key.Split('?')[1];
bool includeSubfolders = bool.Parse(key.Split('?')[2]);
IQueryable <IMediaFile> queryable = DataFacade.GetData <IMediaFile>();
bool filterByFolder = !folderString.IsNullOrEmpty();
IMediaFileFolder folder = null;
if (filterByFolder)
{
var folderReference = new DataReference <IMediaFileFolder>(folderString);
folder = folderReference.Data;
string storeId = folder.StoreId;
queryable = queryable.Where(mediaFile => mediaFile.StoreId == storeId);
string folderPath = folder.Path;
if (!includeSubfolders)
{
queryable = queryable.Where(mediaFile => mediaFile.FolderPath == folderPath);
}
else
{
string descFolderPrefix = folderPath + "/";
queryable = queryable.Where(mediaFile => mediaFile.FolderPath == folderPath || mediaFile.FolderPath.StartsWith(descFolderPrefix));
}
}
if (!extensionFilter.IsNullOrEmpty())
{
Expression <Func <IMediaFile, bool> > filter = GetExtensionFilter(extensionFilter);
if (filter != null)
{
queryable = queryable.Where(filter);
}
}
// orderby mediaFile.StoreId, mediaFile.FolderPath, mediaFile.FileName
queryable = queryable.OrderBy(file => file.StoreId).ThenBy(file => file.FolderPath).ThenBy(file => file.FileName);
if (filterByFolder)
{
int pathLength = folder.Path.Length;
return(from mediaFile in queryable
select new DataReferenceLabelPair <IMediaFile>(mediaFile, mediaFile.FolderPath.Substring(pathLength) + "/" + mediaFile.FileName));
}
return(from mediaFile in queryable
select new DataReferenceLabelPair <IMediaFile>(mediaFile, mediaFile.StoreId + ":" + mediaFile.FolderPath + "/" + mediaFile.FileName));
}
private static void CreateFolder(IList <IMediaFileFolder> folders, string parentPath, string directoryEntryName)
{
IMediaFileFolder folder = DataFacade.BuildNew <IMediaFileFolder>();
folder.Title = directoryEntryName.GetFolderName('/');
folder.Path = parentPath.Combine(directoryEntryName, '/');
folders.Add(folder);
}
private void ValidateFolderData(IMediaFileFolder mediaFolder)
{
if (!mediaFolder.Path.IsCorrectFolderName('/'))
{
throw new ArgumentException("Invalid folder name");
}
if (!DoesFolderExists(mediaFolder.GetParentFolderPath()))
{
throw new ArgumentException("Could not find any parents folders on path " + mediaFolder.GetParentFolderPath());
}
if (DoesFolderExists(mediaFolder.Path))
{
throw new ArgumentException("Folder already exists on path " + mediaFolder.Path);
}
}
private void CreateParentFolder(string parentFolder, string providerName)
{
if (IMediaFileFolderUtils.DoesFolderExists(parentFolder))
{
return;
}
CreateParentFolder(IMediaFileFolderUtils.GetParentFolderPath(parentFolder), providerName);
IMediaFileFolder folder = DataFacade.BuildNew <IMediaFileFolder>();
folder.Path = parentFolder;
DataFacade.AddNew <IMediaFileFolder>(folder, providerName);
}
private void saveCodeActivity_ExecuteCode(object sender, EventArgs e)
{
UpdateTreeRefresher updateTreeRefresher = this.CreateUpdateTreeRefresher(this.EntityToken);
IMediaFileFolder folder = this.GetDataItemFromEntityToken <IMediaFileFolder>();
folder.Path = CreateFolderPath();
folder.Title = this.GetBinding <string>("FolderTitle");
folder.Description = this.GetBinding <string>("FolderDescription");
DataFacade.Update(folder);
SetSaveStatus(true);
updateTreeRefresher.PostRefreshMesseges(folder.GetDataEntityToken());
}
private void Initialize()
{
if (this.EntityToken is MediaRootFolderProviderEntityToken)
{
MediaRootFolderProviderEntityToken token = (MediaRootFolderProviderEntityToken)this.EntityToken;
_storeId = token.Id;
_folderPath = "/";
}
else
{
DataEntityToken token = (DataEntityToken)this.EntityToken;
IMediaFileFolder parentFolder = (IMediaFileFolder)token.Data;
_storeId = parentFolder.StoreId;
_folderPath = parentFolder.Path;
}
}
private void UpdateMediaFileFolder(IMediaFileFolder updatedFolder)
{
Guid mediaFolderId = updatedFolder.Id;
IMediaFolderData currentFolderData = DataFacade.GetData <IMediaFolderData>(x => x.Id == mediaFolderId).First();
if (updatedFolder.Path != currentFolderData.Path)
{
ValidateFolderData(updatedFolder);
}
string oldPath = currentFolderData.Path;
string oldPathWithSlash = oldPath + "/";
List <IMediaFolderData> foldersToUpdatePath =
(from item in DataFacade.GetData <IMediaFolderData>()
where item.Path.StartsWith(oldPathWithSlash) && item.Id != currentFolderData.Id
select item).ToList();
if (foldersToUpdatePath.Count > 0)
{
foreach (IMediaFolderData item in foldersToUpdatePath)
{
item.Path = updatedFolder.Path + item.Path.Substring(oldPath.Length);
}
DataFacade.Update(foldersToUpdatePath);
}
List <IMediaFileData> filesToUpdatePath =
(from item in DataFacade.GetData <IMediaFileData>()
where item.FolderPath == oldPath ||
item.FolderPath.StartsWith(oldPathWithSlash)
select item).ToList();
if (filesToUpdatePath.Count > 0)
{
foreach (IMediaFileData mediaFileData in filesToUpdatePath)
{
mediaFileData.FolderPath = updatedFolder.Path + mediaFileData.FolderPath.Substring(oldPath.Length);
}
DataFacade.Update(filesToUpdatePath);
}
CopyFolderData(updatedFolder, currentFolderData);
DataFacade.Update(currentFolderData);
}
private MediaFileFolder AddMediaFileFolder(IMediaFileFolder mediaFolder)
{
ValidateFolderData(mediaFolder);
var folderData = DataFacade.BuildNew <IMediaFolderData>();
folderData.Id = Guid.NewGuid();
CopyFolderData(mediaFolder, folderData);
folderData = DataFacade.AddNew <IMediaFolderData>(folderData);
return(new MediaFileFolder(folderData, Store.Id, _context.CreateDataSourceId(
new MediaDataId
{
MediaType = MediaElementType.Folder,
Id = folderData.Id
},
typeof(IMediaFileFolder))));
}
private void initializeCodeActivity_ExecuteCode(object sender, EventArgs e)
{
IMediaFileFolder folder = this.GetDataItemFromEntityToken <IMediaFileFolder>();
IMediaFileStore store = DataFacade.GetData <IMediaFileStore>(x => x.Id == folder.StoreId).First();
this.Bindings.Add("FolderTitle", folder.Title);
this.Bindings.Add("FolderDescription", folder.Description);
this.Bindings.Add("FolderName", folder.Path.GetFolderName('/'));
this.Bindings.Add("ProvidesMetaData", store.ProvidesMetadata);
this.Bindings.Add("OldFolderPath", folder.Path);
this.BindingsValidationRules.Add("FolderName", new List <ClientValidationRule> {
new NotNullClientValidationRule()
});
this.BindingsValidationRules.Add("FolderTitle", new List <ClientValidationRule> {
new StringLengthClientValidationRule(0, 256)
});
}
public override object Execute(ParameterList parameters, FunctionContextContainer context)
{
var mediaFolderReference = parameters.GetParameter <DataReference <IMediaFileFolder> >("MediaFolder");
Verify.ArgumentNotNull(mediaFolderReference, "mediaFolderReference");
bool includeSubfolders = parameters.GetParameter <bool>("IncludeSubfolders");
IMediaFileFolder mediaFolder = GetMediaFolder(mediaFolderReference);
if (mediaFolder == null)
{
return((Expression <Func <TMedia, bool> >)(f => false));
}
string mediaFolderPath = mediaFolder.Path;
string mediaFolderPathWithSlash = mediaFolder.Path + "/";
if (includeSubfolders)
{
//return (Expression<Func<TMedia, bool>>)
// (image => image.FolderPath == mediaFolderPath
// || image.FolderPath.StartsWith(mediaFolderPathWithSlash));
var imageParam = Expression.Parameter(typeof(TMedia), "image");
var orElse = Expression.OrElse(
Expression.Equal(Expression.Property(imageParam, MethodInfoGetFolderPath),
Expression.Constant(mediaFolderPath)),
Expression.Call(Expression.Property(imageParam, MethodInfoGetFolderPath),
MethodInfoStringStartsWith,
new Expression[] { Expression.Constant(mediaFolderPathWithSlash) }));
return(Expression.Lambda <Func <TMedia, bool> >(orElse, imageParam));
}
// return (Expression<Func<TMedia, bool>>)(imageParam1 => imageParam1.FolderPath == mediaFolderPath);
var imageParam1 = Expression.Parameter(typeof(TMedia), "image");
return(Expression.Lambda <Func <TMedia, bool> >(
Expression.Equal(Expression.Property(imageParam1, MethodInfoGetFolderPath),
Expression.Constant(mediaFolderPath)),
imageParam1));
}
public List <T> AddNew <T>(IEnumerable <T> datas) where T : class, IData
{
List <T> result = new List <T>();
foreach (IData data in datas)
{
if (data == null)
{
throw new ArgumentException("Data in list to add must be non-null");
}
CheckInterface(typeof(T));
}
foreach (IData data in datas)
{
if (typeof(T) == typeof(IMediaFile))
{
IMediaFile file = (IMediaFile)data;
string fullPath = Path.Combine(Path.Combine(_rootDir, file.FolderPath.Remove(0, 1)), file.FileName);
using (Stream readStream = file.GetReadStream())
{
using (Stream writeStream = C1File.Open(fullPath, FileMode.CreateNew))
{
readStream.CopyTo(writeStream);
}
}
result.Add(CreateFile(fullPath) as T);
}
else if (typeof(T) == typeof(IMediaFileFolder))
{
IMediaFileFolder folder = (IMediaFileFolder)data;
string fullPath = Path.Combine(_rootDir, folder.Path.Remove(0, 1));
C1Directory.CreateDirectory(fullPath);
result.Add(CreateFolder(fullPath) as T);
}
}
return(result);
}
private void HasDataReferences(object sender, ConditionalEventArgs e)
{
DataEntityToken token = (DataEntityToken)this.EntityToken;
IMediaFileFolder folder = (IMediaFileFolder)token.Data;
string storeId = folder.StoreId;
string parentPath = folder.Path;
string innerElementsPathPrefix = string.Format("{0}/", parentPath);
var fileQueryable = new StoreIdFilterQueryable <IMediaFile>(DataFacade.GetData <IMediaFile>(), storeId);
IEnumerable <IMediaFile> childFiles =
(from item in fileQueryable
where item.FolderPath.StartsWith(innerElementsPathPrefix) || item.FolderPath == parentPath
select item).Evaluate();
var brokenReferences = new List <IData>();
foreach (IMediaFile mediaFile in childFiles)
{
List <IData> references = DataReferenceFacade.GetNotOptionalReferences(mediaFile);
foreach (IData reference in references)
{
if (brokenReferences.Any(data => data.DataSourceId.Equals(reference.DataSourceId)))
{
continue;
}
brokenReferences.Add(reference);
}
}
e.Result = brokenReferences.Count > 0;
if (brokenReferences.Count == 0)
{
return;
}
Bindings.Add("ReferencedData", DataReferenceFacade.GetBrokenReferencesReport(brokenReferences));
}
private void ValidateInputs(object sender, ConditionalEventArgs e)
{
e.Result = true;
IMediaFileFolder folder = this.GetBinding <IMediaFileFolder>("NewFolder");
string folderName = this.GetBinding <string>("FolderName");
string folderPath = folder.CreateFolderPath(folderName);
string tempFolderName = folderName.Replace('\\', '/').Trim();
while (tempFolderName.Contains("//"))
{
tempFolderName = tempFolderName.Replace("//", "/");
}
if (tempFolderName == "/")
{
e.Result = false;
ShowFieldMessage("FolderName", StringResourceSystemFacade.GetString("Composite.Management", "Website.Forms.Administrative.AddNewMediaFolder.FolderNotOnlySlash"));
return;
}
if (DataFacade.GetData <IMediaFileFolder>().Any(f => string.Compare(f.Path, folderPath, StringComparison.InvariantCultureIgnoreCase) == 0))
{
e.Result = false;
ShowFieldMessage("FolderName", StringResourceSystemFacade.GetString("Composite.Management", "Website.Forms.Administrative.AddNewMediaFolder.FolderNameAlreadyUsed"));
}
if (folderPath.Length > 2048)
{
e.Result = false;
ShowFieldMessage("FolderName", StringResourceSystemFacade.GetString("Composite.Management", "Website.Forms.Administrative.AddNewMediaFolder.FolderNameTooLong"));
}
folderPath.IsCorrectFolderName('/');
}
private string ForceGetMediaFolderPath(string path)
{
if (path == "/")
{
return(path);
}
if (!path.IsCorrectFolderName('/'))
{
throw new ArgumentException("Invalid folder name");
}
IMediaFileFolder folder = (from item in DataFacade.GetData <IMediaFileFolder>()
where item.Path == path
select item).FirstOrDefault();
if (folder == null)
{
ForceGetMediaFolderPath(GetParentFolderPath(path));
folder = DataFacade.BuildNew <IMediaFileFolder>();
folder.Path = path;
folder = DataFacade.AddNew(folder);
}
return(folder.Path);
}
public void Update(IEnumerable <IData> datas)
{
foreach (IData data in datas)
{
if (data == null)
{
throw new ArgumentException("Data in list to update must be non-null");
}
}
foreach (IData data in datas)
{
MediaDataId dataId = data.DataSourceId.DataId as MediaDataId;
if (dataId == null)
{
throw new ArgumentException("Invalid IData");
}
if (dataId.MediaType == _fileType)
{
IMediaFile updatedFile = (IMediaFile)data;
if (updatedFile.StoreId != this.Store.Id)
{
continue;
}
if (updatedFile.IsReadOnly)
{
throw new ArgumentException("Cannot update read only media file " + dataId.FileName);
}
if (updatedFile.FileName != dataId.FileName || updatedFile.FolderPath != dataId.Path)
{
string oldPos = GetAbsolutePath(dataId);
string newPos = GetAbsolutePath(updatedFile);
C1File.Move(oldPos, newPos);
}
using (Stream readStream = updatedFile.GetReadStream())
{
using (Stream writeStream = C1File.Open(GetAbsolutePath(updatedFile), FileMode.Create))
{
readStream.CopyTo(writeStream);
}
}
}
else
{
IMediaFileFolder updatedFolder = (IMediaFileFolder)data;
if (updatedFolder.StoreId != this.Store.Id)
{
continue;
}
if (updatedFolder.IsReadOnly)
{
throw new ArgumentException("Cannot update read only media folder " + dataId.Path);
}
C1Directory.Move(GetAbsolutePath(dataId), GetAbsolutePath(updatedFolder));
}
}
}
private string GetAbsolutePath(IMediaFileFolder folder)
{
return(Path.Combine(_rootDir, folder.Path.Remove(0, 1)));
}
/// <summary>
/// Returns true if the given media folders parent folder exists
/// </summary>
/// <param name="mediaFileFolder"></param>
/// <returns></returns>
public static bool DoesParentFolderExists(this IMediaFileFolder mediaFileFolder)
{
return(DoesFolderExists(mediaFileFolder.GetParentFolderPath()));
}
/// <summary>
/// Returns true if the given media folder exists
/// </summary>
/// <param name="mediaFileFolder"></param>
/// <returns></returns>
public static bool DoesFolderExists(this IMediaFileFolder mediaFileFolder)
{
return(DoesFolderExists(mediaFileFolder.Path));
}
/// <summary>
/// Returns the parent folder for the given media folder
/// </summary>
/// <param name="mediaFileFolder"></param>
/// <returns></returns>
public static string GetParentFolderPath(this IMediaFileFolder mediaFileFolder)
{
return(GetParentFolderPath(mediaFileFolder.Path));
}
/// <summary>
/// Creates a folder path given folder path and the name of the folder
/// </summary>
/// <param name="parentMediaFolder"></param>
/// <param name="folderName"></param>
/// <returns></returns>
public static string CreateFolderPath(this IMediaFileFolder parentMediaFolder, string folderName)
{
return(CreateFolderPath(parentMediaFolder.Path, folderName));
}
public static string GetCompositePath(this IMediaFileFolder mediaFileFolder)
{
return(string.Format("{0}:{1}", mediaFileFolder.StoreId, mediaFileFolder.Path));
}
