Umbraco MediaService/Umbraco MediaItem ne sauvegarde pas

Question

J'essaie de lire un fichier image du système de fichiers et de l'enregistrer en tant que MediaItem dans Umbraco.

Ceci est le code que je mets ensemble:

MemoryStream uploadFile = new MemoryStream(); 
using (FileStream fs = File.OpenRead(tempFilename)) 
{ 
    fs.CopyTo(uploadFile); 

    HttpPostedFileBase memoryfile = new MemoryFile(uploadFile, mimetype, Path.GetFileName(src.Value)); 
    IMedia mediaItem = _mediaService.CreateMedia(Path.GetFileName(src.Value), itNewsMediaParent, "Image"); 
    mediaItem.SetValue("umbracoFile", memoryfile); 
    _mediaService.Save(mediaItem); 
    src.Value = library.NiceUrl(mediaItem.Id); 
} 

Malheureusement, il semble que Umbraco ne peut pas enregistrer le fichier dans le dossier des médias. Il crée le nœud dans l'arborescence des médias, il définit la largeur, la hauteur et tout le reste. Cependant, il indique /media/1001/my_file_name.jpg. La section média contient déjà plusieurs images et le prochain "ID" à utiliser est "1018". Aussi, si je vérifie à l'intérieur /media/1001 il n'y a aucun signe de my_file_name.jpg.

J'ai également vérifié que la méthode SaveAs de memoryfile (qui est un HttpPostedFileBase) n'est jamais appelée.

Quelqu'un peut-il m'aider et me diriger vers la bonne direction pour résoudre ce problème?

Answer 1

Pour enregistrer les médias, j'ai trouvé cette méthode avec MediaService. Cependant, je pense qu'il est possible une autre méthode plus raffinée

[HttpPost] 
    public JsonResult Upload(HttpPostedFileBase file) 
    { 
     IMedia mimage; 

     // Create the media item 
     mimage = _mediaService.CreateMedia(file.FileName, <parentId>, Constants.Conventions.MediaTypes.Image); 
     mimage.SetValue(Constants.Conventions.Media.File, file); 
     _mediaService.Save(mimage); 

     return Json(new { success = true}); 
    } 

Answer 2

L'objet Media réagit différemment pour certains types d'objets passent à elle, dans le cas des fichiers il y a une dérogation dans les classes d'enfants qui gère un HttpPostedFile qui est créé uniquement lors d'un événement de publication de fichier mais la classe de base HttpPostedFileBase (qui fait référence à Umbraco) peut être héritée et implémentée afin que vous puissiez passer des fichiers au service média et qu'Umbraco crée le chemin de fichier correct, etc.

Dans l'exemple ci-dessous j'ai créé une nouvelle classe appelée FileImportWrapper qui hérite de HttpPostedFilebase I puis procéder à remplacer toutes les propriétés et implémenter NT ma version d'entre eux.

Pour le type de contenu, j'ai utilisé l'exemple de code présenté dans ce message stackoverflow (File extensions and MIME Types in .NET).

Voir l'exemple de code ci-dessous.

Code classe

public sealed class FileImportWrapper : HttpPostedFileBase 
    { 
     private FileInfo fileInfo; 

     public FileImportWrapper(string filePath) 
     { 
      this.fileInfo = new FileInfo(filePath); 
     } 

     public override int ContentLength 
     { 
      get 
      { 
       return (int)this.fileInfo.Length; 
      } 
     } 

     public override string ContentType 
     { 
      get 
      { 
       return MimeExtensionHelper.GetMimeType(this.fileInfo.Name); 
      } 
     } 

     public override string FileName 
     { 
      get 
      { 
       return this.fileInfo.FullName; 
      } 
     } 

     public override System.IO.Stream InputStream 
     { 
      get 
      { 
       return this.fileInfo.OpenRead(); 
      } 
     } 

     public static class MimeExtensionHelper 
     { 
      static object locker = new object(); 
      static object mimeMapping; 
      static MethodInfo getMimeMappingMethodInfo; 

      static MimeExtensionHelper() 
      { 
       Type mimeMappingType = Assembly.GetAssembly(typeof(HttpRuntime)).GetType("System.Web.MimeMapping"); 
       if (mimeMappingType == null) 
        throw new SystemException("Couldnt find MimeMapping type"); 
       ConstructorInfo constructorInfo = mimeMappingType.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null); 
       if (constructorInfo == null) 
        throw new SystemException("Couldnt find default constructor for MimeMapping"); 
       mimeMapping = constructorInfo.Invoke(null); 
       if (mimeMapping == null) 
        throw new SystemException("Couldnt find MimeMapping"); 
       getMimeMappingMethodInfo = mimeMappingType.GetMethod("GetMimeMapping", BindingFlags.Static | BindingFlags.NonPublic); 
       if (getMimeMappingMethodInfo == null) 
        throw new SystemException("Couldnt find GetMimeMapping method"); 
       if (getMimeMappingMethodInfo.ReturnType != typeof(string)) 
        throw new SystemException("GetMimeMapping method has invalid return type"); 
       if (getMimeMappingMethodInfo.GetParameters().Length != 1 && getMimeMappingMethodInfo.GetParameters()[0].ParameterType != typeof(string)) 
        throw new SystemException("GetMimeMapping method has invalid parameters"); 
      } 

      public static string GetMimeType(string filename) 
      { 
       lock (locker) 
        return (string)getMimeMappingMethodInfo.Invoke(mimeMapping, new object[] { filename }); 
      } 
     } 
    } 

Code d'utilisation

IMedia media = ApplicationContext.Current.Services.MediaService.CreateMedia("image test 1", -1, Constants.Conventions.MediaTypes.Image); 

this.mediaService.Save(media); // called it before so it creates a media id 

FileImportWrapper file = new FileImportWrapper(IOHelper.MapPath("~/App_Data/image.png")); 

media.SetValue(Constants.Conventions.Media.File, file); 

ApplicationContext.Current.Services.MediaService.Save(media); 

J'espère que cela vous aide et d'autres avec la même exigence.