public override string GetAbsoluteImageUrl(BaseDataMap map, object importRow, ref Item newItem, string importValue, ref LevelLogger logger)
{
var getAbsoluteImageUrlLogger = logger.CreateLevelLogger();
var src = StringUtil.ReadBetweenTags(importValue, SrcTagHtml, EndTagHtml);
if (!IsRequired && String.IsNullOrEmpty(src))
{
return String.Empty;
}
if (IsRequired && String.IsNullOrEmpty(src))
{
getAbsoluteImageUrlLogger.AddError(CategoryConstants.TheSrcForTheImageWasNullOrEmpty, String.Format("The src for the image was null or empty. This must be provided since the isRequired value is set for this field. ImportRow: {0}.",
map.GetImportRowDebugInfo(importRow)));
}
return base.GetAbsoluteImageUrl(map, importRow, ref newItem, src, ref getAbsoluteImageUrlLogger);
}
public override byte[] GetImageAsBytes(BaseDataMap map, object importRow, ref Item newItem, string importValue, ref LevelLogger logger)
{
var getImageLogger = logger.CreateLevelLogger();
var src = GetAbsoluteImageUrl(map, importRow, ref newItem, importValue, ref getImageLogger);
if (String.IsNullOrEmpty(src) && !IsRequired)
{
return null;
}
if (String.IsNullOrEmpty(src) && IsRequired)
{
getImageLogger.AddError(CategoryConstants.TheSrcForTheImageWasNullOrEmptyAfterReturnOfTheGetAbsoluteImageUrl, String.Format("The src for the image was null or empty after return of the GetAbsoluteImageUrl method in the ToImageFromImageHtmlTag field class. An src must be provided. ImportRow: {0}.",
map.GetImportRowDebugInfo(importRow)));
return null;
}
return base.GetImageAsBytes(map, importRow, ref newItem, src, ref getImageLogger);
}
public static bool AttachImageToItem(BaseDataMap map, object importRow, Item newItem, string newItemField, MediaItem imageItem, ref LevelLogger logger, string height = null, string width = null)
{
var attachImageLogger = logger.CreateLevelLogger();
if (imageItem != null)
{
if (string.IsNullOrEmpty(newItemField))
{
{
attachImageLogger.AddError(NewItemFieldIsNotDefinedForMediaitem, String.Format("NewItemField is not defined for mediaitem: {0}.",
map.GetImportRowDebugInfo(importRow)));
return false;
}
}
if (!newItem.Editing.IsEditing)
{
newItem.Editing.BeginEdit();
}
ImageField imageField = newItem.Fields[newItemField];
if (imageField.MediaID != imageItem.ID)
{
imageField.Clear();
imageField.MediaID = imageItem.ID;
if (!String.IsNullOrEmpty(height))
{
imageField.Height = height;
}
if (!String.IsNullOrEmpty(width))
{
imageField.Width = width;
}
if (!String.IsNullOrEmpty(imageItem.Alt))
{
imageField.Alt = imageItem.Alt;
}
else
{
imageField.Alt = imageItem.DisplayName;
}
return true;
}
}
return false;
}
public override void FillField(BaseDataMap map, object importRow, ref Item newItem, string importValue, out bool updatedField, ref LevelLogger logger)
{
var fillFieldLogger = logger.CreateLevelLogger();
try
{
updatedField = false;
if (ID.IsNullOrEmpty(MediaItemId))
{
fillFieldLogger.AddError(CategoryConstants.TheImageMediaLibraryPathIsNotSet, String.Format("The image media library path is not set. ImportRow: {0}.", map.GetImportRowDebugInfo(importRow)));
return;
}
var getImageAlTextLogger = fillFieldLogger.CreateLevelLogger("GetImageAltText");
var imageAltText = GetImageAltText(map, importRow, ref newItem, importValue, ref fillFieldLogger);
if (getImageAlTextLogger.HasErrors())
{
getImageAlTextLogger.AddError(CategoryConstants.GetimagealttextMethodFailed, String.Format("The method GetImageAltText failed. ImportRow: {0}.", map.GetImportRowDebugInfo(importRow)));
return;
}
var getOriginalFileNameLogger = fillFieldLogger.CreateLevelLogger("GetOriginalFileNameWithExtension");
var originalFileNameWithExtension = GetOriginalFileNameWithExtension(map, importRow, ref newItem, importValue, ref getOriginalFileNameLogger);
if (getOriginalFileNameLogger.HasErrors())
{
getOriginalFileNameLogger.AddError(CategoryConstants.GetoriginalfilenamewithextensionFailed, String.Format("The method GetOriginalFileNameWithExtension failed. ImportRow: {0}.", map.GetImportRowDebugInfo(importRow)));
return;
}
var getFileNameLogger = fillFieldLogger.CreateLevelLogger("GetFileName");
var fileName = GetFileName(map, importRow, ref newItem, importValue, ref getFileNameLogger);
if (getFileNameLogger.HasErrors())
{
getFileNameLogger.AddError(CategoryConstants.GetfilenameFailed, String.Format("The method GetFileName failed. ImportRow: {0}.", map.GetImportRowDebugInfo(importRow)));
return;
}
fileName = StringUtility.GetNewItemName(fileName, map.ItemNameMaxLength);
if (!IsRequired && String.IsNullOrEmpty(importValue))
{
return;
}
var imageType = "";
var getImageAsMemoryStreamLogger = fillFieldLogger.CreateLevelLogger("GetImageAsMemoryStream");
var memoryStream = GetImageAsMemoryStream(map, importRow, ref newItem, importValue, ref getImageAsMemoryStreamLogger, out imageType);
if (getImageAsMemoryStreamLogger.HasErrors())
{
getImageAsMemoryStreamLogger.AddError(CategoryConstants.GetImageAsMemoryStreamFailed, String.Format("The method GetImageAsMemoryStream failed. ImportRow: {0}.", map.GetImportRowDebugInfo(importRow)));
return;
}
if (memoryStream == null && !IsRequired)
{
return;
}
if (String.IsNullOrEmpty(originalFileNameWithExtension))
{
if (!String.IsNullOrEmpty(imageType))
{
originalFileNameWithExtension = imageType;
}
else
{
originalFileNameWithExtension = ".jpeg";
}
}
var getMediaFolderLogger = fillFieldLogger.CreateLevelLogger("GetMediaFolderItem");
var mediaItemId = GetMediaFolderItem(map, importRow, ref newItem, ref getMediaFolderLogger);
if (mediaItemId == (ID)null)
{
getMediaFolderLogger.AddError(CategoryConstants.GetMediaFolderItemReturnedANullItemForTheMediaFolderitem, String.Format("The method GetMediaFolderItem returned a null item for the media folderItem. ImportRow: {0}.", map.GetImportRowDebugInfo(importRow)));
return;
}
if (getMediaFolderLogger.HasErrors())
{
getMediaFolderLogger.AddError(CategoryConstants.GetMediaFolderItemFailed, String.Format("The method GetMediaFolderItem failed with an error. ImportRow: {0}.", map.GetImportRowDebugInfo(importRow)));
return;
}
var imageItem = ImageHandler.ImageHelper(fileName, originalFileNameWithExtension, imageAltText, mediaItemId, IsReplaceIfExist, memoryStream, ref fillFieldLogger);
if (imageItem != null)
{
var height = GetImageHeight(map, importRow, ref newItem, importValue, ref fillFieldLogger);
var width = GetImageWidth(map, importRow, ref newItem, importValue, ref fillFieldLogger);
ImageHandler.AttachImageToItem(map, importRow, newItem, NewItemField, imageItem, ref fillFieldLogger, height, width);
}
}
catch (Exception ex)
{
updatedField = false;
fillFieldLogger.AddError(CategoryConstants.ExceptionOccuredWhileProcessingImageImages, String.Format(
"An exception occured in FillField in processing of the image/images. Exception: {0}. ImportRow: {1}.",
map.GetExceptionDebugInfo(ex), map.GetImportRowDebugInfo(importRow)));
}
}
public virtual string GetFileName(BaseDataMap map, object importRow, ref Item newItem, string importValue, ref LevelLogger logger)
{
var getFileNameLogger = logger.CreateLevelLogger();
var fileNameFieldName = GetFileNameFromWhatField;
if (String.IsNullOrEmpty(fileNameFieldName))
{
getFileNameLogger.AddError(CategoryConstants.GetFilenameFromwWhatFieldWasNullOrEmpty, String.Format("The 'GetFileNameFromWhatField' was null or empty. Please indicate which field the filename should be retrieved from. ImportRow: {0}.",
map.GetImportRowDebugInfo(importRow)));
return null;
}
var fileName = map.GetFieldValue(importRow, fileNameFieldName, ref getFileNameLogger);
if (String.IsNullOrEmpty(fileName))
{
getFileNameLogger.AddError(CategoryConstants.TheFilenameFromFieldWasNullOrEmpty, String.Format("The filename was attempted retrieved from the field '{0}', but it was null or empty. The image field name must be provided. ImportRow: {1}.",
fileNameFieldName, map.GetImportRowDebugInfo(importRow)));
return null;
}
return fileName;
}
public override void FillField(BaseDataMap map, object importRow, ref Item newItem, string importValue, out bool updatedField, ref LevelLogger logger)
{
var fillFieldLogger = logger.CreateLevelLogger();
try
{
updatedField = false;
string errorMessage = String.Empty;
string newTimeStamp;
var isUpdateMediaItemLogger = fillFieldLogger.CreateLevelLogger();
var isUpdateMediaItem = IsUpdateMediaItem(map, importRow, ref newItem, importValue, ref isUpdateMediaItemLogger, out newTimeStamp);
if (isUpdateMediaItemLogger.HasErrors())
{
fillFieldLogger.AddError("IsUpdateMediaItem failed with error", String.Format("The method IsUpdateMediaItem failed with the following error: {0}. ImportRow: {1}.",
errorMessage, map.GetImportRowDebugInfo(importRow)));
DeleteMediaItemIfEmpty(map, ref newItem, ref fillFieldLogger);
return;
}
if (isUpdateMediaItem)
{
var getImageAltLogger = fillFieldLogger.CreateLevelLogger();
var imageAltText = GetImageAltText(map, importRow, ref newItem, importValue, ref getImageAltLogger);
if (getImageAltLogger.HasErrors())
{
getImageAltLogger.AddError("GetImageAltText failed with error", String.Format(
"The method GetImageAltText failed with the following error: {0}. ImportRow: {1}.",
errorMessage, map.GetImportRowDebugInfo(importRow)));
DeleteMediaItemIfEmpty(map, ref newItem, ref getImageAltLogger);
return;
}
var getOriginalLogger = fillFieldLogger.CreateLevelLogger();
var originalFileNameWithExtension = GetOriginalFileNameWithExtension(map, importRow, ref newItem,
importValue, ref getOriginalLogger);
if (getOriginalLogger.HasErrors())
{
getOriginalLogger.AddError("GetOriginalFileNameWithExtensio failed", String.Format("The method GetOriginalFileNameWithExtension failed with the following error: {0}. ImportRow: {1}.",
errorMessage, map.GetImportRowDebugInfo(importRow)));
DeleteMediaItemIfEmpty(map, ref newItem, ref getOriginalLogger);
return;
}
if (!IsRequired && String.IsNullOrEmpty(importValue))
{
return;
}
var imageType = "";
var getImageAsMemoryLogger = fillFieldLogger.CreateLevelLogger();
var memoryStream = GetImageAsMemoryStream(map, importRow, ref newItem, importValue, ref getImageAsMemoryLogger, out imageType);
if (getImageAsMemoryLogger.HasErrors())
{
getImageAsMemoryLogger.AddError("GetImageAsStream failed", String.Format("The method GetImageAsStream failed with the following error: {0}. ImportRow: {1}.",
errorMessage, map.GetImportRowDebugInfo(importRow)));
DeleteMediaItemIfEmpty(map, ref newItem, ref getImageAsMemoryLogger);
return;
}
if (memoryStream == null && !IsRequired)
{
return;
}
if (String.IsNullOrEmpty(originalFileNameWithExtension))
{
if (!String.IsNullOrEmpty(imageType))
{
originalFileNameWithExtension = imageType;
}
else
{
originalFileNameWithExtension = DefaultMediaType;
}
}
var imageHelperLogger = fillFieldLogger.CreateLevelLogger();
var imageItem = ImageHandler.ImageHelper(newItem.Name, originalFileNameWithExtension, imageAltText,
newItem.Parent.ID, true, memoryStream, ref imageHelperLogger);
if (imageItem != null)
{
newItem = imageItem;
newItem.Editing.BeginEdit();
newItem[Utility.Constants.FieldNameDataSyncTimeStamp] = newTimeStamp;
updatedField = true;
}
}
}
catch (Exception ex)
{
updatedField = false;
fillFieldLogger.AddError("Exception occured in FillField processing image/images", String.Format(
"An exception occured in FillField in processing of the image/images. Exception: {0}. ImportRow: {1}.",
map.GetExceptionDebugInfo(ex), map.GetImportRowDebugInfo(importRow)));
}
}
public virtual bool IsUpdateMediaItem(BaseDataMap map, object importRow, ref Item newItem, string importValue, ref LevelLogger logger, out string newTimeStamp)
{
var isUpdateMediaItemLogger = logger.CreateLevelLogger();
newTimeStamp = null;
if (UpdateMediaItemStrategy == UpdateStrategy.AlwaysUpdate)
{
return true;
}
if (UpdateMediaItemStrategy == UpdateStrategy.OnlyWhenUpdatedTimestamp)
{
var getTimeLogger = isUpdateMediaItemLogger.CreateLevelLogger();
var importRowTimeStamp = GetTimeStampIdentifier(map, importRow, ref newItem, importValue, ref getTimeLogger);
if (getTimeLogger.HasErrors())
{
return false;
}
if (importRowTimeStamp == null)
{
isUpdateMediaItemLogger.AddError("IsUpdateMediaItem failed when 'importRowTimeStamp' was null", String.Format(
"The method IsUpdateMediaItem failed because the 'importRowTimeStamp' was null. This field is used to retrieve the timestamp of last updated value on importRow. ImportRow: {0}.",
map.GetImportRowDebugInfo(importRow)));
return false;
}
newTimeStamp = importRowTimeStamp;
var lastUpdatedTimeStamp = newItem[Sitecore.SharedSource.DataSync.Utility.Constants.FieldNameDataSyncTimeStamp];
if (!String.IsNullOrEmpty(lastUpdatedTimeStamp))
{
return !lastUpdatedTimeStamp.Trim().ToLower().Equals(importRowTimeStamp.Trim().ToLower());
}
// If the timestamp field is empty, then we must update
return true;
}
var mediaItem = (MediaItem)newItem;
if (mediaItem != null)
{
return !mediaItem.HasMediaStream(FieldNameBlog);
}
isUpdateMediaItemLogger.AddError("Item could not be case to mediaItem in IsUpdateMediaItem", String.Format("The method IsUpdateMediaItem failed because the item could not be casted to a mediaItem and therefor we couldn't be determined if the item had a MediaStream. ImportRow: {0}.",
map.GetImportRowDebugInfo(importRow)));
return false;
}
public virtual string GetTimeStampIdentifier(BaseDataMap map, object importRow, ref Item newItem, string importValue, ref LevelLogger logger)
{
var getTimeStampLogger = logger.CreateLevelLogger();
if (String.IsNullOrEmpty(GetTimeStampIdentifierFromWhatField))
{
getTimeStampLogger.AddError("No value in 'GetTimeStampIdentifierFromWhatField'", String.Format(
"The method GetTimeStampIdentifier failed because there wasn't any value in the field 'GetTimeStampIdentifierFromWhatField'. This field is used to retrieve the timestamp of last updated value on importRow. ImportRow: {0}.",
map.GetImportRowDebugInfo(importRow)));
return null;
}
var getFieldValueLogger = getTimeStampLogger.CreateLevelLogger();
var timeStamp = map.GetFieldValue(importRow, GetTimeStampIdentifierFromWhatField, ref getFieldValueLogger);
if (String.IsNullOrEmpty(timeStamp))
{
getFieldValueLogger.AddError("GetTimeStampIdentifier failed", String.Format("The method GetTimeStampIdentifier failed because the 'timestamp' from the importRow was null or empty. Please make sure each importRow has a timestamp. ImportRow: {0}.",
map.GetImportRowDebugInfo(importRow)));
return null;
}
return timeStamp;
}
public override void FillField(BaseDataMap map, object importRow, ref Item newItem, string importValue, out bool updatedField, ref LevelLogger logger)
{
var fillFieldLogger = logger.CreateLevelLogger();
try
{
updatedField = false;
if (ID.IsNullOrEmpty(MediaItemId))
{
fillFieldLogger.AddError(CategoryConstants.TheImageMediaLibraryPathIsNotSet, String.Format("The image media library path is not set. ImportRow: {0}.", map.GetImportRowDebugInfo(importRow)));
return;
}
var getImageAlTextLogger = fillFieldLogger.CreateLevelLogger();
var imageAltText = GetImageAltText(map, importRow, ref newItem, importValue, ref fillFieldLogger);
if (getImageAlTextLogger.HasErrors())
{
getImageAlTextLogger.AddError(CategoryConstants.GetimagealttextMethodFailed, String.Format("The method GetImageAltText failed. ImportRow: {0}.", map.GetImportRowDebugInfo(importRow)));
return;
}
if (!IsRequired && String.IsNullOrEmpty(importValue))
{
return;
}
var getMediaFolderLogger = fillFieldLogger.CreateLevelLogger();
var mediaItemId = GetMediaFolderItem(map, importRow, ref newItem, ref getMediaFolderLogger);
if (mediaItemId == (ID)null)
{
getMediaFolderLogger.AddError(CategoryConstants.GetMediaFolderItemReturnedANullItemForTheMediaFolderitem, String.Format("The method GetMediaFolderItem returned a null item for the media folderItem. ImportRow: {0}.", map.GetImportRowDebugInfo(importRow)));
return;
}
if (getMediaFolderLogger.HasErrors())
{
getMediaFolderLogger.AddError(CategoryConstants.GetMediaFolderItemFailed, String.Format("The method GetMediaFolderItem failed with an error. ImportRow: {0}.", map.GetImportRowDebugInfo(importRow)));
return;
}
if(String.IsNullOrEmpty(IdentifyMediaItemByWhatFieldName))
{
fillFieldLogger.AddError("No fieldName provided to identify the MediaItem with", String.Format("There wasn't provided a fieldname to locate the MediaItem with. Please provide a value in the field 'IdentifyMediaItemByWhatField'."));
return;
}
var getMediaItemLogger = fillFieldLogger.CreateLevelLogger();
var imageItem = GetMediaItemFromImageLibrary(map, mediaItemId, IdentifyMediaItemByWhatFieldName, importValue, ref getMediaFolderLogger);
if (getMediaFolderLogger.HasErrors())
{
getMediaItemLogger.AddError("Could not find the mediaItem in Media Library", String.Format("Could not find the mediaItem in Media Libary in the GetMEdiaItemFromImageLibrary. ImportRow {0}", map.GetImportRowDebugInfo(importRow)));
return;
}
if (imageItem != null)
{
var height = GetImageHeight(map, importRow, ref newItem, importValue, ref fillFieldLogger);
var width = GetImageWidth(map, importRow, ref newItem, importValue, ref fillFieldLogger);
updatedField = ImageHandler.AttachImageToItem(map, importRow, newItem, NewItemField, imageItem, ref fillFieldLogger, height, width);
}
if(IsRequired && imageItem == null)
{
fillFieldLogger.AddError("The field is required, but no MediaItem was found", String.Format("The field is required, but no MediaItem was found. ImportRow: {0}", map.GetImportRowDebugInfo(importRow)));
return;
}
}
catch (Exception ex)
{
updatedField = false;
fillFieldLogger.AddError(CategoryConstants.ExceptionOccuredWhileProcessingImageImages, String.Format(
"An exception occured in FillField of the ToImageFieldFromImageLibrary. Exception: {0}. ImportRow: {1}.",
map.GetExceptionDebugInfo(ex), map.GetImportRowDebugInfo(importRow)));
}
}
