/// <summary>
        /// Gets the synchronization map.
        /// </summary>
        /// <param name="process">The process.</param>
        /// <param name="syncProcess">The synchronize process.</param>
        /// <returns>System.String.</returns>
        private string GetSynchronizationMap(IProcessDefinition process, SyncProcessDefinition syncProcess)
        {
            var result = new StringBuilder();

            result.AppendFormat(
                @"
            _synchronizationMap = new SynchronizationMap();
");

            foreach (var destinationField in syncProcess.DestinationFields)
            {
                if (destinationField.SystemName == Constants.Version)
                {
                    result.Append(GetAddVersionFields(process, destinationField));
                    continue;
                }

                if (destinationField.SystemName == Constants.CurrentStateColumnName)
                {
                    result.Append(GetAddCurrentStateField(process, destinationField));
                    continue;
                }

                var tableField = GetTableField(process, destinationField.SystemName);

                if (tableField == null)
                    continue;

                if (tableField.IsRef)
                {
                    result.Append(GetAddCrossReferenceField(process, tableField, destinationField));
                    continue;
                }

                result.Append(GetAddGenericField(process, tableField, destinationField));
            }

            return result.ToString();
        }
        /// <summary>
        /// Gets the synchronize schedules.
        /// </summary>
        /// <param name="syncProcess">The synchronize process.</param>
        /// <returns>System.String.</returns>
        private string GetSyncSchedules(SyncProcessDefinition syncProcess)
        {
            var sb = new StringBuilder();

            sb.AppendFormat(@"
            _schedules = new ISchedule[]
            {{
");

            foreach (var schedule in syncProcess.Schedules)
                sb.AppendFormat(
                    @"
                new Schedule
                {{
                    Name = {0},
                    Description = {1},
                    StartDate = {2},
                    EndDate = {3},
                    Pattern = {4},
                    DailyFrequency = {5},
                    IsActive = {6},
                    Guid = Guid.Parse(""{7}"")
                }},
",
                    schedule.Name.ToLiteral(),
                    schedule.Description.ToLiteral(),
                    schedule.StartDate.HasValue
                        ? string.Format(@"new DateTime({0})", schedule.StartDate.Value.Ticks)
                        : "null",
                    schedule.EndDate.HasValue
                        ? string.Format(@"new DateTime({0})", schedule.EndDate.Value.Ticks)
                        : "null",
                    GetSyncSchedulePattern(schedule.Pattern),
                    GetSyncScheduleDailyFrequency(schedule.DailyFrequency),
                    schedule.IsActive ? "true" : "false",
                    schedule.Guid);

            sb.AppendFormat(@"
            }};
");

            return sb.ToString();
        }
 /// <summary>
 /// Gets the synchronize data provider.
 /// </summary>
 /// <param name="syncProcess">The synchronize process.</param>
 /// <returns>System.String.</returns>
 private static string GetSyncDataProvider(SyncProcessDefinition syncProcess)
 {
     return syncProcess.DataProvider == null ? string.Empty : string.Format("_dataProvider = {0};", syncProcess.DataProvider.GetNewDataProviderCode());
 }
 /// <summary>
 /// Gets the name of the synchronizer class.
 /// </summary>
 /// <param name="syncProcess">The synchronize process.</param>
 /// <returns>System.String.</returns>
 private static string GetSynchronizerClassName(SyncProcessDefinition syncProcess)
 {
     return string.Format("Sync_{0}", syncProcess.Guid.ToString().Replace("-", "_"));
 }
        /// <summary>
        /// Gets the synchronize class.
        /// </summary>
        /// <param name="syncProcess">The synchronize process.</param>
        /// <param name="process">The process.</param>
        /// <returns>System.String.</returns>
        private string GetSyncClass(SyncProcessDefinition syncProcess, IProcessDefinition process)
        {
            var sb = new StringBuilder();

            sb.AppendFormat(
                @"
    [Serializable]
    [ExportAsProcessSynchronizer({0}, {1})]
    public class {2} : IProcessSynchronizer
    {{
        {3}
        ",
                process.Name.ToLiteral(),
                syncProcess.Name.ToLiteral(),
                GetSynchronizerClassName(syncProcess),
                GetSyncProviderItemClass(syncProcess));

            sb.AppendFormat(
                @"
        private static readonly IDataProvider _dataProvider;

        private static readonly ISchedule[] _schedules;

        private static readonly SynchronizationMap _synchronizationMap;

        static {0}()
        {{
            {1}
            {2}
            {6}
        }}

        public string Name {{ get {{ return {3}; }} }}

        public string ProcessName {{ get {{ return {5}; }} }}

        public System.Guid Guid {{ get {{ return new System.Guid(""{4}""); }} }}

        public Cebos.Veyron.SharedTypes.ESyncAction Action {{ get {{ return Cebos.Veyron.SharedTypes.ESyncAction.{7}; }} }}

        public IDataProvider DataProvider
        {{
            get {{ return _dataProvider; }}
        }}

        public ISchedule[] Schedules
        {{
            get {{ return _schedules; }}
        }}

        public ISynchronizationMap SynchronizationMap
        {{
            get {{ return _synchronizationMap; }}
        }}
",
                GetSynchronizerClassName(syncProcess),
                GetSyncDataProvider(syncProcess),
                GetSyncSchedules(syncProcess),
                syncProcess.Name.ToLiteral(),
                syncProcess.Guid,
                process.Name.ToLiteral(),
                GetSynchronizationMap(process, syncProcess),
                syncProcess.Action);

            sb.AppendFormat(
                @"
        public _ProviderItem CreateDynamicItem(ProviderItem item)
        {{
            return new _ProviderItem(item);
        }}

        ISyncDynamicItem IProcessSynchronizer.CreateDynamicItem(ProviderItem item)
        {{
            return CreateDynamicItem(item);
        }}
            
        private readonly IValueCalculator _valueCalculator = new _ValueCalculator();

        public IValueCalculator ValueCalculator
        {{
            get {{ return _valueCalculator; }}
        }}
");

            var expressionScripts = !string.IsNullOrEmpty(syncProcess.MapDesigner)
                                        ? ExpressionService.PrepareScriptForMultipleDestinations(
                                            syncProcess.MapDesigner, null)
                                        : new Dictionary<string, string>();

            sb.AppendFormat(
                @"
        public class _ValueCalculator : ValueCalculatorBase
        {{
            public override bool TryGetValue(IDynamicObject providerItem, string mappingKey, out object result)
            {{
                switch (mappingKey)
                {{
");

            foreach (var pair in expressionScripts)
            {
                sb.AppendFormat(
                    @"
                case {0}:
                    result = {1};
                return true;
",
                    pair.Key.ToLiteral(), pair.Value);
            }

            sb.AppendFormat(
                @"
                default:
                    result = null;
                return false;
                }}
            }}
");

            sb.AppendFormat(
                @"
            public override bool ContainsKey(string mappingKey)
            {{
                var keys = new string[] {{ {0} }};

                return keys.Contains(mappingKey);
            }}
        }}
", string.Join(", ", expressionScripts.Keys.Select(s => s.ToLiteral())));

            sb.AppendFormat(@"
    }}
");

            return sb.ToString();
        }
        /// <summary>
        /// Gets the synchronize provider item class.
        /// </summary>
        /// <param name="syncProcess">The synchronize process.</param>
        /// <returns>System.String.</returns>
        /// <exception cref="System.NotSupportedException">The specified identity type is not supported:  + field.IdentityType</exception>
        private string GetSyncProviderItemClass(SyncProcessDefinition syncProcess)
        {
            var sb = new StringBuilder();

            sb.AppendFormat(@"
        public class _ProviderItem : Cebos.Veyron.ESync.SyncDocument.SyncDynamicItemBase
        {{");

            foreach (var field in syncProcess.ProviderFields)
                sb.AppendFormat(
                    @"
            public {1} {0} {{ get; set; }}",
                    field.SystemName,
                    GetCSharpType(field));

            sb.AppendLine();
            sb.AppendFormat(
                @"
            public _ProviderItem(Cebos.Veyron.ESync.SyncDocument.ProviderItem item)
            {{
");

            foreach (var field in syncProcess.ProviderFields)
            {
                switch (field.IdentityType)
                {
                    case ESyncSourceFieldIdentityTypes.Index:
                        if (field.Index.HasValue)
                            sb.Append("\t\t\t\t")
                              .AppendFormat(
                                  @"this.{0} = SafeTypeConverter.Convert<{1}>(item.GetValue({2}));",
                                  field.SystemName,
                                  GetCSharpType(field),
                                  field.Index.Value.ToLiteral())
                              .AppendLine();
                        break;

                    case ESyncSourceFieldIdentityTypes.Name:
                        if (!string.IsNullOrEmpty(field.FieldName))
                            sb.Append("\t\t\t\t")
                              .AppendFormat(
                                  @"this.{0} = SafeTypeConverter.Convert<{1}>(item.GetValue({2}));",
                                  field.SystemName,
                                  GetCSharpType(field),
                                  field.FieldName.ToLiteral())
                              .AppendLine();
                        break;

                    default:
                        throw new NotSupportedException("The specified identity type is not supported: " + field.IdentityType);
                }
            }

            sb.AppendFormat(@"
            }}
        }}");

            return sb.ToString();
        }