public void MapImage(CmsItem item, CmsField cmsField)
{
Item createdItem = GetItem(item.Id, Sitecore.Data.Managers.LanguageManager.GetLanguage(item.Language));
var path = _mediaRepository.ResolveMediaPath(item, createdItem, cmsField);
using (new SecurityDisabler())
{
using (new LanguageSwitcher(item.Language))
{
if (cmsField.TemplateField != null)
{
var file = cmsField.Files.FirstOrDefault();
if (file != null)
{
Item media = _mediaRepository.UploadFile(path, file);
var value = string.Format("<image mediaid=\"{0}\" />", media.ID);
createdItem.Editing.BeginEdit();
createdItem[cmsField.TemplateField.FieldName] = value;
createdItem.Editing.EndEdit();
}
}
}
}
}
public override string ResolveMediaPath(CmsItem item, Item createdItem, CmsField cmsField)
{
Field scField = createdItem.Fields[new ID(cmsField.TemplateField.FieldId)];
string dataSourcePath = GetItem(scField.ID.ToString())["Source"];
if (string.IsNullOrEmpty(dataSourcePath) || GetItem(dataSourcePath) == null)
{
dataSourcePath = MediaFolderRoot;
}
Item parent = createdItem.Parent;
string subfolder = string.Empty;
while (parent != null && ItemIsGcLinked(parent))
{
subfolder = "/" + parent.Name + subfolder;
parent = parent.Parent;
}
dataSourcePath = dataSourcePath + subfolder;
var path = string.IsNullOrEmpty(cmsField.TemplateField.FieldName)
? string.Format("{0}/{1}/", dataSourcePath, item.Title)
: string.Format("{0}/{1}/{2}/", dataSourcePath, item.Title, cmsField.TemplateField.FieldName);
return(path);
}
/// <summary>
/// </summary>
/// <param name="item"></param>
/// <param name="cmsField"></param>
public void MapText(CmsItem item, CmsField cmsField)
{
Item createdItem = GetItem(item.Id, Sitecore.Data.Managers.LanguageManager.GetLanguage(item.Language));
if (createdItem == null)
{
return;
}
using (new SecurityDisabler())
{
using (new LanguageSwitcher(item.Language))
{
createdItem.Editing.BeginEdit();
string value;
switch (cmsField.TemplateField.FieldType)
{
case "Rich Text":
value = cmsField.Value.ToString();
break;
default:
value = StringUtil.RemoveTags(cmsField.Value.ToString()).Trim();
break;
}
createdItem[cmsField.TemplateField.FieldName] = value;
createdItem.Editing.EndEdit();
}
}
}
public void MapDropTree(CmsItem item, CmsField cmsField)
{
Item createdItem = GetItem(item.Id, Sitecore.Data.Managers.LanguageManager.GetLanguage(item.Language));
if (createdItem == null)
{
return;
}
var path = _mediaRepository.ResolveMediaPath(item, createdItem, cmsField);
using (new SecurityDisabler())
{
using (new LanguageSwitcher(item.Language))
{
if (cmsField.TemplateField != null)
{
var file = cmsField.Files.FirstOrDefault();
if (file != null)
{
Item media = _mediaRepository.UploadFile(path, file, item.Title);
createdItem.Editing.BeginEdit();
createdItem[cmsField.TemplateField.FieldName] = media.ID.ToString();
createdItem.Editing.EndEdit();
_mediaRepository.CleanUp(path);
}
}
}
}
}
/// <summary>
/// </summary>
/// <param name="item"></param>
/// <param name="cmsField"></param>
public void MapFile(CmsItem item, CmsField cmsField)
{
Item createdItem = GetItem(item.Id, Sitecore.Data.Managers.LanguageManager.GetLanguage(item.Language));
if (createdItem == null)
{
return;
}
using (new SecurityDisabler())
{
using (new LanguageSwitcher(item.Language))
{
if (cmsField.TemplateField != null)
{
var file = cmsField.Files.FirstOrDefault();
if (file != null)
{
// var media = UploadFile(path, file);
var path = _mediaRepository.ResolveMediaPath(item, createdItem, cmsField);
Item media = _mediaRepository.UploadFile(path, file, item.Title);
var mediaUrl = MediaManager.GetMediaUrl(media, new MediaUrlOptions { UseItemPath = false, AbsolutePath = false });
var value = string.Format("<file mediaid=\"{0}\" src=\"{1}\" />", media.ID, mediaUrl);
createdItem.Editing.BeginEdit();
createdItem[cmsField.TemplateField.FieldName] = value;
createdItem.Editing.EndEdit();
_mediaRepository.CleanUp(path);
}
}
}
}
}
public virtual string ResolveMediaPath(CmsItem item, object createdItem, CmsField field)
{
var path = string.IsNullOrEmpty(field.TemplateField.FieldName)
? string.Format("/GatherContent/{0}/", item.Title)
: string.Format("/GatherContent/{0}/{1}/", item.Title, field.TemplateField.FieldName);
return(path);
}
public virtual string ResolveMediaPath(CmsItem item, object createdItem, CmsField field)
{
var path = string.IsNullOrEmpty(field.TemplateField.FieldName)
? $"/GatherContent/{item.Title}/"
: $"/GatherContent/{item.Title}/{field.TemplateField.FieldName}/";
return(path);
}
/// <summary>
/// </summary>
/// <param name="item"></param>
/// <param name="cmsField"></param>
public void MapChoice(CmsItem item, CmsField cmsField)
{
Item createdItem = GetItem(item.Id, Sitecore.Data.Managers.LanguageManager.GetLanguage(item.Language));
using (new SecurityDisabler())
{
using (new LanguageSwitcher(item.Language))
{
createdItem.Editing.BeginEdit();
if (cmsField.Files != null && cmsField.Files.Any())
{
var value = string.Empty;
foreach (var file in cmsField.Files)
{
if (file != null)
{
// var media = UploadFile(path, file);
var path = _mediaRepository.ResolveMediaPath(item, createdItem, cmsField);
Item media = _mediaRepository.UploadFile(path, file);
if (media != null)
{
value += media.ID + "|";
}
}
}
value = value.TrimEnd('|');
if (!string.IsNullOrEmpty(value))
{
createdItem[cmsField.TemplateField.FieldName] = value;
}
}
else if (cmsField.Options != null && cmsField.Options.Any())
{
var value = string.Empty;
foreach (var option in cmsField.Options)
{
var children = GetDatasource(createdItem, cmsField.TemplateField.FieldId, option);
//option = GC option.Label
if (children != null)
{
value += children.ID + "|";
}
}
value = value.TrimEnd('|');
if (!string.IsNullOrEmpty(value))
{
createdItem[cmsField.TemplateField.FieldName] = value;
}
}
else
{
createdItem[cmsField.TemplateField.FieldName] = string.Empty;
}
createdItem.Editing.EndEdit();
}
}
}
public void MapFile(CmsItem item, CmsField cmsField)
{
IContent createdItem = ContextService.ContentService.GetById(Convert.ToInt32(item.Id));
if (createdItem == null)
{
return;
}
var field = createdItem.PropertyTypes.SingleOrDefault(type =>
type.Id == Convert.ToInt32(cmsField.TemplateField.FieldId));
if (field != null)
{
string imageIds = string.Empty;
IDataTypeDefinition dataType =
ContextService.DataTypeService.GetDataTypeDefinitionById(field.DataTypeDefinitionId);
if (cmsField.TemplateField != null)
{
foreach (var file in cmsField.Files)
{
var fileName = file.FileName;
var ext = fileName.Substring(fileName.LastIndexOf('.') + 1).ToLower();
cmsField.TemplateField.FieldName = createdItem.PropertyTypes.Single(type =>
type.Id == Convert.ToInt32(cmsField.TemplateField.FieldId)).Name;
var path = _mediaRepository.ResolveMediaPath(item, createdItem, cmsField);
if (!UmbracoConfig.For.UmbracoSettings().Content.DisallowedUploadFiles.Contains(ext))
{
switch (dataType.PropertyEditorAlias)
{
case "Umbraco.MediaPicker":
imageIds = _mediaRepository.UploadFile(path, file).ToString();
break;
case "Umbraco.MultipleMediaPicker":
imageIds += (imageIds.Length > 0 ? "," : "") +
_mediaRepository.UploadFile(path, file);
break;
default:
imageIds = _mediaRepository.UploadFile(path, file).ToString();
break;
}
}
}
createdItem.SetValue(field.Alias, imageIds);
ContextService.ContentService.Save(createdItem);
}
}
else
{
throw new KeyNotFoundException(String.Format("Some fields has been deleted from Document Type {0}", createdItem.ContentType.Name));
}
}
public virtual string ResolveMediaPath(CmsItem item, Item createdItem, CmsField cmsField)
{
string path;
//Field scField = createdItem.Fields[new ID(cmsField.TemplateField.FieldId)];
//string dataSourcePath = GetItem(scField.ID.ToString())["Source"];
//if (!string.IsNullOrEmpty(dataSourcePath) && GetItem(dataSourcePath) != null)
//{
// path = dataSourcePath;
//}
//else
//{
if (string.Equals(item.Template.TemplateName.ToLower(), "deal"))
{
publishParentMediaFolder = string.Format(DealsFolderRoot + "/{0}/", ItemUtil.ProposeValidItemName(item.Title));
path = string.IsNullOrEmpty(cmsField.TemplateField.FieldName)
? string.Format(DealsFolderRoot + "/{0}/", ItemUtil.ProposeValidItemName(item.Title))
: string.Format(DealsFolderRoot + "/{0}/{1}/", ItemUtil.ProposeValidItemName(item.Title), ItemUtil.ProposeValidItemName(cmsField.TemplateField.FieldName));
SetDatasourcePath(createdItem, cmsField.TemplateField.FieldId, DealsFolderRoot);
}
else if (string.Equals(item.Template.TemplateName.ToLower(), "event"))
{
publishParentMediaFolder = string.Format(EventsFolderRoot + "/{0}/", ItemUtil.ProposeValidItemName(item.Title));
path = string.IsNullOrEmpty(cmsField.TemplateField.FieldName)
? string.Format(EventsFolderRoot + "/{0}/", ItemUtil.ProposeValidItemName(item.Title))
: string.Format(EventsFolderRoot + "/{0}/{1}/", ItemUtil.ProposeValidItemName(item.Title), ItemUtil.ProposeValidItemName(cmsField.TemplateField.FieldName));
SetDatasourcePath(createdItem, cmsField.TemplateField.FieldId, EventsFolderRoot);
}
else
{
publishParentMediaFolder = string.Format(MediaFolderRoot + "/{0}/", ItemUtil.ProposeValidItemName(item.Title));
path = string.IsNullOrEmpty(cmsField.TemplateField.FieldName)
? string.Format(MediaFolderRoot + "/{0}/", ItemUtil.ProposeValidItemName(item.Title))
: string.Format(MediaFolderRoot + "/{0}/{1}/", ItemUtil.ProposeValidItemName(item.Title), ItemUtil.ProposeValidItemName(cmsField.TemplateField.FieldName));
SetDatasourcePath(createdItem, cmsField.TemplateField.FieldId, MediaFolderRoot);
}
//}
return(path);
}
/// <summary>
/// </summary>
/// <param name="item"></param>
/// <param name="cmsField"></param>
public void ResolveAttachmentMapping(CmsItem item, CmsField cmsField)
{
switch (cmsField.TemplateField.FieldType)
{
case "Droptree":
MapDropTree(item, cmsField);
break;
case "Image":
MapImage(item, cmsField);
break;
case "File":
MapFile(item, cmsField);
break;
default:
MapChoice(item, cmsField);
break;
}
}
private bool CheckFieldError(TemplateMapping templateMapping, List <Element> gcFields, List <File> files, ItemResultModel itemResponseModel)
{
bool fieldError = false;
var groupedFields = templateMapping.FieldMappings.GroupBy(i => i.CmsField);
foreach (var grouping in groupedFields)
{
CmsField cmsField = grouping.Key;
var gcFieldIds = grouping.Select(i => i.GcField.Id);
var gcFieldsToMap = grouping.Select(i => i.GcField);
IEnumerable <Element> gcFieldsForMapping =
gcFields.Where(i => gcFieldIds.Contains(i.Name)).ToList();
var gcField = gcFieldsForMapping.FirstOrDefault();
if (gcField != null)
{
var value = GetValue(gcFieldsForMapping);
var options = GetOptions(gcFieldsForMapping);
cmsField.Files = files.Where(x => x.FieldId == gcField.Name).ToList();
cmsField.Value = value;
cmsField.Options = options;
//update GC fields' type
foreach (var field in gcFieldsToMap)
{
field.Type = gcField.Type;
}
}
else
{
//if field error, set error message
itemResponseModel.ImportMessage = "Update failed: Template fields mismatch";
itemResponseModel.IsImportSuccessful = false;
fieldError = true;
break;
}
}
return(fieldError);
}
public virtual string ResolveMediaPath(CmsItem item, Item createdItem, CmsField cmsField)
{
Field scField = createdItem.Fields[new ID(cmsField.TemplateField.FieldId)];
string dataSourcePath = GetItem(scField.ID.ToString())["Source"];
string path;
if (string.IsNullOrEmpty(dataSourcePath))
{
path = string.IsNullOrEmpty(cmsField.TemplateField.FieldName)
? string.Format("/sitecore/media library/GatherContent/{0}/", item.Title)
: string.Format("/sitecore/media library/GatherContent/{0}/{1}/", item.Title, cmsField.TemplateField.FieldName);
SetDatasourcePath(createdItem, cmsField.TemplateField.FieldId, path);
}
else
{
path = dataSourcePath;
}
return(path);
}
public void MapDateTime(CmsItem item, CmsField cmsField)
{
Item createdItem = GetItem(item.Id, Sitecore.Data.Managers.LanguageManager.GetLanguage(item.Language));
if (createdItem == null)
{
return;
}
string stringValue = StringUtil.RemoveTags(cmsField.Value.ToString()).Trim();
string format = _accountsRepository.GetAccountSettings().DateTimeParseFormat;
if (string.IsNullOrWhiteSpace(format))
{
format = Constants.DateParseFormat;
}
DateTime dateTimeValue;
bool parseSuccessfull = DateTime.TryParseExact(stringValue, format, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces, out dateTimeValue);
if (!parseSuccessfull)
{
return;
}
using (new SecurityDisabler())
{
using (new LanguageSwitcher(item.Language))
{
createdItem.Editing.BeginEdit();
createdItem[cmsField.TemplateField.FieldName] = DateUtil.ToIsoDate(dateTimeValue);
createdItem.Editing.EndEdit();
}
}
}
public void MapText(CmsItem item, CmsField cmsField)
{
IContent createdItem = ContextService.ContentService.GetById(Convert.ToInt32(item.Id));
if (createdItem == null)
{
return;
}
var field =
createdItem.PropertyTypes.FirstOrDefault(type => type.Id == Convert.ToInt32(cmsField.TemplateField.FieldId));
if (field != null)
{
var value = field.PropertyEditorAlias == "Umbraco.TinyMCEv3"
? cmsField.Value.ToString().Trim()
: Regex.Replace(cmsField.Value.ToString(), "<.*?>", string.Empty).Trim();
switch (field.PropertyEditorAlias)
{
case "Umbraco.Textbox":
if (value.Length > 500)
{
value = value.Substring(0, 500);
}
break;
default:
break;
}
createdItem.SetValue(field.Alias, value);
ContextService.ContentService.Save(createdItem);
}
else
{
throw new KeyNotFoundException(String.Format("Some fields has been deleted from Document Type {0}", createdItem.ContentType.Name));
}
}
/// <summary>
///
/// </summary>
/// <param name="itemId"></param>
/// <param name="models"></param>
/// <param name="language"></param>
/// <returns></returns>
public List <ItemResultModel> UpdateItems(string itemId, List <UpdateListIds> models, string language)
{
var model = new List <ItemResultModel>();
var gcItems = new Dictionary <GCItem, string>();
foreach (var item in models)
{
GCItem gcItem = ItemsService.GetSingleItem(item.GCId).Data;
gcItems.Add(gcItem, item.CMSId);
}
//var templates = MappingRepository.GetMappings();
var templatesDictionary = new Dictionary <int, GCTemplate>();
foreach (var item in gcItems)
{
GCItem gcItem = item.Key; //gc item
string cmsId = item.Value; // corresponding cms id
var itemResponseModel = new ItemResultModel
{
IsImportSuccessful = true,
ImportMessage = "Update Successful"
};
if (!string.IsNullOrEmpty(GcAccountSettings.GatherContentUrl))
{
itemResponseModel.GcLink = string.Concat(GcAccountSettings.GatherContentUrl, "/item/", gcItem.Id);
}
itemResponseModel.GcItem = new GcItemModel
{
Id = gcItem.Id.ToString(),
Title = gcItem.Name
};
itemResponseModel.Status = new GcStatusModel
{
Color = gcItem.Status.Data.Color,
Name = gcItem.Status.Data.Name,
};
GCTemplate gcTemplate;
int templateId = gcItem.TemplateId.Value;
templatesDictionary.TryGetValue(templateId, out gcTemplate);
if (gcTemplate == null)
{
gcTemplate = TemplatesService.GetSingleTemplate(templateId.ToString()).Data;
templatesDictionary.Add(templateId, gcTemplate);
}
itemResponseModel.GcTemplate = new GcTemplateModel
{
Id = gcTemplate.Id.ToString(),
Name = gcTemplate.Name
};
string cmsLink = ItemsRepository.GetCmsItemLink(HttpContext.Current.Request.Url.Scheme, HttpContext.Current.Request.Url.Host, cmsId);
itemResponseModel.CmsLink = cmsLink;
itemResponseModel.CmsId = cmsId;
//MappingResultModel cmsItem;
//TryMapItem(gcItem, gcTemplate, templates, out cmsItem);
//result.Add(cmsItem);
List <Element> gcFields = gcItem.Config.SelectMany(i => i.Elements).ToList();
//var templateMapping = templates.First(x => x.GcTemplate.GcTemplateId == gcItem.TemplateId.ToString());
var templateMapping = MappingRepository.GetMappingByItemId(cmsId, language);
if (templateMapping != null) // template found, now map fields here
{
var gcContentIdField = templateMapping.FieldMappings.FirstOrDefault(fieldMapping => fieldMapping.CmsField.TemplateField.FieldName == "GC Content Id");
if (gcContentIdField != null)
{
templateMapping.FieldMappings.Remove(gcContentIdField);
}
var files = new List <File>();
if (gcItem.Config.SelectMany(config => config.Elements).Any(element => element.Type == "files"))
{
foreach (var file in ItemsService.GetItemFiles(gcItem.Id.ToString()).Data)
{
files.Add(new File
{
FileName = file.FileName,
Url = file.Url,
FieldId = file.Field,
UpdatedDate = file.Updated,
FileId = file.Id
});
}
}
bool fieldError = CheckFieldError(templateMapping, gcFields, files, itemResponseModel);
if (!fieldError)
{
var cmsContentIdField = new FieldMapping
{
CmsField = new CmsField
{
TemplateField = new CmsTemplateField {
FieldName = "GC Content Id"
},
Value = gcItem.Id.ToString()
}
};
templateMapping.FieldMappings.Add(cmsContentIdField);
var cmsItem = new CmsItem
{
Template = templateMapping.CmsTemplate,
Title = gcItem.Name,
Fields = templateMapping.FieldMappings.Select(x => x.CmsField).ToList(),
Language = language,
Id = cmsId
};
var fieldMappings = templateMapping.FieldMappings;
// one CMS text field can be mapped to several GC fields
// in this case we concatenate their texts and put into one CMS field
foreach (IGrouping <string, FieldMapping> fields in fieldMappings.GroupBy(f => f.CmsField.TemplateField.FieldName))
{
FieldMapping field = fields.First();
if (field.GcField != null)
{
switch (field.GcField.Type)
{
case "choice_radio":
case "choice_checkbox":
{
ItemsRepository.MapChoice(cmsItem, field.CmsField);
}
break;
case "files":
{
ItemsRepository.ResolveAttachmentMapping(cmsItem, field.CmsField);
}
break;
default:
{
if (field.CmsField.TemplateField.FieldType == "Datetime" || field.CmsField.TemplateField.FieldType == "Date")
{
ItemsRepository.MapDateTime(cmsItem, field.CmsField);
}
else
{
if (fields.Count() > 1)
{
field.CmsField.Value = string.Join("\r\n", fields.Select(f => f.CmsField.Value.ToString()));
}
ItemsRepository.MapText(cmsItem, field.CmsField);
}
}
break;
}
}
}
var cmsSyncDateField = new CmsField
{
TemplateField = new CmsTemplateField {
FieldName = "Last Sync Date"
},
Value = DateTime.UtcNow.ToString("yyyyMMddTHHmmss")
};
ItemsRepository.MapText(cmsItem, cmsSyncDateField);
}
}
else
{
//no template mapping, set error message
itemResponseModel.ImportMessage = "Update failed: Template not mapped";
itemResponseModel.IsImportSuccessful = false;
}
model.Add(itemResponseModel);
}
return(model);
}
private FieldMapping ConvertSitecoreFieldToModel(Item fieldMapping)
{
var field = GetItem(fieldMapping[SitecoreField]);
if (field == null)
{
return(null);
}
var additionalFields = new List <CmsField>();
var fields = fieldMapping[SitecoreFieldsAdditionalCopy];
if (!string.IsNullOrWhiteSpace(fields))
{
var fieldsAdditional = fields.Split(new [] { "|" }, StringSplitOptions.RemoveEmptyEntries);
if (fieldsAdditional.Any())
{
foreach (var fieldAdditional in fieldsAdditional)
{
var fieldAdditionalItem = GetItem(fieldAdditional);
if (fieldAdditionalItem != null)
{
var cmsField = new CmsField
{
TemplateField = new CmsTemplateField
{
FieldId = fieldAdditionalItem.ID.ToString(),
FieldName = fieldAdditionalItem.Name,
FieldType = fieldAdditionalItem["Type"]
}
};
additionalFields.Add(cmsField);
}
}
}
}
var fieldItemUrl = string.Empty;
if (HttpContext.Current != null)
{
fieldItemUrl = _itemsRepository.GetCmsItemLink(HttpContext.Current.Request.Url.Scheme, HttpContext.Current.Request.Url.Host, fieldMapping.ID.ToString());
}
var result = new FieldMapping
{
CmsField = new CmsField
{
TemplateField = new CmsTemplateField
{
FieldId = fieldMapping[SitecoreField],
FieldName = field.Name,
FieldType = field["Type"]
}
},
CmsFieldAdditionalMapping = additionalFields,
CmsFieldMappingItemId = fieldMapping.ID.ToString(),
CmsFieldMappingItemUrl = fieldItemUrl,
GcField = new GcField
{
Id = fieldMapping["GC Field Id"],
Name = fieldMapping["GC Field"]
}
};
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="itemId"></param>
/// <param name="models"></param>
/// <param name="language"></param>
/// <returns></returns>
public List <ItemResultModel> UpdateItems(string itemId, List <UpdateListIds> models, string language)
{
var model = new List <ItemResultModel>();
var gcItems = new Dictionary <GCItem, string>();
foreach (var item in models)
{
GCItem gcItem = ItemsService.GetSingleItem(item.GCId).Data;
gcItems.Add(gcItem, item.CMSId);
}
var templates = MappingRepository.GetMappings();
var templatesDictionary = new Dictionary <int, GCTemplate>();
foreach (var item in gcItems)
{
var gcItem = item.Key; //gc item
var cmsId = item.Value; // corresponding cms id
var itemResponseModel = new ItemResultModel
{
IsImportSuccessful = true,
ImportMessage = "Update Successful"
};
if (!string.IsNullOrEmpty(GcAccountSettings.GatherContentUrl))
{
itemResponseModel.GcLink = string.Concat(GcAccountSettings.GatherContentUrl, "/item/", gcItem.Id);
}
itemResponseModel.GcItem = new GcItemModel
{
Id = gcItem.Id.ToString(),
Title = gcItem.Name
};
itemResponseModel.Status = new GcStatusModel
{
Color = gcItem.Status.Data.Color,
Name = gcItem.Status.Data.Name,
};
GCTemplate gcTemplate;
var templateId = gcItem.TemplateId.Value;
templatesDictionary.TryGetValue(templateId, out gcTemplate);
if (gcTemplate == null)
{
gcTemplate = TemplatesService.GetSingleTemplate(templateId.ToString()).Data;
templatesDictionary.Add(templateId, gcTemplate);
}
itemResponseModel.GcTemplate = new GcTemplateModel
{
Id = gcTemplate.Id.ToString(),
Name = gcTemplate.Name
};
var cmsLink = ItemsRepository.GetCmsItemLink(HttpContext.Current.Request.Url.Host, cmsId);
itemResponseModel.CmsLink = cmsLink;
//MappingResultModel cmsItem;
//TryMapItem(gcItem, gcTemplate, templates, out cmsItem);
//result.Add(cmsItem);
List <Element> gcFields = gcItem.Config.SelectMany(i => i.Elements).ToList();
var templateMapping = templates.FirstOrDefault(x => x.GcTemplate.GcTemplateId == gcItem.TemplateId.ToString());
if (templateMapping != null) // template found, now map fields here
{
var gcContentIdField = templateMapping.FieldMappings.FirstOrDefault(fieldMapping => fieldMapping.CmsField.TemplateField.FieldName == "GC Content Id");
if (gcContentIdField != null)
{
templateMapping.FieldMappings.Remove(gcContentIdField);
}
var files = new List <File>();
if (
gcItem.Config.SelectMany(config => config.Elements)
.Select(element => element.Type)
.Contains("files"))
{
foreach (var file in ItemsService.GetItemFiles(gcItem.Id.ToString()).Data)
{
files.Add(new File
{
FileName = file.FileName,
Url = file.Url,
FieldId = file.Field,
UpdatedDate = file.Updated
});
}
}
bool fieldError = false;
var groupedFields = templateMapping.FieldMappings.GroupBy(i => i.CmsField);
foreach (var grouping in groupedFields)
{
CmsField cmsField = grouping.Key;
var gcFieldIds = grouping.Select(i => i.GcField.Id);
var gcFieldsToMap = grouping.Select(i => i.GcField);
IEnumerable <Element> gcFieldsForMapping =
gcFields.Where(i => gcFieldIds.Contains(i.Name)).ToList();
var gcField = gcFieldsForMapping.FirstOrDefault();
if (gcField != null)
{
var value = GetValue(gcFieldsForMapping);
var options = GetOptions(gcFieldsForMapping);
cmsField.Files = files.Where(x => x.FieldId == gcField.Name).ToList();
cmsField.Value = value;
cmsField.Options = options;
//update GC fields' type
foreach (var field in gcFieldsToMap)
{
field.Type = gcField.Type;
}
}
else
{
//if field error, set error message
itemResponseModel.ImportMessage = "Update failed: Template fields mismatch";
itemResponseModel.IsImportSuccessful = false;
fieldError = true;
break;
}
}
if (!fieldError)
{
var cmsContentIdField = new FieldMapping
{
CmsField = new CmsField
{
TemplateField = new CmsTemplateField {
FieldName = "GC Content Id"
},
Value = gcItem.Id.ToString()
}
};
templateMapping.FieldMappings.Add(cmsContentIdField);
var cmsItem = new CmsItem
{
Template = templateMapping.CmsTemplate,
Title = gcItem.Name,
Fields = templateMapping.FieldMappings.Select(x => x.CmsField).ToList(),
Language = language,
Id = cmsId
};
var fields = templateMapping.FieldMappings;
try
{
foreach (var field in fields)
{
if (field.GcField != null)
{
switch (field.GcField.Type)
{
case "choice_radio":
case "choice_checkbox":
{
ItemsRepository.MapChoice(cmsItem, field.CmsField);
}
break;
case "files":
{
ItemsRepository.MapFile(cmsItem, field.CmsField);
}
break;
default:
{
ItemsRepository.MapText(cmsItem, field.CmsField);
}
break;
}
}
}
}
catch (KeyNotFoundException ex)
{
itemResponseModel.ImportMessage = "Update failed: Some fields has been deleted from CMS Template";
itemResponseModel.IsImportSuccessful = false;
model.Add(itemResponseModel);
break;
}
//ItemsRepository.UpdateItem(new CmsItem
//{
//});
}
}
else
{
//no template mapping, set error message
itemResponseModel.ImportMessage = "Update failed: Template not mapped";
itemResponseModel.IsImportSuccessful = false;
}
model.Add(itemResponseModel);
}
return(model);
}
/// <summary>
///
/// </summary>
/// <param name="itemId"></param>
/// <param name="items"></param>
/// <param name="projectId"></param>
/// <param name="statusId"></param>
/// <param name="language"></param>
/// <returns></returns>
private List <ItemResultModel> Import(string itemId, List <ImportItemModel> items, string projectId, string statusId, string language)
{
var model = new List <ItemResultModel>();
//get all paths
var fullGcPaths = GetItemsMap(projectId, items.Select(x => x.Id));
var pathItemsToBeRemoved = new List <int>();
Dictionary <string, List <ItemEntity> > shortPaths = new Dictionary <string, List <ItemEntity> >();
if (fullGcPaths.Count() > 1)
{
var firstPath = fullGcPaths.First();
foreach (var path in firstPath.Value)
{
//if all paths start with same item and this item is not selected
//TODO: check all cases work: add UT
if (fullGcPaths.Select(x => x.Value).All(x => x.First().Data.Id == path.Data.Id) && !items.Select(x => x.Id).Contains(path.Data.Id.ToString()))
{
pathItemsToBeRemoved.Add(path.Data.Id);
}
}
}
foreach (var item in fullGcPaths)
{
List <ItemEntity> itemsToAdd = new List <ItemEntity>();
foreach (var gcPathItem in item.Value)
{
if (!pathItemsToBeRemoved.Contains(gcPathItem.Data.Id))
{
itemsToAdd.Add(gcPathItem);
}
}
shortPaths.Add(item.Key, itemsToAdd);
}
var sorted = shortPaths.OrderBy(x => x.Value.Count).ThenBy(x => x.Value.First().Data.Name);//sort to start from shortest and alphabetically asc
foreach (var path in sorted)
{
var itemResponseModel = new ItemResultModel
{
IsImportSuccessful = true,
ImportMessage = "Import Successful"
};
var gcItem = path.Value.Last(); //this is the item we selected to import
var item = items.FirstOrDefault(x => x.Id == gcItem.Data.Id.ToString()); //item coming from UI; selected mapping and other info
if (gcItem != null && gcItem.Data != null && gcItem.Data.TemplateId != null)
{
if (!string.IsNullOrEmpty(FactoryService.CurrentSettings.GatherContentUrl))
{
itemResponseModel.GcLink = string.Concat(FactoryService.CurrentSettings.GatherContentUrl, "/item/", gcItem.Data.Id);
}
itemResponseModel.GcItem = new GcItemModel
{
Id = gcItem.Data.Id.ToString(),
Title = gcItem.Data.Name
};
itemResponseModel.Status = new GcStatusModel
{
Color = gcItem.Data.Status.Data.Color,
Name = gcItem.Data.Status.Data.Name,
};
var gcTemplate = FactoryService.Services.TemplateService.GetSingleTemplate(gcItem.Data.TemplateId.ToString());
itemResponseModel.GcTemplate = new GcTemplateModel
{
Id = gcTemplate.Data.Id.ToString(),
Name = gcTemplate.Data.Name
};
//element that corresponds to item in CMS that holds mappings
TemplateMapping templateMapping = FactoryRepository.Repositories.MappingRepository.GetMappingById(item.SelectedMappingId);
List <Element> gcFields = gcItem.Data.Config.SelectMany(i => i.Elements).ToList();
if (templateMapping != null) // template found, now map fields here
{
var files = new List <File>();
if (gcItem.Data.Config.SelectMany(config => config.Elements).Select(element => element.Type).Contains("files"))
{
foreach (var file in FactoryService.Services.ItemsService.GetItemFiles(gcItem.Data.Id.ToString()).Data)
{
files.Add(new File
{
FileName = file.FileName,
Url = file.Url,
FieldId = file.Field,
UpdatedDate = file.Updated,
FileId = file.Id
});
}
}
bool fieldError = false;
var groupedFields = templateMapping.FieldMappings.GroupBy(i => i.CmsField);
foreach (var grouping in groupedFields)
{
CmsField cmsField = grouping.Key;
var gcFieldIds = grouping.Select(i => i.GcField.Id);
var gcFieldsToMap = grouping.Select(i => i.GcField);
IEnumerable <Element> gcFieldsForMapping = gcFields.Where(i => gcFieldIds.Contains(i.Name)).ToList();
var gcField = gcFieldsForMapping.FirstOrDefault();
if (gcField != null)
{
var value = GetValue(gcFieldsForMapping);
var options = GetOptions(gcFieldsForMapping);
cmsField.Files = files.Where(x => x.FieldId == gcField.Name).ToList();
cmsField.Value = value;
cmsField.Options = options;
//update GC fields' type
foreach (var field in gcFieldsToMap)
{
field.Type = gcField.Type;
}
}
else
{
//if field error, set error message
itemResponseModel.ImportMessage = "Import failed: Template fields mismatch";
itemResponseModel.IsImportSuccessful = false;
fieldError = true;
break;
}
}
if (!fieldError)
{
var cmsContentIdField = new FieldMapping
{
CmsField = new CmsField
{
TemplateField = new CmsTemplateField {
FieldName = "GC Content Id"
},
Value = gcItem.Data.Id.ToString()
}
};
templateMapping.FieldMappings.Add(cmsContentIdField);
var cmsItem = new CmsItem
{
Template = templateMapping.CmsTemplate,
Title = gcItem.Data.Name,
Fields = templateMapping.FieldMappings.Select(x => x.CmsField).ToList(),
Language = language
};
var gcPath = string.Join("/", path.Value.Select(x => x.Data.Name));
var parentId = itemId;
bool alreadyMappedItemInPath = false;
//for each mapping which is fact GC Item => Sitecore/Umbraco item - get GC Path and run through its each item
for (int i = 0; i < path.Value.Count; i++)
{
//for each path item check if it exists already in CMS and if yes - skip; otherwise - add not mapped item
if (i == path.Value.Count - 1)
{
//if we at the last item in the path - import mapped item
if (FactoryRepository.Repositories.ItemsRepository.IfMappedItemExists(parentId, cmsItem, templateMapping.MappingId, gcPath))
{
cmsItem.Id = FactoryRepository.Repositories.ItemsRepository.AddNewVersion(parentId, cmsItem, templateMapping.MappingId, gcPath);
}
else
{
cmsItem.Id = FactoryRepository.Repositories.ItemsRepository.CreateMappedItem(parentId, cmsItem, templateMapping.MappingId, gcPath);
}
parentId = cmsItem.Id;
//
var fields = templateMapping.FieldMappings;
try
{
foreach (var field in fields)
{
if (field.GcField != null)
{
switch (field.GcField.Type)
{
case "choice_radio":
case "choice_checkbox":
{
FactoryRepository.Repositories.ItemsRepository.MapChoice(cmsItem, field.CmsField);
}
break;
case "files":
{
FactoryRepository.Repositories.ItemsRepository.MapFile(cmsItem, field.CmsField);
}
break;
default:
{
FactoryRepository.Repositories.ItemsRepository.MapText(cmsItem, field.CmsField);
}
break;
}
}
}
}
catch (KeyNotFoundException ex)
{
itemResponseModel.ImportMessage = "Import failed: Some fields has been deleted from CMS Template";
itemResponseModel.IsImportSuccessful = false;
break;
}
//set CMS link after we got out CMS Id
var cmsLink = FactoryRepository.Repositories.ItemsRepository.GetCmsItemLink(HttpContext.Current.Request.Url.Host, cmsItem.Id);
itemResponseModel.CmsLink = cmsLink;
if (!string.IsNullOrEmpty(statusId))
{
var status = PostNewItemStatus(gcItem.Data.Id.ToString(), statusId, projectId);
if (itemResponseModel == null)
{
continue;
}
itemResponseModel.Status.Color = status.Color;
itemResponseModel.Status.Name = status.Name;
}
}
else
{
var currentCmsItem = new CmsItem
{
Title = path.Value[i].Data.Name,
Language = language
};
//if we are not at the selected item, somewhere in the middle
//1. если замапленный айтем существует (такое же название и такой же gc path?), то тогда выставляем alreadyMappedItemInPath = тру
//и пропускаем всякое создание, сеттим только парент id
//2. иначе если есть незамапленный айтем:
// - alreadyMappedItemInPath == true = - скипуем создание, выставляем его как парент айди
// - alreadyMappedItemInPath == false, - скипуем всё, парент айди не меняем
//3. айтема никакого нет
// - alreadyMappedItemInPath == true = - создаём незамапленный айтем, выставляем его как парент айди
// - alreadyMappedItemInPath == false, - скипуем всё, парент айди не меняем
if (FactoryRepository.Repositories.ItemsRepository.IfMappedItemExists(parentId, currentCmsItem))
{
//cmsItem.Id = ItemsRepository.CreateNotMappedItem(parentId, notMappedCmsItem);
//parentId = cmsItem.Id;
alreadyMappedItemInPath = true;
parentId = FactoryRepository.Repositories.ItemsRepository.GetItemId(parentId, currentCmsItem);
}
else if (FactoryRepository.Repositories.ItemsRepository.IfNotMappedItemExists(parentId, currentCmsItem))
{
if (alreadyMappedItemInPath)
{
parentId = FactoryRepository.Repositories.ItemsRepository.GetItemId(parentId, currentCmsItem);
}
}
else
{
if (alreadyMappedItemInPath)
{
parentId = FactoryRepository.Repositories.ItemsRepository.CreateNotMappedItem(parentId, currentCmsItem);
}
}
}
}
}
}
else
{
//no template mapping, set error message
itemResponseModel.ImportMessage = "Import failed: Template not mapped";
itemResponseModel.IsImportSuccessful = false;
}
}
model.Add(itemResponseModel);
}
return(model);
}
public void MapText(CmsItem item, CmsField cmsField)
{
IContent createdItem = ContextService.ContentService.GetById(Convert.ToInt32(item.Id));
if (createdItem == null)
{
return;
}
var field =
createdItem.PropertyTypes.FirstOrDefault(type => type.Id == Convert.ToInt32(cmsField.TemplateField.FieldId));
if (field != null)
{
var value = field.PropertyEditorAlias == "Umbraco.TinyMCEv3"
? cmsField.Value.ToString().Trim()
: Regex.Replace(cmsField.Value.ToString(), "<.*?>", string.Empty).Trim();
switch (field.PropertyEditorAlias)
{
case "Umbraco.Textbox":
if (value.Length > 500)
{
value = value.Substring(0, 500);
}
createdItem.SetValue(field.Alias, value);
break;
case "Umbraco.TextboxMultiple":
createdItem.SetValue(field.Alias, value);
break;
case "Umbraco.TinyMCEv3":
createdItem.SetValue(field.Alias, value);
break;
case "Umbraco.Date":
case "Umbraco.DateTime":
string dateString = Regex.Replace(cmsField.Value.ToString(), "<.*?>", string.Empty).Trim();
string expectedFormat = FactoryRepository.Repositories.AccountRepository.GetAccountSettings().ImportDateFormat;
try
{
dateString = dateString.Trim();
}
catch (Exception e)
{
throw new ArgumentOutOfRangeException(String.Format("Error importing the date. Date must be in the format {0}", expectedFormat));
}
DateTime theDate;
bool result = DateTime.TryParseExact(dateString, expectedFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out theDate);
if (result)
{
createdItem.SetValue(field.Alias, theDate);
}
else
{
throw new ArgumentException(String.Format("Error importing the date. Date must be in the format {0}", expectedFormat));
}
break;
default:
break;
}
ContextService.ContentService.Save(createdItem);
}
else
{
throw new KeyNotFoundException(String.Format("Some fields has been deleted from Document Type {0}", createdItem.ContentType.Name));
}
}
/// <summary>
/// </summary>
/// <param name="item"></param>
/// <param name="cmsField"></param>
public void MapText(CmsItem item, CmsField cmsField)
{
Item createdItem = GetItem(item.Id, Sitecore.Data.Managers.LanguageManager.GetLanguage(item.Language));
if (createdItem == null)
{
return;
}
using (new SecurityDisabler())
{
using (new LanguageSwitcher(item.Language))
{
createdItem.Editing.BeginEdit();
var value = string.Empty;
if (cmsField.Value != null)
{
switch (cmsField.TemplateField.FieldType)
{
case "Rich Text":
value = cmsField.Value.ToString();
break;
case "General Link":
{
value = GeneralLinkExternal(StringUtil.RemoveTags(cmsField.Value.ToString().Replace("\u200B", "")).Trim());
break;
}
case "Checkbox":
{
value = string.Empty;
var val = StringUtil.RemoveTags(cmsField.Value.ToString().Replace("\u200B", "")).Trim();
if (val == "1")
{
value = "1";
}
else
{
value = "0";
}
break;
}
case "Number":
{
value = cmsField.Value.ToString().Replace("\u200B", "");
break;
}
case "Integer":
{
string checkValue = cmsField.Value.ToString().Replace("\u200B", "");
int isConvertedProperly = 0;
if(int.TryParse(checkValue, out isConvertedProperly))
{
value = checkValue;
}
break;
}
default:
value = StringUtil.RemoveTags(cmsField.Value.ToString()).Trim();
break;
}
}
if (cmsField.TemplateField.FieldType == "Multi-Line Text" || cmsField.TemplateField.FieldType == "Rich Text")
{
value = value.Replace(" ", String.Empty);
}
createdItem[cmsField.TemplateField.FieldName] = value;
createdItem.Editing.EndEdit();
}
}
}
public void MapChoice(CmsItem item, CmsField cmsField)
{
IContent createdItem = ContextService.ContentService.GetById(Convert.ToInt32(item.Id));
if (createdItem == null || cmsField.TemplateField == null || cmsField.Options == null || cmsField.Options.Count == 0)
{
return;
}
var field = createdItem.PropertyTypes.SingleOrDefault(
type => type.Id == Convert.ToInt32(cmsField.TemplateField.FieldId));
if (field != null)
{
IDataTypeDefinition dataType =
ContextService.DataTypeService.GetDataTypeDefinitionById(field.DataTypeDefinitionId);
var dataSource =
ContextService.DataTypeService.GetPreValuesCollectionByDataTypeId(dataType.Id).PreValuesAsDictionary;
switch (dataType.PropertyEditorAlias)
{
case "Umbraco.RadioButtonList":
case "Umbraco.DropDown":
case "Umbraco.DropdownlistPublishingKeys":
var selected = dataSource.FirstOrDefault(x => x.Value.Value == cmsField.Options.First());
if (selected.Value != null)
{
createdItem.SetValue(
createdItem.PropertyTypes.Single(
type => type.Id == Convert.ToInt32(cmsField.TemplateField.FieldId)).Alias,
selected.Value.Id);
}
break;
case "Umbraco.MultipleMediaPicker":
case "Umbraco.MediaPicker":
{
string imageIds = string.Empty;
if (cmsField.Files != null && cmsField.Files.Any())
{
foreach (var file in cmsField.Files)
{
var fileName = file.FileName;
var ext = fileName.Substring(fileName.LastIndexOf('.') + 1).ToLower();
cmsField.TemplateField.FieldName = createdItem.PropertyTypes.Single(type =>
type.Id == Convert.ToInt32(cmsField.TemplateField.FieldId)).Name;
var path = _mediaRepository.ResolveMediaPath(item, createdItem, cmsField);
if (!UmbracoConfig.For.UmbracoSettings().Content.DisallowedUploadFiles.Contains(ext))
{
switch (dataType.PropertyEditorAlias)
{
case "Umbraco.MediaPicker":
imageIds = _mediaRepository.UploadFile(path, file).ToString();
break;
case "Umbraco.MultipleMediaPicker":
imageIds += (imageIds.Length > 0 ? "," : "") +
_mediaRepository.UploadFile(path, file);
break;
default:
imageIds = _mediaRepository.UploadFile(path, file).ToString();
break;
}
}
}
createdItem.SetValue(createdItem.PropertyTypes.Single(type =>
type.Id == Convert.ToInt32(cmsField.TemplateField.FieldId)).Alias, imageIds);
}
else if (cmsField.Options != null && cmsField.Options.Any())
{
string selectedItems = string.Empty;
foreach (var option in cmsField.Options)
{
if (dataSource.Select(x => x.Value.Value).Contains(option))
{
selectedItems += (selectedItems.Length > 0 ? "," : "")
+
dataSource.Where(x => x.Value.Value == option)
.Select(x => x.Value.Id)
.First();
}
}
createdItem.SetValue(
createdItem.PropertyTypes.Single(
type => type.Id == Convert.ToInt32(cmsField.TemplateField.FieldId)).Alias,
selectedItems);
}
}
break;
case "Umbraco.CheckBoxList":
case "Umbraco.DropDownMultiple":
{
string selectedItems = string.Empty;
foreach (var option in cmsField.Options)
{
if (dataSource.Select(x => x.Value.Value).Contains(option))
{
selectedItems += (selectedItems.Length > 0 ? "," : "")
+
dataSource.Where(x => x.Value.Value == option)
.Select(x => x.Value.Id)
.First();
}
}
createdItem.SetValue(
createdItem.PropertyTypes.Single(
type => type.Id == Convert.ToInt32(cmsField.TemplateField.FieldId)).Alias, selectedItems);
}
break;
default:
break;
}
ContextService.ContentService.Save(createdItem);
}
else
{
throw new KeyNotFoundException(String.Format("Some fields has been deleted from Document Type {0}", createdItem.ContentType.Name));
}
}
