public void Delete(IEnumerable <DataSourceId> dataSourceIds)
{
foreach (DataSourceId dataSourceId in dataSourceIds)
{
if (dataSourceId == null)
{
throw new ArgumentException("DataSourceIds must me non-null");
}
}
foreach (DataSourceId dataSourceId in dataSourceIds)
{
MediaDataId dataId = dataSourceId.DataId as MediaDataId;
if (dataId.MediaType == _fileType)
{
if (IsReadOnlyFolder(dataId.Path))
{
throw new ArgumentException("Cannot delete read only file " + dataId.FileName);
}
C1File.Delete(GetAbsolutePath(dataId));
}
else
{
if (IsReadOnlyFolder(dataId.Path))
{
throw new ArgumentException("Cannot delete read only folder " + dataId.Path);
}
C1Directory.Delete(GetAbsolutePath(dataId), true);
}
}
}
/// <exclude />
public void Update(IEnumerable <IData> dataset)
{
if (dataset.Any(data => data == null))
{
throw new ArgumentException("Data in list to update must be non-null");
}
foreach (IData data in dataset)
{
MediaDataId dataId = data.DataSourceId.DataId as MediaDataId;
if (dataId == null)
{
throw new ArgumentException("Invalid IData");
}
if (dataId.MediaType == MediaElementType.File)
{
UpdateMediaFile((IMediaFile)data);
}
else if (dataId.MediaType == MediaElementType.Folder)
{
UpdateMediaFileFolder((IMediaFileFolder)data);
}
else
{
throw new InvalidOperationException("Unexpected media type '{0}'".FormatWith(dataId.MediaType));
}
}
}
private IQueryable <IMediaFileFolder> GetMediaFileFolders()
{
IQueryable <IMediaFileFolder> mediaFoldersQuery = _mediaFoldersCachedQuery;
if (mediaFoldersQuery == null)
{
lock (_syncRoot)
{
if (_mediaFoldersCachedQuery == null)
{
var mediaFolderItems = new List <IMediaFileFolder>();
IQueryable <IMediaFolderData> folders = DataFacade.GetData <IMediaFolderData>();
var publicDataScope = DataScopeIdentifier.Public;
foreach (IMediaFolderData folder in folders)
{
var dataId = new MediaDataId {
MediaType = MediaElementType.Folder, Id = folder.Id
};
var dataSourceId = _context.CreateDataSourceId(dataId, typeof(IMediaFileFolder), publicDataScope, CultureInfo.InvariantCulture);
mediaFolderItems.Add(new MediaFileFolder(folder, Store.Id, dataSourceId));
}
_mediaFoldersCachedQuery = mediaFolderItems.AsQueryable();
}
mediaFoldersQuery = _mediaFoldersCachedQuery;
}
}
return(mediaFoldersQuery);
}
/// <exclude />
public T GetData <T>(IDataId dataId) where T : class, IData
{
if (dataId == null)
{
throw new ArgumentNullException("dataId");
}
CheckInterface(typeof(T));
MediaDataId mediaDataId = dataId as MediaDataId;
if (mediaDataId == null)
{
return(null);
}
if (mediaDataId.MediaType == MediaElementType.Folder)
{
if (typeof(T) != typeof(IMediaFileFolder))
{
throw new ArgumentException("The dataId specifies a IMediaFileFolder, but the generic method was invoked with different type");
}
IMediaFolderData folder = DataFacade.GetData <IMediaFolderData>().FirstOrDefault(x => x.Id == mediaDataId.Id);
if (folder == null)
{
return(null);
}
return(new MediaFileFolder(folder, Store.Id,
_context.CreateDataSourceId(new MediaDataId {
MediaType = MediaElementType.Folder, Id = folder.Id
}, typeof(IMediaFileFolder))) as T);
}
if (mediaDataId.MediaType == MediaElementType.File)
{
if (typeof(T) != typeof(IMediaFile))
{
throw new ArgumentException("The dataId specifies a IMediaFile, but the generic method was invoked with different type");
}
IMediaFileData file = DataFacade.GetData <IMediaFileData>().FirstOrDefault(x => x.Id == mediaDataId.Id);
if (file == null)
{
return(null);
}
string internalPath = Path.Combine(_workingDirectory, file.Id.ToString());
return(new MediaFile(file, Store.Id,
_context.CreateDataSourceId(new MediaDataId {
MediaType = MediaElementType.File, Id = file.Id
}, typeof(IMediaFile)), internalPath) as T);
}
return(Store as T);
}
private string GetAbsolutePath(MediaDataId mediaData)
{
if (mediaData.MediaType == _fileType)
{
return(Path.Combine(Path.Combine(_rootDir, mediaData.Path.Remove(0, 1)), mediaData.FileName));
}
else
{
return(Path.Combine(_rootDir, mediaData.Path.Remove(0, 1)));
}
}
private string GetAbsolutePath(MediaDataId mediaData)
{
string folderPath = Path.Combine(_rootDir, mediaData.Path.Remove(0, 1));
if (mediaData.MediaType == _fileType)
{
return(Path.Combine(folderPath, mediaData.FileName));
}
return(folderPath);
}
public T GetData <T>(IDataId dataId) where T : class, IData
{
if (dataId == null)
{
throw new ArgumentNullException("dataId");
}
CheckInterface(typeof(T));
MediaDataId mediaDataId = dataId as MediaDataId;
if (mediaDataId == null)
{
return(null);
}
if (mediaDataId.MediaType == _folderType)
{
if (typeof(T) != typeof(IMediaFileFolder))
{
throw new ArgumentException("The dataId specifies a IMediaFileFolder, but the generic method was invoked with different type");
}
FileSystemMediaFileFolder folder = (from dirInfo in C1Directory.GetDirectories(_rootDir, "*", SearchOption.AllDirectories)
where GetRelativePath(dirInfo) == mediaDataId.Path
select CreateFolder(dirInfo)).FirstOrDefault();
return(folder as T);
}
else if (mediaDataId.MediaType == _fileType)
{
if (typeof(T) != typeof(IMediaFile))
{
throw new ArgumentException("The dataId specifies a IMediaFile, but the generic method was invoked with different type");
}
FileSystemMediaFile file = (from fileInfo in C1Directory.GetFiles(_rootDir, "*", SearchOption.AllDirectories)
where GetRelativePath(Path.GetDirectoryName(fileInfo)) == mediaDataId.Path && Path.GetFileName(fileInfo) == mediaDataId.FileName
select CreateFile(fileInfo)).FirstOrDefault();
return(file as T);
}
else
{
return(Store as T);
}
}
/// <exclude />
public void Delete(IEnumerable <DataSourceId> dataSourceIds)
{
if (dataSourceIds.Any(f => f == null))
{
throw new ArgumentException("DataSourceIds must be non-null");
}
foreach (DataSourceId dataSourceId in dataSourceIds)
{
MediaDataId dataId = dataSourceId.DataId as MediaDataId;
if (dataId.MediaType == MediaElementType.Folder)
{
DeleteMediaFolder(dataId.Id);
}
else if (dataId.MediaType == MediaElementType.File)
{
DeleteMediaFile(dataId.Id);
}
else
{
throw new InvalidOperationException("Unexpected media type '{0}'".FormatWith(dataId.MediaType));
}
}
}
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));
}
}
}
