private (ObservableCollection <string>, ObservableCollection <string>, bool userHaveAccess) getDirContent(DirectoryInfo currentDirectory)
{
ObservableCollection <string> files = new ObservableCollection <string>();
ObservableCollection <string> dirs = new ObservableCollection <string>();
bool userHaveAccess = false;
try
{
if (currentDirectory.FullName.Equals("/storage"))
{
dirs = currentDirectory.GetDirectories().Where(d => !d.Name.Equals("emulated")).OrderBy(d => d.Name).Select(d => d.Name)
.ToObservableCollection();
dirs.Add("/storage/emulated/0");
}
else
{
dirs = currentDirectory.GetDirectories().OrderBy(d => d.Name).Select(d => d.Name)
.ToObservableCollection();
}
MediaFileManager mediaFileManager = new MediaFileManager();
files = mediaFileManager.GetMediaFilesFromDirectory(currentDirectory).OrderByDescending(f => f.CreationTime)
.Select(f => f.FullName).ToArray().ToObservableCollection();;
userHaveAccess = true;
}
catch (IOException ioException)
{
HandleError.Process("Settings", "getDirContent", ioException, false, currentDirectory.FullName);
}
catch (UnauthorizedAccessException e)
{
HandleError.Process("Settings", "getDirContent", e, false, currentDirectory.FullName);
}
return(files, dirs, userHaveAccess);
}
public async void StartDialog()
{
PermissionManager permissions = new PermissionManager();
var taskPermissionRead = await permissions.CheckAndRequestStorageReadPermission();
if (taskPermissionRead.HasFlag(Xamarin.Essentials.PermissionStatus.Granted))
{
ImagesCacheDbManager imagesCache = new ImagesCacheDbManager(new ImageManager(), DateTime.Now.AddDays(90), DateTime.Now);
ParameterManager parameterManager = new ParameterManager();
_initDCIMDirectory = string.Empty;
if (!parameterManager.Get("CameraDirectoryFullPath", out _initDCIMDirectory))
{
//параметр заполняется при старте индексации, уже должен быть заполнен
_initDCIMDirectory = imagesCache.GetPublicDirectoryDcim();
}
PathToDefaultDCIM = imagesCache.GetPublicDirectoryDcim();
PathToCustomDCIM = _initDCIMDirectory;
IsUsageMainMemory = _initDCIMDirectory.Equals(PathToDefaultDCIM);
await Task.Run(() =>
{
MediaFileManager mediaFileManager = new MediaFileManager();
CountOfPhotoDefaultDCIM = mediaFileManager.GetMediaFilesFromDirectory(new DirectoryInfo(PathToDefaultDCIM)).Count();
_pathToImagesDir = _initDCIMDirectory;
CountOfPhotoCustomDCIM = mediaFileManager.GetMediaFilesFromDirectory(new DirectoryInfo(_initDCIMDirectory)).Count();
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("CountOfPhotoDefaultDCIM"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("CountOfPhotoCustomDCIM"));
updateDirContent(new DirectoryInfo(_pathToImagesDir));
});
}
}
public CurrentUserController(
MediaFileManager mediaFileManager,
IOptions <ContentSettings> contentSettings,
IHostingEnvironment hostingEnvironment,
IImageUrlGenerator imageUrlGenerator,
IBackOfficeSecurityAccessor backofficeSecurityAccessor,
IUserService userService,
IUmbracoMapper umbracoMapper,
IBackOfficeUserManager backOfficeUserManager,
ILoggerFactory loggerFactory,
ILocalizedTextService localizedTextService,
AppCaches appCaches,
IShortStringHelper shortStringHelper,
IPasswordChanger <BackOfficeIdentityUser> passwordChanger) : this(
mediaFileManager,
StaticServiceProvider.Instance.GetRequiredService <IOptionsSnapshot <ContentSettings> >(),
hostingEnvironment,
imageUrlGenerator,
backofficeSecurityAccessor,
userService,
umbracoMapper,
backOfficeUserManager,
localizedTextService,
appCaches,
shortStringHelper,
passwordChanger,
StaticServiceProvider.Instance.GetRequiredService <IUserDataService>())
{
}
public CurrentUserController(
MediaFileManager mediaFileManager,
IOptionsSnapshot <ContentSettings> contentSettings,
IHostingEnvironment hostingEnvironment,
IImageUrlGenerator imageUrlGenerator,
IBackOfficeSecurityAccessor backofficeSecurityAccessor,
IUserService userService,
IUmbracoMapper umbracoMapper,
IBackOfficeUserManager backOfficeUserManager,
ILocalizedTextService localizedTextService,
AppCaches appCaches,
IShortStringHelper shortStringHelper,
IPasswordChanger <BackOfficeIdentityUser> passwordChanger,
IUserDataService userDataService)
{
_mediaFileManager = mediaFileManager;
_contentSettings = contentSettings.Value;
_hostingEnvironment = hostingEnvironment;
_imageUrlGenerator = imageUrlGenerator;
_backofficeSecurityAccessor = backofficeSecurityAccessor;
_userService = userService;
_umbracoMapper = umbracoMapper;
_backOfficeUserManager = backOfficeUserManager;
_localizedTextService = localizedTextService;
_appCaches = appCaches;
_shortStringHelper = shortStringHelper;
_passwordChanger = passwordChanger;
_userDataService = userDataService;
}
private ScopeProvider GetScopeProvider(out Mock <IEventAggregator> eventAggregatorMock)
{
var loggerFactory = NullLoggerFactory.Instance;
var fileSystems = new FileSystems(
loggerFactory,
Mock.Of <IIOHelper>(),
Options.Create(new GlobalSettings()),
Mock.Of <IHostingEnvironment>());
var mediaFileManager = new MediaFileManager(
Mock.Of <IFileSystem>(),
Mock.Of <IMediaPathScheme>(),
loggerFactory.CreateLogger <MediaFileManager>(),
Mock.Of <IShortStringHelper>(),
Mock.Of <IServiceProvider>(),
Options.Create(new ContentSettings()));
eventAggregatorMock = new Mock <IEventAggregator>();
return(new ScopeProvider(
new AmbientScopeStack(),
new AmbientScopeContextStack(), Mock.Of <IDistributedLockingMechanismFactory>(),
Mock.Of <IUmbracoDatabaseFactory>(),
fileSystems,
new TestOptionsMonitor <CoreDebugSettings>(new CoreDebugSettings()),
mediaFileManager,
loggerFactory,
eventAggregatorMock.Object));
}
/// <summary>
/// Sets the posted file value of a property.
/// </summary>
public static void SetValue(
this IContentBase content,
MediaFileManager mediaFileManager,
MediaUrlGeneratorCollection mediaUrlGenerators,
IShortStringHelper shortStringHelper,
IContentTypeBaseServiceProvider contentTypeBaseServiceProvider,
string propertyTypeAlias,
string filename,
Stream filestream,
string culture = null,
string segment = null)
{
if (filename == null || filestream == null)
{
return;
}
filename = shortStringHelper.CleanStringForSafeFileName(filename);
if (string.IsNullOrWhiteSpace(filename))
{
return;
}
filename = filename.ToLower();
SetUploadFile(content, mediaFileManager, mediaUrlGenerators, contentTypeBaseServiceProvider, propertyTypeAlias, filename, filestream, culture, segment);
}
/// <summary>
/// Initializes a new instance of the <see cref="CreatedPackageSchemaRepository" /> class.
/// </summary>
public CreatedPackageSchemaRepository(
IUmbracoDatabaseFactory umbracoDatabaseFactory,
IHostingEnvironment hostingEnvironment,
IOptions <GlobalSettings> globalSettings,
FileSystems fileSystems,
IEntityXmlSerializer serializer,
IDataTypeService dataTypeService,
ILocalizationService localizationService,
IFileService fileService,
IMediaService mediaService,
IMediaTypeService mediaTypeService,
IContentService contentService,
MediaFileManager mediaFileManager,
IMacroService macroService,
IContentTypeService contentTypeService,
string?mediaFolderPath = null,
string?tempFolderPath = null)
{
_umbracoDatabase = umbracoDatabaseFactory.CreateDatabase();
_hostingEnvironment = hostingEnvironment;
_fileSystems = fileSystems;
_serializer = serializer;
_dataTypeService = dataTypeService;
_localizationService = localizationService;
_fileService = fileService;
_mediaService = mediaService;
_mediaTypeService = mediaTypeService;
_contentService = contentService;
_mediaFileManager = mediaFileManager;
_macroService = macroService;
_contentTypeService = contentTypeService;
_xmlParser = new PackageDefinitionXmlParser();
_createdPackagesFolderPath = mediaFolderPath ?? Constants.SystemDirectories.CreatedPackages;
_tempFolderPath = tempFolderPath ?? Constants.SystemDirectories.TempData + "/PackageFiles";
}
private static void SetUploadFile(
this IContentBase content,
MediaFileManager mediaFileManager,
MediaUrlGeneratorCollection mediaUrlGenerators,
IContentTypeBaseServiceProvider contentTypeBaseServiceProvider,
string propertyTypeAlias,
string filename,
Stream filestream,
string culture = null,
string segment = null)
{
var property = GetProperty(content, contentTypeBaseServiceProvider, propertyTypeAlias);
// Fixes https://github.com/umbraco/Umbraco-CMS/issues/3937 - Assigning a new file to an
// existing IMedia with extension SetValue causes exception 'Illegal characters in path'
string oldpath = null;
if (content.TryGetMediaPath(property.Alias, mediaUrlGenerators, out string mediaFilePath, culture, segment))
{
oldpath = mediaFileManager.FileSystem.GetRelativePath(mediaFilePath);
}
var filepath = mediaFileManager.StoreFile(content, property.PropertyType, filename, filestream, oldpath);
// NOTE: Here we are just setting the value to a string which means that any file based editor
// will need to handle the raw string value and save it to it's correct (i.e. JSON)
// format. I'm unsure how this works today with image cropper but it does (maybe events?)
property.SetValue(mediaFileManager.FileSystem.GetUrl(filepath), culture, segment);
}
private ScopeProvider GetScopeProvider(NullLoggerFactory instance)
{
var fileSystems = new FileSystems(
instance,
Mock.Of <IIOHelper>(),
Options.Create(new GlobalSettings()),
Mock.Of <IHostingEnvironment>());
var mediaFileManager = new MediaFileManager(
Mock.Of <IFileSystem>(),
Mock.Of <IMediaPathScheme>(),
instance.CreateLogger <MediaFileManager>(),
Mock.Of <IShortStringHelper>(),
Mock.Of <IServiceProvider>(),
Options.Create(new ContentSettings()));
return(new ScopeProvider(
Mock.Of <IUmbracoDatabaseFactory>(),
fileSystems,
Options.Create(new CoreDebugSettings()),
mediaFileManager,
Mock.Of <ILogger <ScopeProvider> >(),
instance,
Mock.Of <IRequestCache>(),
Mock.Of <IEventAggregator>()
));
}
public ImagesController(
MediaFileManager mediaFileManager,
IImageUrlGenerator imageUrlGenerator)
{
_mediaFileManager = mediaFileManager;
_imageUrlGenerator = imageUrlGenerator;
}
public void MediaFileManager_writes_to_physical_file_system_when_scoped_and_scope_is_completed()
{
string rootPath = HostingEnvironment.MapPathWebRoot(GlobalSettings.UmbracoMediaPhysicalRootPath);
string rootUrl = HostingEnvironment.ToAbsolute(GlobalSettings.UmbracoMediaPath);
var physMediaFileSystem = new PhysicalFileSystem(IOHelper, HostingEnvironment, GetRequiredService <ILogger <PhysicalFileSystem> >(), rootPath, rootUrl);
MediaFileManager mediaFileManager = MediaFileManager;
Assert.IsFalse(physMediaFileSystem.FileExists("f1.txt"));
using (IScope scope = ScopeProvider.CreateScope(scopeFileSystems: true))
{
using (var ms = new MemoryStream(Encoding.UTF8.GetBytes("foo")))
{
mediaFileManager.FileSystem.AddFile("f1.txt", ms);
}
Assert.IsTrue(mediaFileManager.FileSystem.FileExists("f1.txt"));
Assert.IsFalse(physMediaFileSystem.FileExists("f1.txt"));
scope.Complete();
Assert.IsTrue(mediaFileManager.FileSystem.FileExists("f1.txt"));
Assert.IsFalse(physMediaFileSystem.FileExists("f1.txt"));
}
// After scope is disposed ensure shadow wrapper writes to physical file system
Assert.IsTrue(mediaFileManager.FileSystem.FileExists("f1.txt"));
Assert.IsTrue(physMediaFileSystem.FileExists("f1.txt"));
}
public ScopeProvider(
IAmbientScopeStack ambientScopeStack,
IAmbientScopeContextStack ambientContextStack,
IDistributedLockingMechanismFactory distributedLockingMechanismFactory,
IUmbracoDatabaseFactory databaseFactory,
FileSystems fileSystems,
IOptionsMonitor <CoreDebugSettings> coreDebugSettings,
MediaFileManager mediaFileManager,
ILoggerFactory loggerFactory,
IEventAggregator eventAggregator)
{
DistributedLockingMechanismFactory = distributedLockingMechanismFactory;
DatabaseFactory = databaseFactory;
_ambientScopeStack = ambientScopeStack;
_ambientContextStack = ambientContextStack;
_fileSystems = fileSystems;
_coreDebugSettings = coreDebugSettings.CurrentValue;
_mediaFileManager = mediaFileManager;
_logger = loggerFactory.CreateLogger <ScopeProvider>();
_loggerFactory = loggerFactory;
_eventAggregator = eventAggregator;
// take control of the FileSystems
_fileSystems.IsScoped = () => AmbientScope != null && AmbientScope.ScopedFileSystems;
coreDebugSettings.OnChange(x => _coreDebugSettings = x);
}
public void MediaFileManager_Is_Singleton()
{
MediaFileManager fileManager1 = GetRequiredService <MediaFileManager>();
MediaFileManager fileManager2 = GetRequiredService <MediaFileManager>();
Assert.AreSame(fileManager1, fileManager2);
}
private ScopeProvider GetScopeProvider(out Mock <IEventAggregator> eventAggregatorMock)
{
NullLoggerFactory loggerFactory = NullLoggerFactory.Instance;
var fileSystems = new FileSystems(
loggerFactory,
Mock.Of <IIOHelper>(),
Options.Create(new GlobalSettings()),
Mock.Of <IHostingEnvironment>());
var mediaFileManager = new MediaFileManager(
Mock.Of <IFileSystem>(),
Mock.Of <IMediaPathScheme>(),
loggerFactory.CreateLogger <MediaFileManager>(),
Mock.Of <IShortStringHelper>(),
Mock.Of <IServiceProvider>(),
Options.Create(new ContentSettings()));
eventAggregatorMock = new Mock <IEventAggregator>();
return(new ScopeProvider(
Mock.Of <IUmbracoDatabaseFactory>(),
fileSystems,
Options.Create(new CoreDebugSettings()),
mediaFileManager,
loggerFactory.CreateLogger <ScopeProvider>(),
loggerFactory,
Mock.Of <IRequestCache>(),
eventAggregatorMock.Object
));
}
/// <inheritdoc />
public string GetFilePath(MediaFileManager fileManager, Guid itemGuid, Guid propertyGuid, string filename)
{
var combinedGuid = GuidUtils.Combine(itemGuid, propertyGuid);
var directory = GuidUtils.ToBase32String(combinedGuid, DirectoryLength);
return(Path.Combine(directory, filename).Replace('\\', '/'));
}
public void Can_Generate_Xml_Representation_Of_Media()
{
// Arrange
var mediaType = MockedContentTypes.CreateImageMediaType("image2");
ServiceContext.MediaTypeService.Save(mediaType);
// reference, so static ctor runs, so event handlers register
// and then, this will reset the width, height... because the file does not exist, of course ;-(
var loggerFactory = NullLoggerFactory.Instance;
var scheme = Mock.Of <IMediaPathScheme>();
var contentSettings = new ContentSettings();
var mediaFileManager = new MediaFileManager(Mock.Of <IFileSystem>(), scheme,
loggerFactory.CreateLogger <MediaFileManager>(), ShortStringHelper);
var ignored = new FileUploadPropertyEditor(DataValueEditorFactory, mediaFileManager, Microsoft.Extensions.Options.Options.Create(contentSettings), DataTypeService, LocalizationService, LocalizedTextService, UploadAutoFillProperties, ContentService);
var media = MockedMedia.CreateMediaImage(mediaType, -1);
media.WriterId = -1; // else it's zero and that's not a user and it breaks the tests
ServiceContext.MediaService.Save(media, Constants.Security.SuperUserId);
// so we have to force-reset these values because the property editor has cleared them
media.SetValue(Constants.Conventions.Media.Width, "200");
media.SetValue(Constants.Conventions.Media.Height, "200");
media.SetValue(Constants.Conventions.Media.Bytes, "100");
media.SetValue(Constants.Conventions.Media.Extension, "png");
var nodeName = media.ContentType.Alias.ToSafeAlias(ShortStringHelper);
var urlName = media.GetUrlSegment(ShortStringHelper, new[] { new DefaultUrlSegmentProvider(ShortStringHelper) });
// Act
XElement element = media.ToXml(Factory.GetRequiredService <IEntityXmlSerializer>());
// Assert
Assert.That(element, Is.Not.Null);
Assert.That(element.Name.LocalName, Is.EqualTo(nodeName));
Assert.AreEqual(media.Id.ToString(), (string)element.Attribute("id"));
Assert.AreEqual(media.ParentId.ToString(), (string)element.Attribute("parentID"));
Assert.AreEqual(media.Level.ToString(), (string)element.Attribute("level"));
Assert.AreEqual(media.SortOrder.ToString(), (string)element.Attribute("sortOrder"));
Assert.AreEqual(media.CreateDate.ToString("s"), (string)element.Attribute("createDate"));
Assert.AreEqual(media.UpdateDate.ToString("s"), (string)element.Attribute("updateDate"));
Assert.AreEqual(media.Name, (string)element.Attribute("nodeName"));
Assert.AreEqual(urlName, (string)element.Attribute("urlName"));
Assert.AreEqual(media.Path, (string)element.Attribute("path"));
Assert.AreEqual("", (string)element.Attribute("isDoc"));
Assert.AreEqual(media.ContentType.Id.ToString(), (string)element.Attribute("nodeType"));
Assert.AreEqual(media.GetCreatorProfile(ServiceContext.UserService).Name, (string)element.Attribute("writerName"));
Assert.AreEqual(media.CreatorId.ToString(), (string)element.Attribute("writerID"));
Assert.IsNull(element.Attribute("template"));
Assert.AreEqual(media.Properties[Constants.Conventions.Media.File].GetValue().ToString(), element.Elements(Constants.Conventions.Media.File).Single().Value);
Assert.AreEqual(media.Properties[Constants.Conventions.Media.Width].GetValue().ToString(), element.Elements(Constants.Conventions.Media.Width).Single().Value);
Assert.AreEqual(media.Properties[Constants.Conventions.Media.Height].GetValue().ToString(), element.Elements(Constants.Conventions.Media.Height).Single().Value);
Assert.AreEqual(media.Properties[Constants.Conventions.Media.Bytes].GetValue().ToString(), element.Elements(Constants.Conventions.Media.Bytes).Single().Value);
Assert.AreEqual(media.Properties[Constants.Conventions.Media.Extension].GetValue().ToString(), element.Elements(Constants.Conventions.Media.Extension).Single().Value);
}
private void deleteMedia(ViewRoutePointMediaObject media)
{
_log.AddStringEvent($"image deleted, passed mediaid:{media.RoutePointMediaObjectId}");
_routePointMediaManager.SetSyncStatus(media.RoutePointMediaObjectId, false, true);
_routePointMediaManager.SetSyncStatus(media.RoutePointMediaObjectId, true, true);
MediaFileManager fileManager = new MediaFileManager();
fileManager.Delete(media.RoutePointMediaObjectId, media.MediaType);
}
/// <inheritdoc />
public string GetFilePath(MediaFileManager fileManager, Guid itemGuid, Guid propertyGuid, string filename)
{
// assumes that cuid and puid keys can be trusted - and that a single property type
// for a single content cannot store two different files with the same name
var combinedGuid = GuidUtils.Combine(itemGuid, propertyGuid);
var directory = HexEncoder.Encode(combinedGuid.ToByteArray() /*'/', 2, 4*/); // could use ext to fragment path eg 12/e4/f2/...
return(Path.Combine(directory, filename).Replace('\\', '/'));
}
public UploadAutoFillProperties(
MediaFileManager mediaFileManager,
ILogger <UploadAutoFillProperties> logger,
IImageUrlGenerator imageUrlGenerator,
IImageDimensionExtractor imageDimensionExtractor)
{
_mediaFileManager = mediaFileManager ?? throw new ArgumentNullException(nameof(mediaFileManager));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_imageUrlGenerator = imageUrlGenerator ?? throw new ArgumentNullException(nameof(imageUrlGenerator));
_imageDimensionExtractor = imageDimensionExtractor ?? throw new ArgumentNullException(nameof(imageDimensionExtractor));
}
public MigrateToPackageData(
IPackagingService packagingService,
IMediaService mediaService,
MediaFileManager mediaFileManager,
MediaUrlGeneratorCollection mediaUrlGenerators,
IShortStringHelper shortStringHelper,
IContentTypeBaseServiceProvider contentTypeBaseServiceProvider,
IMigrationContext context)
: base(packagingService, mediaService, mediaFileManager, mediaUrlGenerators, shortStringHelper, contentTypeBaseServiceProvider, context)
{
}
/// <summary>
/// Creates a ScopeProvider with mocked internals.
/// </summary>
/// <param name="syntaxProviderMock">The mock of the ISqlSyntaxProvider2, used to count method calls.</param>
/// <returns></returns>
private ScopeProvider GetScopeProvider(out Mock <IDistributedLockingMechanism> lockingMechanism)
{
var loggerFactory = NullLoggerFactory.Instance;
var fileSystems = new FileSystems(
loggerFactory,
Mock.Of <IIOHelper>(),
Mock.Of <IOptions <GlobalSettings> >(),
Mock.Of <IHostingEnvironment>());
var mediaFileManager = new MediaFileManager(
Mock.Of <IFileSystem>(),
Mock.Of <IMediaPathScheme>(),
loggerFactory.CreateLogger <MediaFileManager>(),
Mock.Of <IShortStringHelper>(),
Mock.Of <IServiceProvider>(),
Options.Create(new ContentSettings()));
var databaseFactory = new Mock <IUmbracoDatabaseFactory>();
var database = new Mock <IUmbracoDatabase>();
var sqlContext = new Mock <ISqlContext>();
lockingMechanism = new Mock <IDistributedLockingMechanism>();
lockingMechanism.Setup(x => x.ReadLock(It.IsAny <int>(), It.IsAny <TimeSpan?>()))
.Returns(Mock.Of <IDistributedLock>());
lockingMechanism.Setup(x => x.WriteLock(It.IsAny <int>(), It.IsAny <TimeSpan?>()))
.Returns(Mock.Of <IDistributedLock>());
var lockingMechanismFactory = new Mock <IDistributedLockingMechanismFactory>();
lockingMechanismFactory.Setup(x => x.DistributedLockingMechanism)
.Returns(lockingMechanism.Object);
// Setup mock of database factory to return mock of database.
databaseFactory.Setup(x => x.CreateDatabase()).Returns(database.Object);
databaseFactory.Setup(x => x.SqlContext).Returns(sqlContext.Object);
// Setup mock of database to return mock of sql SqlContext
database.Setup(x => x.SqlContext).Returns(sqlContext.Object);
var syntaxProviderMock = new Mock <ISqlSyntaxProvider>();
// Setup mock of ISqlContext to return syntaxProviderMock
sqlContext.Setup(x => x.SqlSyntax).Returns(syntaxProviderMock.Object);
return(new ScopeProvider(
new AmbientScopeStack(),
new AmbientScopeContextStack(),
lockingMechanismFactory.Object,
databaseFactory.Object,
fileSystems,
new TestOptionsMonitor <CoreDebugSettings>(new CoreDebugSettings()),
mediaFileManager,
loggerFactory,
Mock.Of <IEventAggregator>()));
}
internal static IActionResult PostSetAvatarInternal(IList<IFormFile> files, IUserService userService,
IAppCache cache, MediaFileManager mediaFileManager, IShortStringHelper shortStringHelper,
ContentSettings contentSettings, IHostingEnvironment hostingEnvironment, IImageUrlGenerator imageUrlGenerator,
int id)
{
if (files is null)
{
return new UnsupportedMediaTypeResult();
}
var root = hostingEnvironment.MapPathContentRoot(Constants.SystemDirectories.TempFileUploads);
//ensure it exists
Directory.CreateDirectory(root);
//must have a file
if (files.Count == 0)
{
return new NotFoundResult();
}
IUser? user = userService.GetUserById(id);
if (user == null)
{
return new NotFoundResult();
}
if (files.Count > 1)
{
return new ValidationErrorResult(
"The request was not formatted correctly, only one file can be attached to the request");
}
//get the file info
IFormFile file = files.First();
var fileName = file.FileName.Trim(new[] { '\"' }).TrimEnd();
var safeFileName = fileName.ToSafeFileName(shortStringHelper);
var ext = safeFileName.Substring(safeFileName.LastIndexOf('.') + 1).ToLower();
if (contentSettings.DisallowedUploadFiles.Contains(ext) == false)
{
//generate a path of known data, we don't want this path to be guessable
user.Avatar = "UserAvatars/" + (user.Id + safeFileName).GenerateHash<SHA1>() + "." + ext;
using (Stream fs = file.OpenReadStream())
{
mediaFileManager.FileSystem.AddFile(user.Avatar, fs, true);
}
userService.Save(user);
}
return new OkObjectResult(user.GetUserAvatarUrls(cache, mediaFileManager, imageUrlGenerator));
}
/// <summary>
/// Stores a file.
/// </summary>
/// <param name="content"><see cref="IContentBase"/>A content item.</param>
/// <param name="propertyTypeAlias">The property alias.</param>
/// <param name="filename">The name of the file.</param>
/// <param name="filestream">A stream containing the file data.</param>
/// <param name="filepath">The original file path, if any.</param>
/// <returns>The path to the file, relative to the media filesystem.</returns>
/// <remarks>
/// <para>Does NOT set the property value, so one should probably store the file and then do
/// something alike: property.Value = MediaHelper.FileSystem.GetUrl(filepath).</para>
/// <para>The original file path is used, in the old media file path scheme, to try and reuse
/// the "folder number" that was assigned to the previous file referenced by the property,
/// if any.</para>
/// </remarks>
public static string StoreFile(this IContentBase content, MediaFileManager mediaFileManager, IContentTypeBaseServiceProvider contentTypeBaseServiceProvider, string propertyTypeAlias, string filename, Stream filestream, string filepath)
{
var contentType = contentTypeBaseServiceProvider.GetContentTypeOf(content);
var propertyType = contentType
.CompositionPropertyTypes.FirstOrDefault(x => x.Alias.InvariantEquals(propertyTypeAlias));
if (propertyType == null)
{
throw new ArgumentException("Invalid property type alias " + propertyTypeAlias + ".");
}
return(mediaFileManager.StoreFile(content, propertyType, filename, filestream, filepath));
}
public SetupuSync(
IPackagingService packagingService,
IMediaService mediaService,
MediaFileManager mediaFileManager,
MediaUrlGeneratorCollection mediaUrlGenerators,
IShortStringHelper shortStringHelper,
IContentTypeBaseServiceProvider contentTypeBaseServiceProvider,
IMigrationContext context,
IOptions <PackageMigrationSettings> packageMigrationsSettings)
: base(packagingService, mediaService, mediaFileManager, mediaUrlGenerators, shortStringHelper, contentTypeBaseServiceProvider, context, packageMigrationsSettings)
{
}
protected override void OnCreate(Bundle bundle)
{
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
base.OnCreate(bundle);
global::Xamarin.Forms.Forms.Init(this, bundle);
MediaFileManager.Initialize(Forms.Context);
LoadApplication(new App());
}
public FileUploadPropertyValueEditor(
DataEditorAttribute attribute,
MediaFileManager mediaFileManager,
ILocalizedTextService localizedTextService,
IShortStringHelper shortStringHelper,
IOptions <ContentSettings> contentSettings,
IJsonSerializer jsonSerializer,
IIOHelper ioHelper)
: base(localizedTextService, shortStringHelper, jsonSerializer, ioHelper, attribute)
{
_mediaFileManager = mediaFileManager ?? throw new ArgumentNullException(nameof(mediaFileManager));
_contentSettings = contentSettings.Value ?? throw new ArgumentNullException(nameof(contentSettings));
}
public ScopeProvider(IUmbracoDatabaseFactory databaseFactory, FileSystems fileSystems, IOptions <CoreDebugSettings> coreDebugSettings, MediaFileManager mediaFileManager, ILogger <ScopeProvider> logger, ILoggerFactory loggerFactory, IRequestCache requestCache, IEventAggregator eventAggregator)
{
DatabaseFactory = databaseFactory;
_fileSystems = fileSystems;
_coreDebugSettings = coreDebugSettings.Value;
_mediaFileManager = mediaFileManager;
_logger = logger;
_loggerFactory = loggerFactory;
_requestCache = requestCache;
_eventAggregator = eventAggregator;
// take control of the FileSystems
_fileSystems.IsScoped = () => AmbientScope != null && AmbientScope.ScopedFileSystems;
}
protected override void Compose()
{
base.Compose();
_publishedSnapshotAccessorMock = new Mock <IPublishedSnapshotAccessor>();
Builder.Services.AddUnique <IPublishedSnapshotAccessor>(_publishedSnapshotAccessorMock.Object);
Builder.Services.AddUnique <IPublishedModelFactory>(f => new PublishedModelFactory(f.GetRequiredService <TypeLoader>().GetTypes <PublishedContentModel>(), f.GetRequiredService <IPublishedValueFallback>()));
Builder.Services.AddUnique <IPublishedContentTypeFactory, PublishedContentTypeFactory>();
Builder.Services.AddUnique <IPublishedValueFallback, PublishedValueFallback>();
var loggerFactory = NullLoggerFactory.Instance;
var mediaService = Mock.Of <IMediaService>();
var contentTypeBaseServiceProvider = Mock.Of <IContentTypeBaseServiceProvider>();
var umbracoContextAccessor = Mock.Of <IUmbracoContextAccessor>();
var backOfficeSecurityAccessor = Mock.Of <IBackOfficeSecurityAccessor>();
var publishedUrlProvider = Mock.Of <IPublishedUrlProvider>();
var imageSourceParser = new HtmlImageSourceParser(publishedUrlProvider);
var serializer = new ConfigurationEditorJsonSerializer();
var mediaFileService = new MediaFileManager(Mock.Of <IFileSystem>(), Mock.Of <IMediaPathScheme>(),
loggerFactory.CreateLogger <MediaFileManager>(), Mock.Of <IShortStringHelper>());
var pastedImages = new RichTextEditorPastedImages(umbracoContextAccessor, loggerFactory.CreateLogger <RichTextEditorPastedImages>(), HostingEnvironment, mediaService, contentTypeBaseServiceProvider, mediaFileService, ShortStringHelper, publishedUrlProvider, serializer);
var linkParser = new HtmlLocalLinkParser(umbracoContextAccessor, publishedUrlProvider);
var dataTypeService = new TestObjects.TestDataTypeService(
new DataType(new VoidEditor(DataValueEditorFactory), serializer)
{
Id = 1
},
new DataType(new TrueFalsePropertyEditor(DataValueEditorFactory, IOHelper), serializer)
{
Id = 1001
},
new DataType(new RichTextPropertyEditor(DataValueEditorFactory, backOfficeSecurityAccessor, imageSourceParser, linkParser, pastedImages, IOHelper, Mock.Of <IImageUrlGenerator>()), serializer)
{
Id = 1002
},
new DataType(new IntegerPropertyEditor(DataValueEditorFactory), serializer)
{
Id = 1003
},
new DataType(new TextboxPropertyEditor(DataValueEditorFactory, IOHelper), serializer)
{
Id = 1004
},
new DataType(new MediaPickerPropertyEditor(DataValueEditorFactory, IOHelper), serializer)
{
Id = 1005
});
Builder.Services.AddUnique <IDataTypeService>(f => dataTypeService);
}
private async Task <bool> updateImages(MediaForUpdate media, bool loadOnlyPreviewImg)
{
bool result = false;
if (!media.IsDeleted)
{
if ((media.MediaType == MediaObjectTypeEnum.Audio || (media.MediaType == MediaObjectTypeEnum.Image && !loadOnlyPreviewImg)) && (!media.OriginalServerSynced))
{
var httpStatus = await updateMediaFileAsync(media.RoutePointId, media.RoutePointMediaObjectId,
media.MediaType, false);
result = httpStatus == HttpStatusCode.OK;
_routePointMediaManager.SetSyncStatus(media.RoutePointMediaObjectId, false,
result);
if (!result)
{
_log.AddStringEvent(
$"media file update {media.RoutePointMediaObjectId}, original, http status:{HttpStatusCode.OK}");
}
}
if ((!media.PreviewServerSynced) && (media.MediaType == MediaObjectTypeEnum.Image))
{
var httpStatus = await updateMediaFileAsync(media.RoutePointId, media.RoutePointMediaObjectId,
media.MediaType, true);
bool resultPreview = httpStatus == HttpStatusCode.OK;
_routePointMediaManager.SetSyncStatus(media.RoutePointMediaObjectId, true, resultPreview);
if (!resultPreview)
{
_log.AddStringEvent(
$"media file update {media.RoutePointMediaObjectId}, preview, http status:{HttpStatusCode.OK}");
}
if (result)
{
result = resultPreview;
}
}
}
else
{
_log.AddStringEvent($"image deleted, passed mediaid:{media.RoutePointMediaObjectId}");
_routePointMediaManager.SetSyncStatus(media.RoutePointMediaObjectId, false, true);
_routePointMediaManager.SetSyncStatus(media.RoutePointMediaObjectId, true, true);
MediaFileManager fileManager = new MediaFileManager();
fileManager.Delete(media.RoutePointMediaObjectId, media.MediaType);
result = true;
}
return(result);
}
/// <summary>
/// Registers the default required middleware to run Umbraco.
/// </summary>
public void RegisterDefaultRequiredMiddleware()
{
UseUmbracoCoreMiddleware();
// Important we handle image manipulations before the static files, otherwise the querystring is just ignored.
AppBuilder.UseImageSharp();
// Get media file provider and request path/URL
MediaFileManager mediaFileManager = AppBuilder.ApplicationServices.GetRequiredService <MediaFileManager>();
if (mediaFileManager.FileSystem.TryCreateFileProvider(out IFileProvider? mediaFileProvider))
{
GlobalSettings globalSettings =
AppBuilder.ApplicationServices.GetRequiredService <IOptions <GlobalSettings> >().Value;
IHostingEnvironment?hostingEnvironment = AppBuilder.ApplicationServices.GetService <IHostingEnvironment>();
var mediaRequestPath = hostingEnvironment?.ToAbsolute(globalSettings.UmbracoMediaPath);
// Configure custom file provider for media
IWebHostEnvironment?webHostEnvironment = AppBuilder.ApplicationServices.GetService <IWebHostEnvironment>();
if (webHostEnvironment is not null)
{
webHostEnvironment.WebRootFileProvider =
webHostEnvironment.WebRootFileProvider.ConcatComposite(
new PrependBasePathFileProvider(mediaRequestPath, mediaFileProvider));
}
}
AppBuilder.UseStaticFiles();
AppBuilder.UseUmbracoPluginsStaticFiles();
// UseRouting adds endpoint routing middleware, this means that middlewares registered after this one
// will execute after endpoint routing. The ordering of everything is quite important here, see
// https://docs.microsoft.com/en-us/aspnet/core/fundamentals/routing?view=aspnetcore-5.0
// where we need to have UseAuthentication and UseAuthorization proceeding this call but before
// endpoints are defined.
AppBuilder.UseRouting();
AppBuilder.UseAuthentication();
AppBuilder.UseAuthorization();
// This must come after auth because the culture is based on the auth'd user
AppBuilder.UseRequestLocalization();
// Must be called after UseRouting and before UseEndpoints
AppBuilder.UseSession();
// DO NOT PUT ANY UseEndpoints declarations here!! Those must all come very last in the pipeline,
// endpoints are terminating middleware. All of our endpoints are declared in ext of IUmbracoApplicationBuilder
}
public static void GetAllTitles(MediaFileManager manager, BackgroundWorker worker, DoWorkEventArgs e)
{
GetAllTitles(manager.GetMediaFiles("*"), worker, e);
}
