Migrate Images in Media Manager automation

Consider the use-case of uploading 7500 images manually and linking each image with component in SDL  Tridion. Its very tedious tasks to do and if any change in images and need to redo 2-3 times. you need hell of a time and dedication.

So Best approach is to Automate set of tasks so that it can be imported into Media Manager and Linking can also happen side by side.

So need following set of services to accomplish this task:

1. SDL Tridion
2. Media Manager Cloud instance
3. STS Service
4. SDL Media manager Client
5. ECL Service Client

Part 1

Connecting to Media manager

STS - Security token service (STS) is a cross-platform open standard core component of the OASIS group's WS-Trust web services single sign-on specs.

STS is used to authenticate between Migration Tool and SDL media manager. setting up it required configuring public key of the  Media manager. It was the hardest part for this whole stuff.

- Generate proxy from the Media Manager Service
-  STS service should be in the running state.
- Migration tool will connect to MM using Federated Security with STS service providing the encoded MM's public certificate.
- Once connection is established the upload process triggers.

There would be two bindings in app.config  one for connecting to mediaManager another to connect to STS service running on Url like following : http://localhost:89/IWSTrust13

Note: STS service is not provide OOTB by SDL. You have to code is based on STS standard or talk to SDL if they have ready to use such service which can be leverages.

Part 2
This section is involved in ingesting assets into DAM.

Following are code snippet for digital assets migration/ingestion. code. first section create a program id and upload image

second code snipped create a distribution associated with program id.

 public string UploadFile(long folderId, long assetTypeId, long[] tags, string keywords, string fullPathToFileToUpload)  
     {  
       MediaManager2011Client mediaManagerService = null;  
       try  
       {  
         Logger.Info("Uploading Image");  
         UploadInfoData data = new UploadInfoData();  
         data.DistributionCreation=DistributionCreationOptions.OneDistributionPerItem;  
         data.IsIncludedInGalleries = true;  
         data.MakeAvailableForDownload = true;  
         data.MakeAvailableForWebPublishing = true;  
         data.ProgramCreation = ProgramCreationOptions.OneProgramPerItem;  
         mediaManagerService = new MediaManager2011Client("FederationEndpointHttps");  
         string uploadUrl = mediaManagerService.GetUploadUrl(folderId, assetTypeId, tags, keywords, data);  
         WebClient webClient = new WebClient();  
         var response= webClient.UploadFile(uploadUrl, fullPathToFileToUpload);  
         WebHeaderCollection headers = webClient.ResponseHeaders;  
         string assetIdAsString = headers["AssetId"];  
         string programIdAsString = headers["ProgramId"];  
         Logger.Debug(string.Format("Asset Id:{0} & ProgramId:{1} For Uploaded Image", assetIdAsString, programIdAsString));  
         return programIdAsString;  
       }  
       catch (Exception ex)  
       {  
         Logger.Error(string.Format("Exception caught while uploading image-{0}", ex.Message));  
         return null;  
       }  
       finally  
       {  
         if (mediaManagerService != null)  
         {  
           if (mediaManagerService.State == System.ServiceModel.CommunicationState.Faulted)  
           {  
             mediaManagerService.Abort();  
           }  
           else  
           {  
             mediaManagerService.Close();  
           }  
         }  
       }  
}

  public ItemData CreateNewDistributionData(long programId,long folderId,string distributionName, long outletId, IMediaManager2011 client)  
     {  
       var distributionData = new DistributionData();  
       distributionData.Name = distributionName;  
       distributionData.OutletId = outletId;  
       distributionData.OutletType = OutletClassifier.Image;  
       distributionData.ProgramIds = new[] { programId };  
       distributionData.IsLive = true;  
       distributionData.FolderId = folderId;  
       return client.AddItem(distributionData);  
     }  

Part 3
after images are ingested into Media Manager DAM, those needs to be linked to required components in the Tridion. so for External Content Library has to be used. Installation and configuration of ECL are very well documented on SDL Docs.

ECL Service client - Generating ECL stub is quite a task, it involves getting Media manager id and generate a stub in the CMS which actually create a component in CMS with Tcm-id. 

Stub Uri has following format: "ecl:{publicationId}-mm-{dist-Id}-dist-file"

ECL client is used to create ECL stubs in CMS. Check Detailed Article

Automation of ECL stubs creation

To generate a Stub for the image from external sources using External Content library,  its tricky to generate stub. if you have 100s of images to be imported and then putting those into SDL Tridion using ECL, its very time consuming

so we used following way to generate stub at run-time


Code Snippet:

This code create the ECL compatible URI which will be later used to generate the actual stub

 public string GetUris(string publicationId, CustomImage image)  
 {  
             if (image.d != null)  
             {  
               return string.Format("ecl:{0}-mm-{1}-dist-file", publicationId, image.Id);  
             }  
  }  

Following code is baseclass and instantiate the client to create the stub using following settings

    <endpoint name="EclBinaryEndpoint" address="net.tcp://localhost:2660/ExternalContentLibrary/2012/netTcp" binding="netTcpBinding" bindingConfiguration="EclNetTcpBinding" contract="Tridion.ExternalContentLibrary.Service.Client.ISessionAwareEclService"/>  

 public abstract class TridionEclBase  
   {  
     protected static Client tridionClient { get; set; }  
     public TridionEclBase()  
     {  
       tridionClient = Client.GetClientInstance();  
     }  
   }  

following snippet was used to create the actual stub in the CMS

 public class CreateImageStub : TridionEclBase  
   {  
     private SessionAwareEclServiceClient eclServiceClient;  
     public CreateImageStub()  
       : base()  
     { }  
     public Dictionary<string, string> CreateImageStubByEclUir(List<string> eclUrl)  
     {  
       return eclServiceClient.CreateOrGetStubUris(eclUrl);  
     }  
   }  

it returns key value pair

ECLID as key
TCMID as Value