/// <summary>
        /// Adds the editable root control specific methods.
        /// </summary>
        /// <param name="assemblyCode">The assembly code.</param>
        /// <param name="process">The process.</param>
        public override void AddEditableRootControlSpecificMethods(StringBuilder assemblyCode, IProcessDefinition process)
        {
            base.AddEditableRootControlSpecificMethods(assemblyCode, process);

            assemblyCode.Append(@"
        public void Copy()
        {
            using (BypassPropertyChecks)
            {
                Locked = null;
                LockedByAccountId = null;
                LockedByAccountName = null;
                LastModifiedOn = DateTime.Now;
                IsNewVersion = true;
                ApplyEdit();
                Save(true);
            }
        }");

            //When we change IFileProcess, we need to add UploadFile(string fileName) method
            //and update FileFieldUpdater.Update()
            assemblyCode.Append(@"
        public void UploadFile()
        {
            DataPortal.Execute(new UploadFileCommand { FileName = FileName });
        }
        ");
        }

        /// <summary>
        /// This method is called after generation of all logic code in Editable Root AddBusinessRules method.
        /// </summary>
        /// <param name="code">Code holder.</param>
        /// <param name="process">Generating process definition.</param>
        public override void OnAfterEditableRootAddBusinessRules(StringBuilder code, IProcessDefinition process)
        {
            base.OnAfterEditableRootAddBusinessRules(code, process);

            code.Append(@" BusinessRules.AddRule(new CalendarsWorkingIntervalsRule());");
            code.Append(@" BusinessRules.AddRule(new CalendarsUniqNameRule());"); 
        }

        /// <summary>
        /// This method is called before ActionManager.InvokeActions in EditableRoot.DataPortal_Update.
        /// </summary>
        /// <param name="code">
        /// The code.
        /// </param>
        /// <param name="process">
        /// The process.
        /// </param>
        public override void OnBefore_EditableRoot_DataPortal_Update_InvokeActions(StringBuilder code, IProcessDefinition process)
        {
            // Update action items if BasePerson.OutOfOffice changes.
            code.AppendFormat(@"
            ActionItemManager.CheckOutOfOffice(this, oldItem);
");
        }

        /// <summary>
        /// Called when [after_ add class properties].
        /// </summary>
        /// <param name="assemblyCode">The assembly code.</param>
        /// <param name="process">The process.</param>
        /// <param name="isInfoProperty">if set to <c>true</c> [is information property].</param>
        /// <param name="resolveRefTypes">if set to <c>true</c> [resolve reference types].</param>
        /// <param name="skipId">if set to <c>true</c> [skip identifier].</param>
        public override void OnAfter_AddClassProperties(StringBuilder assemblyCode, IProcessDefinition process, bool isInfoProperty, bool resolveRefTypes, bool skipId = false)
        {
            if (!isInfoProperty) return;

            foreach (var crf in process.RootTable.FieldList.Where(f => f.ColumnType == ColumnTypes.Reference && !f.IsHidden && f.IncludeInList))
            {
                assemblyCode.AppendFormat(@"
        private {1}Info _{0}Member;
        public {1}Info {0}Member
        {{ 
            get 
            {{
                if (_{0}Member == null && {0}Id > 0) 
                {{
                    var items = {1}List.Get{1}PageList(string.Empty, {0}Id, 1, null, null);
                    if (items.Count > 0) 
                    {{
                        _{0}Member = items[0];
                    }}
                }}
                return _{0}Member;
            }}
        }}
"
                    , crf.ColumnName, crf.ReferencedProcessName);
            }
        }

        /// <summary>
        /// Called when [after_ editable child_ data portal_ fetch].
        /// </summary>
        /// <param name="code">The code.</param>
        /// <param name="process">The process.</param>
        public override void OnAfter_EditableChild_DataPortal_Fetch(StringBuilder code, IProcessDefinition process)
        {
            base.OnAfter_EditableChild_DataPortal_Fetch(code, process);

            AddUpdateApprovalMembers(code, process);
            AddLoadApprovalOverrideMembers(code, process);
        }

        /// <summary>
        /// Called when [before_ editable root_ data portal_ insert_ update children].
        /// </summary>
        /// <param name="assemblyCode">The assembly code.</param>
        /// <param name="process">The process.</param>
        public override void OnBefore_EditableRoot_DataPortal_Insert_UpdateChildren(StringBuilder assemblyCode, IProcessDefinition process)
        {
            base.OnBefore_EditableRoot_DataPortal_Insert_UpdateChildren(assemblyCode, process);
			if (process.SampleFields == null)
				return;

            foreach (var sample in process.SampleFields.Values)
            {
                assemblyCode.AppendFormat(@"
            if ({0} == null || {0}.Count == 0)
            {{
                LoadProperty({0}Property, {0}SampleList.PopulateSampleList(this));
            }}
            ", sample.Name);

                //if it is not 0 or 1 or 2 which are indexes of SampleType because this is how sample type was stored in old processes
                if (!string.IsNullOrEmpty(sample.SampleTypeFieldName) && !Char.IsDigit(sample.SampleTypeFieldName[0]))
                {
                    assemblyCode.AppendFormat(@"
            if (string.IsNullOrEmpty({0}))
                LoadProperty({0}Property, ""Number"");
            ", sample.SampleTypeFieldName);
                }
            }
        }

        /// <summary>
        /// Editables the root_ generate control specific functions.
        /// </summary>
        /// <param name="code">The code.</param>
        /// <param name="process">The process.</param>
        public override void EditableRoot_GenerateControlSpecificFunctions(StringBuilder code, IProcessDefinition process)
        {
            base.EditableRoot_GenerateControlSpecificFunctions(code, process);

            foreach (var field in process.TableList[0].FieldList.Where(x => x.ColumnType == ColumnTypes.File && (x.ConvertToPdf || x.UseReport)))
            {
                if (string.IsNullOrEmpty(field.CoverPagePortraitReportName) && string.IsNullOrEmpty(field.CoverPageLandscapeReportName) &&
                    string.IsNullOrEmpty(field.WatermarkPortraitReportName) && string.IsNullOrEmpty(field.WatermarkLandscapeReportName) &&
                    string.IsNullOrEmpty(field.AppendixLandscapeReportName) && string.IsNullOrEmpty(field.AppendixPortraitReportName) &&
                    string.IsNullOrEmpty(field.ReportName)) continue;

                code.Append("\t\t\t").Append(@"
        [NonSerialized]
        [NotUndoable]
        private IFileManager _fileManager;

        public IFileManager TheFileManager
        {
            get 
            { 
                return _fileManager ??
                      (_fileManager = ImportDependency<IFileManager>());
            }
            set { _fileManager = value; }
        }
");
                return;
            }

        }

        /// <summary>
        /// Called when [after_ editable root_ data portal_ create].
        /// </summary>
        /// <param name="code">The code.</param>
        /// <param name="process">The process.</param>
        public override void OnAfter_EditableRoot_DataPortal_Create(StringBuilder code, IProcessDefinition process)
        {
            base.OnAfter_EditableRoot_DataPortal_Create(code, process);

            code.AppendFormat(@"
            LoadProperty({0}Property, false);", Constants.OutOfOfficePropertyName).AppendLine();
        }

        /// <summary>
        /// Adds extra properties to EditableRoot.
        /// </summary>
        /// <param name="code">The source code under generation.</param>
        /// <param name="process">Current process.</param>
        public override void AddEditClassProperties(StringBuilder code, IProcessDefinition process)
        {
            base.AddEditClassProperties(code, process);

            if (process.SampleFields == null)
                return;

            foreach (var sample in process.SampleFields.Values)
            {
                var sampleSettings = new XElement("SampleSettings",
                   new XAttribute("Id", sample.Id),
                   new XAttribute("SampleTypeFieldName", sample.SampleTypeFieldName),
                   new XAttribute("UpperSpecFieldName", sample.UpperSpecFieldName),
                   new XAttribute("LowerSpecFieldName", sample.LowerSpecFieldName),
                   new XAttribute("SamplingTechniqueFieldName", sample.SamplingTechniqueFieldName),
                   new XAttribute("SampleSizeType", sample.SampleSizeType.ToString()),
                   new XAttribute("SampleSizeFieldName", sample.SampleSizeFieldName),
                   new XAttribute("BatchSizeFieldName", sample.BatchSizeFieldName),
                   new XAttribute("AQLTableFieldName", sample.AQLTableFieldName),
                   new XAttribute("AQLFieldName", sample.AQLFieldName),
                   new XAttribute("NumberOfDecimalsFieldName", sample.NumberOfDecimalsFieldName));

                code.AppendFormat(@"
		public string {0}{1}
		{{
			get {{ return ""{2}""; }}
		}}
", sample.Name, Constants.SampleSettingPostfix, sampleSettings.ToString().Replace("\"", "\\\""));
            }
        }

        /// <summary>Gets the audit from cross referenced table for CR fields with Link Field.</summary>
        /// <param name="process">The process.</param>
        /// <returns></returns>
        private string GetAuditUnions(IProcessDefinition process)
        {
            var code = new StringBuilder();
            foreach (var field in process.TableList[0].FieldList.Where(f => f.IsRef && !string.IsNullOrEmpty(f.LinkFieldSystemName)))
            {
                code.AppendLine().AppendFormat(@"
UNION ALL
SELECT [Id]
      ,[Type]
      ,@id
      ,'{0}'
      ,''
      ,'Link added: Process={1}, Id=' + CAST([ItemId] AS VARCHAR(10))
      ,[UpdateDate]
      ,[UserName]
FROM [audit].[{1}]
WHERE NewValue LIKE 'Process={2}, Id=' + CAST(@id AS VARCHAR(10)) + ',%'
UNION ALL
SELECT [Id]
      ,[Type]
      ,@id
      ,'{0}'
      ,'Link removed: Process={1}, Id=' + CAST([ItemId] AS VARCHAR(10))
	  ,''
      ,[UpdateDate]
      ,[UserName]
FROM [audit].[{1}]
WHERE OldValue LIKE 'Process={2}, Id=' + CAST(@id AS VARCHAR(10)) + ',%'", field.SystemName, field.ReferenceColumnTable, process.Name).AppendLine();
            }

            if (code.Length > 0)
                code.AppendLine().Append("ORDER BY UpdateDate DESC");

            return code.ToString();
        }

        /// <summary>
        /// Adds extra properties to EditableRoot.
        /// </summary>
        /// <param name="code">The source code under generation.</param>
        /// <param name="process">Current process.</param>
        public override void AddEditClassProperties(StringBuilder code, IProcessDefinition process)
        {
            base.AddEditClassProperties(code, process);

            foreach (var field in process.RootTable.FieldList.Where(f => f.ColumnType == ColumnTypes.Frequency))
            {
                code.AppendFormat(
                    @"
            public Cebos.Veyron.SharedTypes.FrequencyInfo {0}{4}
            {{
                get
                {{
                    return new Cebos.Veyron.SharedTypes.FrequencyInfo({0}, {0}{1}, {0}{2}, {0}{3});
                }}

                set
                {{
                    {0} = value.Name;
                    {0}{1} = value.FrequencyType;
                    {0}{2} = value.FrequencyHours;
                    {0}{3} = value.SelectedEvent;
                }}
            }}
",
                    field.SystemName,
                    Constants.FrequencyEventTypeFieldSuffix,
                    Constants.FrequencyEventHoursFieldSuffix,
                    Constants.FrequencyEventSelectedFrequencyFieldSuffix,
                    Constants.FrequencyEventInfoFieldSuffix);
            }
        }

		public ActivityFormImpl(IProcessDefinition processDefinition, IList fields, IDictionary attributeValues)
		{
			this._processDefinition = processDefinition;
			this._activityState = (IActivityState) processDefinition.StartState;
			this._fields = fields;
			this._attributeValues = attributeValues;
			InitTransitionNames(processDefinition.StartState);
		}

 public override void OnBefore_EditableRoot_DataPortal_Insert_UpdateChildren(StringBuilder code, IProcessDefinition process)
 {
     foreach (var gageField in process.RootTable.FieldList.Where(x => x.ColumnType == ColumnTypes.GageRR))
     {
         code.AppendFormat(@"
     DataPortal.UpdateChild({0}_Member, new MsaUpdateCriteria{{ParentId = Id, Connection = connection}});", gageField.SystemName);
     }
 }

        /// <summary>
        /// This method is called after generation of all logic code in Editable Root AddBusinessRules method.
        /// </summary>
        /// <param name="code">Code holder.</param>
        /// <param name="process">Generating process definition.</param>
        public override void OnAfterEditableRootAddBusinessRules(StringBuilder code, IProcessDefinition process)
        {
            base.OnAfterEditableRootAddBusinessRules(code, process);

            code.Append(@"BusinessRules.AddRule(new FrequencyPatternNameRule(NameProperty));")
                .AppendLine()
                .Append(@"BusinessRules.AddRule(new FrequencyPatternPatternTypeRule(PatternTypeProperty));");
        }

        /// <summary>
        /// Adds the update approval members.
        /// </summary>
        /// <param name="code">The code.</param>
        /// <param name="process">The process.</param>
        private void AddUpdateApprovalMembers(StringBuilder code, IProcessDefinition process)
        {
            if (process.RootTable.FieldList.All(f => f.ColumnType != ColumnTypes.Approval))
                return;

            code.AppendFormat(@"
            UpdateApprovalMembers();");
        }

        /// <summary>
        /// Called when [after_ editable root_ data portal_ insert].
        /// </summary>
        /// <param name="code">The code.</param>
        /// <param name="process">The process.</param>
        public override void OnAfter_EditableRoot_DataPortal_Insert(StringBuilder code, IProcessDefinition process)
        {
            base.OnAfter_EditableRoot_DataPortal_Insert(code, process);
            if (process.RootTable.FieldList.All(f => f.ColumnType != ColumnTypes.AutoNumber)) return;

            code.AppendLine(@"
                }");
        }

        private IEnumerable<string> GetSourceFields(IProcessDefinition process, TableFieldDefinition field, string expression, bool onlyRoot)
        {
            var sourceFields = ExpressionService.GetExpressionSourceFields(expression, onlyRoot).ToArray();
            var allSourceFields = sourceFields.Concat(sourceFields.Select(x => x + "Member"));
            var localization = field.Localization ?? process.DefaultLocalization;
            allSourceFields = allSourceFields.Concat(sourceFields.Select(x => LocalizationUtils.GetLocalizedFieldName(x, localization.Culture.Name)));

            return allSourceFields;
        }

        /// <summary>
        /// Called when [after_ editable root_ data portal_ create].
        /// </summary>
        /// <param name="code">The code.</param>
        /// <param name="process">The process.</param>
        public override void OnAfter_EditableRoot_DataPortal_Create(StringBuilder code, IProcessDefinition process)
        {
            base.OnAfter_EditableRoot_DataPortal_Create(code, process);

             foreach (var sample in process.SampleFields.Values)
             {
                 code.AppendFormat("\r\n\t\t\tLoadProperty({0}Property, {0}SampleList.GetSampleList(new DynamicSampleCriteria(this)));", sample.Name);
             }
        }        

 /// <summary>
 /// Initializes a new instance of the <see cref="AssemblyGeneratorContext"/> class.
 /// </summary>
 /// <param name="process">The process.</param>
 /// <param name="assemblyType">The assembly type.</param>
 /// <param name="pubInfo">The pub info.</param>
 public AssemblyGeneratorContext(
     IProcessDefinition process,
     AssemblyType assemblyType = AssemblyType.Client,
     PublisherInformation pubInfo = null)
 {
     PubInfo = pubInfo;
     AssemblyType = assemblyType;
     Process = process;
 }

 /// <summary>
 /// This method is called after generation of all logic code in Editable Root OnChildChanged method.
 /// </summary>
 /// <param name="code">Code holder.</param>
 /// <param name="process">Generating process definition.</param>
 public override void OnAfter_EditableRoot_OnChildChanged(StringBuilder code, IProcessDefinition process)
 {
     base.OnAfter_EditableRoot_OnChildChanged(code, process);
     code.Append(@"
     CheckPropertyRules(NameProperty);
     CheckPropertyRules(WorkingIntervalsProperty);
     CheckPropertyRules(WorkingExceptionsProperty);
                  ");
 }