private string GetBreadcrumb(GCItem item, List <GCItem> items)
{
var names = new List <string>();
string result = BuildBreadcrumb(item, items, names);
return(result);
}
public ImportResultItemModel(GCItem item, GCTemplate template, bool isImportSuccessful, string resultMessage)
{
Id = item.Id.ToString();
IsImportSuccessful = isImportSuccessful;
ResultMessage = resultMessage;
Status = item.Status.Data;
Template = template;
Title = item.Name;
}
/// <summary>
///
/// </summary>
/// <param name="gcItem"></param>
/// <param name="gcTemplate"></param>
/// <param name="selectedMappingId"></param>
/// <param name="result"></param>
/// <param name="selectedLocationId"></param>
private void TryMapItem(GCItem gcItem, GCTemplate gcTemplate, string selectedMappingId, out MappingResultModel result, string selectedLocationId = null)
{
bool isUpdate = gcItem is UpdateGCItem;
List <Element> gcFields = gcItem.Config.SelectMany(i => i.Elements).ToList();
var template = FactoryRepository.Repositories.MappingRepository.GetMappingById(selectedMappingId);
if (template == null)
{
string errorMessage = isUpdate ? "Update failed: Template not mapped" : "Import failed: Template not mapped";
result = new MappingResultModel(gcItem, null, gcTemplate.Name, null, string.Empty, errorMessage, false, selectedLocationId);
return;
}
List <ImportCMSField> fields;
IEnumerable <IGrouping <string, FieldMapping> > groupedFields = template.FieldMappings.GroupBy(i => i.CmsField.TemplateField.FieldId);
var files = new List <File>();
if (gcItem.Config.SelectMany(config => config.Elements).Select(element => element.Type).Contains("files"))
{
foreach (var file in FactoryService.Services.ItemsService.GetItemFiles(gcItem.Id.ToString()).Data)
{
files.Add(new File
{
FileName = file.FileName,
Url = file.Url,
UpdatedDate = file.Updated
});
}
}
TryMapItemState mapState = TryMapFields(gcFields, groupedFields, files, out fields);
if (mapState == TryMapItemState.FieldError)
{
string errorMessage = isUpdate ? "Update failed: Template fields mismatch" : "Import failed: Template fields mismatch";
result = new MappingResultModel(gcItem, null, gcTemplate.Name, null, string.Empty, errorMessage, false, selectedLocationId);
return;
}
string cmsId = string.Empty;
string message = "Import Successful";
if (isUpdate)
{
cmsId = (gcItem as UpdateGCItem).CMSId;
message = "Update Successful";
}
result = new MappingResultModel(gcItem, fields, gcTemplate.Name, template.CmsTemplate.TemplateId, cmsId, message, true, selectedLocationId);
}
public MappingResultModel(GCItem item, List <ImportCMSField> fields, string template, string cmsTemplate, string cmsId = "", string message = "", bool isImportSuccessful = true, string defaultLocation = null)
{
GCItemId = item.Id.ToString();
Status = item.Status.Data;
Title = item.Name;
GCTemplate = template;
CMSTemplateId = cmsTemplate;
Fields = fields;
CMSId = cmsId;
Message = message;
DefaultLocation = defaultLocation;
IsImportSuccessful = isImportSuccessful;
}
public ImportListItem(GCItem item, GCTemplate template, List <GCItem> items, string dateFormat, IEnumerable <AvailableMapping> mappings)
{
Checked = false;
AvailableMappings = new AvailableMappings();
Id = item.Id.ToString();
Title = item.Name;
Status = item.Status.Data;
Breadcrumb = GetBreadcrumb(item, items);
LastUpdatedInGC = item.Updated.Date.ToString(dateFormat);
AvailableMappings.Mappings.AddRange(mappings);
Template = template;
}
private string BuildBreadcrumb(GCItem item, List <GCItem> items, List <string> names)
{
names.Add(item.Name);
if (item.ParentId != 0)
{
GCItem next = items.FirstOrDefault(i => i.Id == item.ParentId);
return(BuildBreadcrumb(next, items, names));
}
names.Reverse();
string url = string.Join("/", names);
return(string.Format("/{0}", url));
}
public UpdateGCItem(GCItem item, string cmsId)
{
this.CMSId = cmsId;
this.Config = item.Config;
this.Created = item.Created;
this.CustomStateId = item.CustomStateId;
this.ProjectId = item.ProjectId;
this.DueDates = item.DueDates;
this.Id = item.Id;
this.Name = item.Name;
this.Notes = item.Notes;
this.Overdue = item.Overdue;
this.Updated = item.Updated;
this.Type = item.Type;
this.ParentId = item.ParentId;
this.Position = item.Position;
this.Status = item.Status;
this.TemplateId = item.TemplateId;
}
/// <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);
}
/// <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);
}
