protected virtual void ProcessLevelLoggerAndChildren(LevelLogger levelLogger, LogLine.LogType[] logTypes, ref StringBuilder sb, int level)
{
var children = levelLogger.GetChildren();
if (children != null)
{
var prefix = GetPrefixIndent(level);
foreach (var child in children)
{
var logLine = child as LogLine;
if (logLine != null)
{
if (logTypes == null || logTypes.Contains(logLine.Type))
{
sb.AppendLine(String.Format("{0} {1}", prefix, OutputLogLine(logLine)));
continue;
}
}
var childLevelLogger = child as LevelLogger;
if (childLevelLogger != null)
{
if (childLevelLogger.HasErrorsOrInfos())
{
var keys = childLevelLogger.HasKeys() ? GetKeys(childLevelLogger) : "";
var name = GetCategoryName(childLevelLogger);
if (!String.IsNullOrEmpty(name))
{
sb.AppendLine(String.Format("{0} {1} {2}", prefix, name, keys));
}
ProcessLevelLoggerAndChildren(childLevelLogger, logTypes, ref sb, level + 1);
}
}
}
}
}
protected void Run(BaseDataMap map, LevelLogger logger, OutputHandlerBase exporter)
{
Context.Job.Status.State = JobState.Running;
logger.AddKey(Utility.Constants.DataSyncItemId, map.ImportItem.ID.ToString());
logger.AddData(Utility.Constants.DataSyncItem, map.ImportItem);
logger.AddData(Logger.Log.Constants.Identifier, map.ImportItem.Name);
var startedAt = DateTime.Now;
logger = map.Process();
var finishededAt = DateTime.Now;
logger.AddData(Logger.Log.Constants.StartTime, startedAt);
logger.AddData(Logger.Log.Constants.EndTime, finishededAt);
try
{
MailManager.SendLogReport(ref logger, exporter);
}
catch (Exception exception)
{
Diagnostics.Log.Error(exporter.GetIdentifier() + " failed in sending out the mail. Please see the exception message for more details. Exception:" + exception.Message + ". Status:\r\n" +
exporter.Export(), typeof(DataSyncWizard));
}
if (logger.HasErrors())
{
Context.Job.Status.Failed = true;
}
else
{
Context.Job.Status.State = JobState.Finished;
}
}
//protected void Timer1_Tick(object sender, EventArgs e)
//{
// litStatus.Text = "Panel refreshed at: " + DateTime.Now.ToLongTimeString();
// if (dataSyncJob != null)
// {
// if (dataSyncJob.logBuilder != null)
// {
// var processedItems = dataSyncJob.logBuilder.ProcessedItems;
// litStatus.Text += processedItems + "";
// }
// }
//}
//public delegate void LongTimeTask_Delegate(string str);
//public void LongTimeTask(string str)
//{
// Item dataSyncItem = currentDB.Items[ddlImport.SelectedValue];
// if (dataSyncItem != null)
// {
// Logging logBuilder = new Logging();
// DataSyncManager.RunDataSyncJob(dataSyncItem, ref logBuilder);
// if (logBuilder != null)
// {
// txtMessage.Text = logBuilder.LogBuilder.Length < 1 ? "The import completed successfully. \r\nStatus: \r\n" + logBuilder.GetItemStatusText() : logBuilder.LogBuilder + "\r\nStatus: \r\n" + logBuilder.GetItemStatusText();
// }
// else
// {
// txtMessage.Text = "The log object was null.";
// }
// }
//}
//public void TaskCompleted(IAsyncResult r)
//{
// litStatus.Text = "Job done: " + DateTime.Now.ToLongTimeString();
// this.updatePanelStatus.Update();
//}
//protected void btnImport_Click(object sender, EventArgs e)
//{
// //LongTimeTask_Delegate d = new LongTimeTask_Delegate(LongTimeTask);
// //IAsyncResult r = d.BeginInvoke("String", new AsyncCallback(TaskCompleted), null);
// //d.EndInvoke(r);
//}
protected void btnImport_Click(object sender, EventArgs e)
{
Item dataSyncItem = currentDB.Items[ddlImport.SelectedValue];
if (dataSyncItem != null)
{
LevelLogger logger = Manager.CreateLogger(dataSyncItem);
var dataSyncManager = new DataSyncManager();
dataSyncManager.RunDataSyncJob(dataSyncItem, ref logger);
if (logger != null)
{
var exporter = Manager.CreateOutputHandler(dataSyncItem, logger);
if (exporter != null)
{
txtMessage.Text = exporter.Export();
}
else
{
txtMessage.Text = "The Exporter class was null. Therefor the log was not written out.";
}
}
else
{
txtMessage.Text = "The log object was null.";
}
}
}
/// <summary>
/// gets custom data from a DataRow
/// </summary>
/// <param name="importRow"></param>
/// <param name="fieldName"></param>
/// <returns></returns>
public override string GetFieldValue(object importRow, string fieldName, ref LevelLogger logger)
{
var getFieldLogger = logger.CreateLevelLogger();
try
{
DataRow dataRow = importRow as DataRow;
if (dataRow != null)
{
if (!String.IsNullOrEmpty(fieldName))
{
object fieldValue = dataRow[fieldName];
return((fieldValue != null) ? fieldValue.ToString() : String.Empty);
}
else
{
getFieldLogger.AddError(CategoryConstants.TheFieldnameArgumentWasNullOrEmpty, String.Format("The GetFieldValue method failed because the the 'fieldName' was null or empty. ImportRow: {0}.", GetImportRowDebugInfo(importRow)));
}
}
else
{
getFieldLogger.AddError(CategoryConstants.TheImportRowWasNull, String.Format("The GetFieldValue method failed because the Import Row was null. FieldName: {0}.", fieldName));
}
}
catch (Exception ex)
{
getFieldLogger.AddError(CategoryConstants.GetFieldValueFailed, String.Format("The GetFieldValue method failed with an exception. ImportRow: {0}. FieldName: {1}. Exception: {2}.", GetImportRowDebugInfo(importRow), fieldName, ex));
}
return(String.Empty);
}
public static OutputHandlerBase CreateOutputHandler(Item dataSyncItem, LevelLogger logger)
{
string outHandlerAssembly = dataSyncItem[FieldNameOutputHandlerAssembly];
string outputHandlerClass = dataSyncItem[FieldNameOutputHandlerClass];
if (!String.IsNullOrEmpty(outHandlerAssembly))
{
if (!String.IsNullOrEmpty(outputHandlerClass))
{
OutputHandlerBase outputHandler = null;
try
{
outputHandler = (OutputHandlerBase)Reflection.ReflectionUtil.CreateObject(outHandlerAssembly, outputHandlerClass, new object[] { logger });
}
catch (FileNotFoundException fnfe)
{
throw new Exception("The binary specified could not be found" + fnfe.Message, fnfe);
}
if (outputHandler != null)
{
return(outputHandler);
}
throw new Exception(String.Format("The OutputHandler provided could not be instantiated. Assembly:'{0}' Class:'{1}'", outHandlerAssembly, outputHandlerClass));
}
else
{
throw new Exception(String.Format("OutputHandler class is not defined"));
}
}
else
{
throw new Exception("OutputHandler assembly is not defined");
}
return(null);
}
public static LevelLogger CreateLogger(Item dataSyncItem)
{
string logAssembly = dataSyncItem[FieldNameLogAssembly];
string logClass = dataSyncItem[FieldNameLogClass];
if (!String.IsNullOrEmpty(logAssembly))
{
if (!String.IsNullOrEmpty(logClass))
{
LevelLogger logger = null;
try
{
logger = (LevelLogger)Reflection.ReflectionUtil.CreateObject(logAssembly, logClass, new object[] { });
}
catch (FileNotFoundException fnfe)
{
throw new Exception("The binary specified could not be found" + fnfe.Message, fnfe);
}
if (logger != null)
{
return(logger);
}
throw new Exception(String.Format("The Log provided could not be instantiated. Assembly:'{0}' Class:'{1}'", logAssembly, logClass));
}
else
{
throw new Exception(String.Format("Log class is not defined"));
}
}
else
{
throw new Exception("Log assembly is not defined");
}
return(null);
}
public override string GetFieldValue(object importRow, string fieldName, ref LevelLogger logger)
{
var levelLogger = logger.CreateLevelLogger();
try
{
var row = importRow as Dictionary <string, string>;
if (row != null)
{
if (row.ContainsKey(fieldName))
{
return(row[fieldName]);
}
Logger.AddError("Error", string.Format("The fieldName {0} didn't exist in the import row.", fieldName));
}
}
catch (Exception ex)
{
levelLogger.AddError("GetFieldValue failed",
string.Format(
"The GetFieldValue method failed with an exception. ImportRow: {0}. FieldName: {1}. Exception: {2}.",
GetImportRowDebugInfo(importRow), fieldName, ex));
}
return(string.Empty);
}
public static void SendLogReport(ref LevelLogger logger, OutputHandlerBase exporter)
{
var dataSyncItem = logger.GetData(Utility.Constants.DataSyncItem) as Item;
if (dataSyncItem == null)
{
logger.AddError("Error", "The DataSyncItem was null. Therefor we couldn't retrieve any mail recipients.");
return;
}
if (exporter == null)
{
logger.AddError("Error", "The ExporterBase was null. This class is used to output the logger.");
return;
}
var recipient = dataSyncItem[FieldNameMailRecipients];
if (String.IsNullOrEmpty(recipient))
{
logger.AddInfo("Add Mail Recipients to receive email reports", "If you want to receive email, then fill out the field 'Mail Recipients'.");
}
else
{
var replyTo = dataSyncItem[FieldNameMailReplyTo];
if (String.IsNullOrEmpty(replyTo))
{
replyTo = DefaultReplyTo;
logger.AddError("Error", "The 'Mail Reply To' field must be defined. Please provide a replyTo address for the mail.");
}
var subject = dataSyncItem[FieldNameMailSubject];
if (String.IsNullOrEmpty(subject))
{
subject = DefaultSubject;
}
var result = !logger.HasFatalsOrErrors() ? Success : Failure;
try
{
subject = String.Format(subject, exporter.GetIdentifier(), result);
}
catch (Exception exception)
{
logger.AddError("Error", "SendLogReport had an exception trying to format the subject of the mail." + exception.Message);
}
var doNotSendMailOnSuccess = dataSyncItem[FieldNameDoNotSendMailOnSuccess] == SitecoreBooleanTrue;
if ((doNotSendMailOnSuccess && result == Failure) || !doNotSendMailOnSuccess)
{
try{
if (SendMail.SendMailWithoutAttachment(recipient, replyTo, subject, exporter.Export()) == Failure)
{
logger.AddError("Error", "The SendMailWithoutAttachment failed.");
}
}
catch (Exception ex)
{
logger.AddError("Error", "The SendMailWithoutAttachment failed with an exception: " + ex.Message);
}
}
}
}
public SqlDataMap(Database db, Item importItem, LevelLogger logger)
: base(db, importItem, logger)
{
if (string.IsNullOrEmpty(Query))
{
Logger.AddError("Error", "the 'Query' field was not set");
}
}
public CSVDataMap(Database db, Item importItem, LevelLogger logger, string data)
: base(db, importItem, logger)
{
Data = data;
HeaderColumns = new Dictionary <string, int>();
ImportData = new List <object>();
InitializeColumnDelimiterCharacter(importItem);
}
public void CheckStatus()
{
var job = JobManager.GetJob(Handle.Parse(JobHandle));
if (job != null)
{
var status = job.Status;
var state = status.State;
LevelLogger logger = (LevelLogger)job.Options.CustomData;
var dataSyncItem = logger.GetData(Utility.Constants.DataSyncItem) as Item;
if (status == null)
{
throw new Exception("The sync process was unexpectedly interrupted.");
}
if (state == JobState.Running)
{
NextButton.Disabled = true;
BackButton.Disabled = false;
CancelButton.Disabled = false;
if (logger.GetCounter(IncrementConstants.TotalNumberOfItems) > 0)
{
ImportStatusText.Text = logger.GetCounter(IncrementConstants.ProcessedItems) + " of " + logger.GetCounter(IncrementConstants.TotalNumberOfItems) + " items processed.";
}
else
{
ImportStatusText.Text = "Retrieving import data...";
}
if (logger.GetCounter(IncrementConstants.ProcessedItems) == logger.GetCounter(IncrementConstants.TotalNumberOfItems) && logger.GetCounter(IncrementConstants.ProcessedItems) != 0)
{
NotPresentStatusText.Text = "Processing items not present in import...";
//if (logger.TotalNumberOfNotPresentInImportItems > 0)
//{
// NotPresentStatusText.Text = logger.GetCounter(IncrementConstants.DisabledItems) + " of " +
// logger.TotalNumberOfNotPresentInImportItems +
// " items not present in import processed.";
//}
}
FailedText.Visible = logger.GetCounter(IncrementConstants.FailureItems) > 0;
FailedStatusText.Text = logger.GetCounter(IncrementConstants.FailureItems) + " items failed.";
}
else if (state == JobState.Finished)
{
Status.Text = String.Format("Items processed: {0}.", logger.GetCounter(IncrementConstants.ProcessedItems).ToString(CultureInfo.CurrentCulture));
Active = "LastPage";
BackButton.Disabled = true;
var exporter = Manager.CreateOutputHandler(dataSyncItem, logger);
string str2 = exporter.Export();
if (!string.IsNullOrEmpty(str2))
{
ResultText.Value = str2;
}
return;
}
SheerResponse.Timer("CheckStatus", 5);
}
}
protected virtual string GetBaseCacheKey(Item parent, ref LevelLogger logger)
{
if (parent == null)
{
logger.AddError("The parent item was null in the GetBaseCacheKey method.", "The parent item was null in the GetBaseCacheKey method.");
return(null);
}
return(parent.ID + "");
}
/// <summary>
/// Initializes the object.
/// </summary>
private void Start()
{
logger = LevelLogger.instance;
pathContainer = ObjectUtil.CreateNewObject("Paths");
pathMaterial = new Material(Shader.Find("Particles/Additive"));
if (logFile != null)
{
visible = true;
}
}
public void GetAllowedLevels_EmptyMessageTypesAllowed_ReturnNullException()
{
// Arrange
_levelLoggerSettingsMock.Setup(x => x.IsErrorTypeAllowed).Returns(false);
_levelLoggerSettingsMock.Setup(x => x.IsMessageTypeAllowed).Returns(false);
_levelLoggerSettingsMock.Setup(x => x.IsWarningTypeAllowed).Returns(false);
// Act & Assert
var levelLogger = new LevelLogger(_levelLoggerSettingsMock.Object);
levelLogger.GetAllowedLevels();
}
public SitecoreDataMap(Database db, Item importItem, LevelLogger logger)
: base(db, importItem, logger)
{
//deal with sitecore properties if any
Item Props = GetItemByTemplate(importItem, Utility.Constants.PropertiesFolderID);
if (Props.IsNotNull())
{
ChildList c = Props.GetChildren();
if (c.Any())
{
foreach (Item child in c)
{
//create an item to get the class / assembly name from
BaseMapping bm = new BaseMapping(child);
if (!string.IsNullOrEmpty(bm.HandlerAssembly))
{
if (!string.IsNullOrEmpty(bm.HandlerClass))
{
//create the object from the class and cast as base field to add it to field definitions
IBaseProperty bp = null;
try {
bp = (IBaseProperty)Sitecore.Reflection.ReflectionUtil.CreateObject(bm.HandlerAssembly, bm.HandlerClass, new object[] { child });
} catch (FileNotFoundException fnfe) {
Logger.AddError("Error", string.Format("the property:{0} binary {1} specified could not be found", child.Name, bm.HandlerAssembly));
}
if (bp != null)
{
PropertyDefinitions.Add(bp);
}
else
{
Logger.AddError("Error", string.Format("the property: '{0}' class type {1} could not be instantiated", child.Name, bm.HandlerClass));
}
}
else
{
Logger.AddError("Error", string.Format("the property: '{0}' Handler Class {1} is not defined", child.Name, bm.HandlerClass));
}
}
else
{
Logger.AddError("Error", string.Format("the property: '{0}' Handler Assembly {1} is not defined", child.Name, bm.HandlerAssembly));
}
}
}
else
{
Logger.AddError("Warn", "there are no properties to import");
}
}
}
/// <summary>
/// gets a field value from an item
/// </summary>
/// <param name="importRow"></param>
/// <param name="fieldName"></param>
/// <returns></returns>
public override string GetFieldValue(object importRow, string fieldName, ref LevelLogger logger)
{
var getFieldValueLogger = logger.CreateLevelLogger();
var importRowItem = importRow as Item;
if (importRowItem != null)
{
if (!String.IsNullOrEmpty(fieldName))
{
switch (fieldName.ToLower())
{
case ("@key"):
return(importRowItem.Key);
case ("@name"):
return(importRowItem.Name);
case ("@displayname"):
return(importRowItem.DisplayName);
case ("@id"):
return(importRowItem.ID.ToShortID().ToString());
case ("@parentid"):
return(importRowItem.Parent != null
? importRowItem.ParentID.ToShortID().ToString()
: string.Empty);
}
var field = importRowItem.Fields[fieldName];
if (field != null)
{
return(importRowItem[fieldName]);
}
getFieldValueLogger.AddError("The 'fieldName' didn't result in any field on the item", String.Format("The GetFieldValue method failed because the the 'fieldName' didn't result in any field on the item. ImportRow: {0}.", GetImportRowDebugInfo(importRow)));
}
else
{
getFieldValueLogger.AddError(CategoryConstants.TheFieldnameArgumentWasNullOrEmpty, String.Format("The GetFieldValue method failed because the the 'fieldName' was null or empty. ImportRow: {0}.", GetImportRowDebugInfo(importRow)));
}
}
else
{
getFieldValueLogger.AddError(CategoryConstants.TheImportRowWasNull, String.Format(
"The GetFieldValue method failed because the Import Row was null. FieldName: {0}.",
fieldName));
}
return(String.Empty);
}
public void GetAllowedLevels_AllTypesAllowed_ReturnListWithThreeElement()
{
// Arrange
_levelLoggerSettingsMock.Setup(x => x.IsErrorTypeAllowed).Returns(true);
_levelLoggerSettingsMock.Setup(x => x.IsMessageTypeAllowed).Returns(true);
_levelLoggerSettingsMock.Setup(x => x.IsWarningTypeAllowed).Returns(true);
// Act
var levelLogger = new LevelLogger(_levelLoggerSettingsMock.Object);
var result = levelLogger.GetAllowedLevels();
// Assert
var expectedItems = 3;
Assert.AreEqual(expectedItems, result.Count());
}
public LevelLogger RunDataSyncJob(Item dataSyncItem, ref LevelLogger logger)
{
string errorMessage = String.Empty;
var map = InstantiateDataMap(dataSyncItem, ref logger);
if (!String.IsNullOrEmpty(errorMessage))
{
logger.AddError("Error", errorMessage);
return(logger);
}
if (map != null)
{
logger = map.Process();
}
return(logger);
}
protected virtual string GetKeys(LevelLogger logger)
{
var sb = new StringBuilder();
if (logger != null && logger.Keys != null)
{
foreach (var keyValue in logger.Keys)
{
if (keyValue.Key == "Item")
{
continue;
}
sb.AppendFormat("{0}:{1} - ", keyValue.Key, keyValue.Value);
}
}
return(sb.ToString().TrimEnd(new[] { '-', ' ' }));
}
public virtual void Initialize(ref LevelLogger logger)
{
if (BaseDataMap.IsDisableItemsNotPresentInImport && BaseDataMap.DisableItemsFolderItem != null)
{
var disabledLogger = logger.CreateLevelLogger();
InitializeItemsCache(BaseDataMap.DisableItemsFolderItem, BaseDataMap.IdentifyTheSameItemsByFieldDefinition.GetNewItemField(), ref disabledLogger);
}
var itemsAndParentLogger = logger.CreateLevelLogger();
if (BaseDataMap.FolderByParentHierarchy)
{
InitializeItemsCache(BaseDataMap.Parent, BaseDataMap.IdentifyTheSameItemsByFieldDefinition.GetNewItemField() + "|" + BaseDataMap.IdentifyParentByWhatFieldOnParent, ref itemsAndParentLogger);
}
else
{
InitializeItemsCache(BaseDataMap.Parent, BaseDataMap.IdentifyTheSameItemsByFieldDefinition.GetNewItemField(), ref itemsAndParentLogger);
}
}
private bool TryParseElement(IEnumerable result, out string fieldValue, ref LevelLogger logger)
{
fieldValue = String.Empty;
try
{
var xElements = result.Cast <XElement>();
var elements = xElements as IList <XElement> ?? xElements.ToList();
if (elements.Count() > 1)
{
string pipeseperatedValues = String.Empty;
foreach (var element in elements)
{
if (element != null)
{
var value = element.Value;
if (!String.IsNullOrEmpty(value))
{
pipeseperatedValues += value + "|";
}
}
}
if (pipeseperatedValues.EndsWith("|"))
{
pipeseperatedValues = pipeseperatedValues.TrimEnd('|');
}
fieldValue = pipeseperatedValues;
return(true);
}
if (elements.Count() == 1)
{
var xElement = elements.First();
if (xElement != null)
{
fieldValue = xElement.Value;
return(true);
}
}
}
catch (Exception exception)
{
return(false);
}
return(false);
}
private bool TryParseAttribute(IEnumerable result, out string fieldValue, ref LevelLogger logger)
{
fieldValue = String.Empty;
try
{
var xAttributes = result.Cast <XAttribute>();
var attributes = xAttributes as IList <XAttribute> ?? xAttributes.ToList();
if (attributes.Count() > 1)
{
string pipeseperatedValues = String.Empty;
foreach (var attribute in attributes)
{
if (attribute != null)
{
var value = attribute.Value;
if (!String.IsNullOrEmpty(value))
{
pipeseperatedValues += value + "|";
}
}
}
if (pipeseperatedValues.EndsWith("|"))
{
pipeseperatedValues = pipeseperatedValues.TrimEnd('|');
}
fieldValue = pipeseperatedValues;
return(true);
}
if (attributes.Count() == 1)
{
var xAttribute = attributes.First();
if (xAttribute != null)
{
fieldValue = xAttribute.Value;
return(true);
}
}
}
catch (Exception exception)
{
return(false);
}
return(false);
}
public override void ValidateImportData(IList <object> importData, ref LevelLogger logger)
{
var validateImportDataLogger = logger.CreateLevelLogger();
foreach (var fieldDefinition in FieldDefinitions)
{
var newField = fieldDefinition.GetExistingFieldNames();
foreach (var existingFieldName in fieldDefinition.GetExistingFieldNames())
{
if (!HeaderColumns.ContainsKey(existingFieldName.ToLower()))
{
validateImportDataLogger.AddError("A column was expected but not found", String.Format("--- A column with name {0} was expected.\r\n", existingFieldName));
}
}
}
if (!validateImportDataLogger.HasErrors())
{
base.ValidateImportData(importData, ref validateImportDataLogger);
}
}
protected void StartImport()
{
var dataSyncItem = GetDataSyncItem();
var dataSyncManager = new DataSyncManager();
LevelLogger logger = Manager.CreateLogger(dataSyncItem);
OutputHandlerBase exporter = Manager.CreateOutputHandler(dataSyncItem, logger);
logger.AddKey(Utility.Constants.DataSyncItemId, dataSyncItem.ID.ToString());
logger.AddData(Utility.Constants.DataSyncItem, dataSyncItem);
var map = dataSyncManager.InstantiateDataMap(dataSyncItem, ref logger);
if (map != null)
{
if (!String.IsNullOrEmpty(DataValue))
{
map.Data = DataValue;
}
var options = new JobOptions("FromFileDataSyncWizard", "Job category name", Context.Site.Name, new FromFileDataSyncWizard(), "Run", new object[] { map, map.Logger, exporter });
var job = JobManager.Start(options);
job.Options.CustomData = map.Logger;
JobHandle = job.Handle.ToString();
SheerResponse.Timer("CheckStatus", 5);
}
else
{
Active = "LastPage";
BackButton.Disabled = true;
if (logger.HasErrorsOrInfos())
{
if (exporter != null)
{
ResultText.Value = exporter.Export();
}
else
{
ResultText.Value = "The Exporter class was null. Therefor the log was not written out.";
}
}
}
}
public void Work()
{
Item dataSyncItem = currentDB.Items[dataSyncItemId];
logger = Manager.CreateLogger(dataSyncItem);
if (dataSyncItem != null)
{
var dataSyncManager = new DataSyncManager();
dataSyncManager.RunDataSyncJob(dataSyncItem, ref logger);
//if (logBuilder != null)
//{
// txtMessage.Text = logBuilder.LogBuilder.Length < 1 ? "The import completed successfully. \r\nStatus: \r\n" + logBuilder.GetItemStatusText() : logBuilder.LogBuilder + "\r\nStatus: \r\n" + logBuilder.GetItemStatusText();
//}
//else
//{
// txtMessage.Text = "The log object was null.";
//}
}
}
public virtual bool VerifyConditionFromQuery(string line, ref LevelLogger logger)
{
var verifyConditionLogger = logger.CreateLevelLogger();
if (!String.IsNullOrEmpty(Query))
{
if (Query.Contains(DefaultQueryDelimiterCharacter))
{
var queryValues = Query.Split(DefaultQueryDelimiterCharacter);
if (queryValues.Length == 2)
{
string key = queryValues[0];
string value = queryValues[1];
if (!String.IsNullOrEmpty(key) && !String.IsNullOrEmpty(value))
{
var retrievedValue = GetFieldValue(line, key, ref verifyConditionLogger);
return(value.ToLower().Equals(retrievedValue.ToLower()));
}
else
{
verifyConditionLogger.AddError("The Query was in wrong format. Either Key or value was null or empty", String.Format("The provided Query '{0}' was in wrong format. Either of the key or value was null or empty. Format should be 'key{1}value' ie 'Category{1}Summer'. " +
"Key: {2}. Value: {3}. Line: {4}.", Query, DefaultQueryDelimiterCharacter, key, value, line));
}
}
else
{
verifyConditionLogger.AddError("The Query was in wrong format.", String.Format("The provided Query '{0}' was in wrong format. Format should be 'key{1}value' ie 'Category{1}Summer'. " +
"Line: {2}. QueryValues.Length: {3}.", Query, DefaultQueryDelimiterCharacter, line, queryValues.Length));
}
}
else
{
verifyConditionLogger.AddError("The Query didn't contain a valid delimiter character", String.Format("The provided Query '{0}' didn't contain a valid delimiter character. This character must be: '{1}'. Line: {2}. he VerifyConditionFromQuery method failed because the Query was null or empty.",
Query, DefaultQueryDelimiterCharacter, line));
}
return(false);
}
return(true);
}
public BaseDataMap InstantiateDataMap(Item dataSyncItem, ref LevelLogger logger)
{
var currentDB = Configuration.Factory.GetDatabase("master");
string handlerAssembly = dataSyncItem[FieldNameHandlerAssembly];
string handlerClass = dataSyncItem[FieldNameHandlerClass];
if (!String.IsNullOrEmpty(handlerAssembly))
{
if (!String.IsNullOrEmpty(handlerClass))
{
BaseDataMap map = null;
try
{
map = (BaseDataMap)Reflection.ReflectionUtil.CreateObject(handlerAssembly, handlerClass, new object[] { currentDB, dataSyncItem, logger });
}
catch (FileNotFoundException fnfe)
{
logger.AddError("Error", "The binary specified could not be found" + fnfe.Message);
}
if (map != null)
{
return(map);
}
logger.AddError("Error", String.Format("The data map provided could not be instantiated. Assembly:'{0}' Class:'{1}'", handlerAssembly, handlerClass));
}
else
{
logger.AddError("Error", "Import handler class is not defined");
}
}
else
{
logger.AddError("Error", "import handler assembly is not defined");
}
return(null);
}
public override void FillField(BaseDataMap map, object importRow, ref Item newItem, string importValue, out bool updatedField, ref LevelLogger logger)
{
var fillFieldLogger = logger.CreateLevelLogger();
updatedField = false;
if (IsRequired && string.IsNullOrEmpty(importValue))
{
fillFieldLogger.AddError(CategoryConstants.ImportedValueToFieldWasEmpty, String.Format(
"The Item '{0}' of template type: '{1}', field '{2}', but the imported value '{3}' was empty. This field must be provided when the field is required. The field was not updated.",
(object)map.GetItemDebugInfo(newItem), (object)newItem.TemplateName,
(object)NewItemField, (object)importValue));
return;
}
if (!ID.IsID(SourceList))
{
fillFieldLogger.AddError(CategoryConstants.SourceListNotAnValidSitecoreId, String.Format(
"The 'Source List' provided was not an valid Sitecore ID. SourceList: {0}. The Fill Field method was aborted and the fieldvalue was not updated.",
SourceList));
return;
}
var listParent = newItem.Database.GetItem(SourceList);
if (listParent != null)
{
if (!string.IsNullOrEmpty(importValue))
{
var matchingChildItem = GetMatchingChildItem(map, listParent, importValue);
var childItems = matchingChildItem as Item[] ?? matchingChildItem.ToArray();
if (childItems.Any())
{
var str = string.Empty;
foreach (var childItem in childItems)
{
if (childItem != null)
{
str += (str.Length > 0)
? "|" + childItem.ID
: childItem.ID.ToString();
}
}
var field = newItem.Fields[NewItemField];
if (field != null)
{
if (string.IsNullOrEmpty(str))
{
fillFieldLogger.AddError(CategoryConstants.ImportedValueDidntResultInAIdToStore, String.Format(
"The Item '{0}' of template type: '{1}' has a field '{2}', but the imported value '{3}' didn't result in a ID to store.",
(object)map.GetItemDebugInfo(newItem), (object)newItem.TemplateName,
(object)NewItemField, (object)importValue));
return;
}
if (field.Value != str)
{
field.Value = str;
updatedField = true;
}
}
if (IsRequired && field == null)
{
fillFieldLogger.AddError(CategoryConstants.RequiredFieldNotFoundOnItem, String.Format(
"The Item '{0}' of template type: '{1}' didn't contain a field with name '{2}'. This field must be present because the 'Is Required Field' is checked.",
map.GetItemDebugInfo(newItem), newItem.TemplateName,
NewItemField));
return;
}
}
else if (!this.DoNotRequireValueMatch)
{
fillFieldLogger.AddError(CategoryConstants.DidntLocateALookupItemWithTheValue, String.Format(
"The Item '{0}' of template type: '{1}' didn't locate a lookup Item with the value '{2}'.",
newItem.ID.ToString(), newItem.TemplateName, importValue));
return;
}
}
else if (this.IsRequired)
{
fillFieldLogger.AddError(CategoryConstants.TheGuidDidntResultInAHitForLookup, String.Format(
"The Item '{0}' of template type: '{1}' had a Guid field '{2}' where the imported value '{3}' didn't result any hit. Because the 'Is Required Field' is checked there must be found a value i Sitecore. The field was not updated.",
(object)map.GetItemDebugInfo(newItem), (object)newItem.TemplateName,
(object)NewItemField, (object)importValue));
return;
}
else if (newItem[NewItemField] != importValue)
{
newItem[NewItemField] = importValue;
updatedField = true;
}
}
if (IsRequired && listParent == null)
{
fillFieldLogger.AddError(CategoryConstants.TheGuidFieldHadASourcelistThatWasNull, String.Format(
"The Item '{0}' of template type: '{1}' had a Guid field '{2}' for which SourceList was null. This SourceList must be present because the 'Is Required Field' is checked.",
(object)map.GetItemDebugInfo(newItem), (object)newItem.TemplateName,
(object)this.NewItemField));
}
}
/// <summary>
/// gets custom data from a DataRow
/// </summary>
/// <param name="importRow"></param>
/// <param name="fieldName"></param>
/// <param name="errorMessage"></param>
/// <returns></returns>
public override string GetFieldValue(object importRow, string fieldName, ref LevelLogger logger)
{
var getFieldValueLogger = logger.CreateLevelLogger();
try
{
var xElement = importRow as XElement;
if (xElement != null)
{
if (!String.IsNullOrEmpty(fieldName))
{
try
{
// First retrieve the fieldName as an attribute
var attribute = xElement.Attribute(fieldName);
if (attribute != null)
{
string value = attribute.Value;
if (!String.IsNullOrEmpty(value))
{
return(value);
}
}
else
{
// Then retrieve the fieldname as an subelement
var subElements = xElement.Elements(fieldName);
var elementsList = subElements.ToList();
if (elementsList.Count() > 1)
{
// Log eror since document format is wrong. Has two or more elements with same name.
getFieldValueLogger.AddError("Found more than one subelement with FieldName", String.Format(
"The GetFieldValue method failed because the fieldName '{0}' resulted in more than one subelement in the Import Row. FieldName: {0}. ImportRow: {1}.",
fieldName, GetImportRowDebugInfo(importRow)));
}
else if (elementsList.Count() == 1)
{
var subElement = elementsList.First();
if (subElement != null)
{
var value = subElement.Value;
if (!String.IsNullOrEmpty(value))
{
return(value);
}
}
}
}
}
catch (XmlException)
{
// We do nothing since this is most likely because we have a xpath query as the fieldname.
}
// Now finally try to retrieve through a xPath query
var executeXPathLogger = getFieldValueLogger.CreateLevelLogger();
var result = ExecuteXPathQueryOnXElement(xElement, fieldName, ref executeXPathLogger);
if (executeXPathLogger.HasErrors())
{
executeXPathLogger.AddError("Failure in ExecuteXPathQueryOnXElement", String.Format("The GetFieldValue method failed in executing the ExecuteXPathQueryOnXElement method."));
}
string fieldValue;
if (result is string)
{
return(result as string);
}
var enumerable = result as IList <object> ?? result.Cast <object>().ToList();
if (TryParseAttribute(enumerable, out fieldValue, ref getFieldValueLogger))
{
return(fieldValue);
}
if (TryParseElement(enumerable, out fieldValue, ref getFieldValueLogger))
{
return(fieldValue);
}
}
else
{
getFieldValueLogger.AddError(CategoryConstants.TheFieldnameArgumentWasNullOrEmpty, String.Format("The GetFieldValue method failed because the 'fieldName' was null or empty. FieldName: {0}. ImportRow: {1}.", fieldName, GetImportRowDebugInfo(importRow)));
}
}
else
{
getFieldValueLogger.AddError(CategoryConstants.TheImportRowWasNull, String.Format("The GetFieldValue method failed because the Import Row was null. FieldName: {0}.", fieldName));
}
}
catch (Exception ex)
{
getFieldValueLogger.AddError(CategoryConstants.GetFieldValueFailed, String.Format("The GetFieldValue method failed with an exception. ImportRow: {0}. FieldName: {1}. Exception: {2}.", GetImportRowDebugInfo(importRow), fieldName, ex));
}
return(String.Empty);
}
protected IEnumerable ExecuteXPathQueryOnXElement(XElement xElement, string query, ref LevelLogger logger)
{
var executeXPathQueryLogger = logger.CreateLevelLogger();
if (xElement != null)
{
try
{
if (query == Dot)
{
return(GetInnerXml(xElement));
}
return(xElement.XPathEvaluate(query) as IEnumerable);
}
catch (Exception ex)
{
executeXPathQueryLogger.AddError("Exception occured ExecuteXPathQueryOnXElement executing the XPath", String.Format("An exception occured in the ExecuteXPathQueryOnXElement method executing the XPath query. Query: {0}. Exception: {1}.", query, GetExceptionDebugInfo(ex)));
}
}
executeXPathQueryLogger.AddError("XDocument was null in ExecuteXPathQueryOnXElement", "In ExecuteXPathQueryOnXElement method the XDocument was null.");
return(null);
}
