/// <summary>
        /// Creates the SyncQueueItem from the given data and adds it to the sync queue
        /// </summary>
        private void AddToQueue(FileSystemEventArgs e, ChangeAction action)
        {
            var isFile = Common.PathIsFile(e.FullPath);
            // ignore directory changes
            if (!isFile && action == ChangeAction.changed) return;

            var queueItem = new SyncQueueItem(controller)
                {
                    Item = new ClientItem
                        {
                            Name = e.Name,
                            FullPath = e.FullPath,
                            Type = isFile ? ClientItemType.File : ClientItemType.Folder,
                            Size = (isFile && action != ChangeAction.deleted) ? new FileInfo(e.FullPath).Length : 0x0,
                            LastWriteTime = File.GetLastWriteTime(e.FullPath)
                        },
                    SyncTo = SyncTo.Remote,
                    ActionType = action
                };

            if (action == ChangeAction.renamed)
            {
                var args = e as RenamedEventArgs;
                queueItem.Item.FullPath = args.OldFullPath;
                queueItem.Item.NewFullPath = args.FullPath;
            }
            // Send to the sync queue
            controller.SyncQueue.Add(queueItem);
        }

        /// <summary>
        /// Validates this instance.
        /// </summary>
        /// <param name="dao">The DAO for additional data validation.</param>
        /// <param name="changeAction">The change action.</param>
        internal override void Validate(GenericDao dao, ChangeAction changeAction)
        {
            // Perform custom validation
            if (changeAction == ChangeAction.Update)
            {
                this.ValidateGreaterThanZero(() => this.ReportGenerationQueueId);
            }

            if (changeAction == ChangeAction.Insert || changeAction == ChangeAction.Update)
            {
                //// If (Enum.IsDefined(typeof(Enums.ReportStatus), this.ReportGenerationStatus))
                ////{
                ////    this.Errors.Add("The report generation status is invalid");
                ////}

                Regex periodRegex = new Regex(@"^\d{6,6}$");

                if (!periodRegex.IsMatch(this.Period.ToString()))
                {
                    this.Errors.Add("The report period is not a valid period");
                }

                Regex quarterNameRegex = new Regex("^Q[0-3]$");

                if (this.ReforecastQuarterName == null)
                {
                    this.Errors.Add("The reforecast quarter cannot be empty");
                }
                else if (!quarterNameRegex.IsMatch(this.ReforecastQuarterName))
                {
                    this.Errors.Add("The reforecast quarter is not a valid period");
                }
            }
        }

        /// <summary>
        /// Shows a notification regarding an action on one file OR folder
        /// </summary>
        /// <param name="name">The name of the file or folder</param>
        /// <param name="ca">The ChangeAction</param>
        /// <param name="file">True if file, False if Folder</param>
        public static void Show(string name, ChangeAction ca, bool file)
        {
            if (!Settings.General.Notifications) return;

            name = Common._name(name);

            InvokeNotificationReady(null, new NotificationArgs { Title = Common.Languages[ca, file], Text = name });
        }

 protected void RaiseComponentsChanged( ComponentModel componentModel, ChangeAction action )
 {
     var handler = ComponentsChanged;
      if ( handler != null )
      {
     handler( this, new ComponentsChangedEventArgs( componentModel, action ) );
      }
 }

partial         void OnValidate(ChangeAction action)
        {
            if (!IsValid)
            {
                RuleViolation first = GetRuleViolations().First();
                throw new RuleViolationException(first.ErrorMessage);
            }
        }

 /// <summary>
 /// Validates this instance.
 /// </summary>
 /// <param name="dao">The DAO for additional data validation.</param>
 /// <param name="changeAction">The change action.</param>
 internal override void Validate(GenericDao dao, ChangeAction changeAction)
 {
     // Perform custom validation
     if (changeAction == ChangeAction.Update)
     {
         this.ValidateGreaterThanZero(() => this.ReportParameterActivityTypeId);
     }
 }

        /// <summary>
        /// Shows a notification that a file or folder was renamed.
        /// </summary>
        /// <param name="name">The old name of the file/folder</param>
        /// <param name="ca">file/folder ChangeAction, should be ChangeAction.renamed</param>
        /// /// <param name="newname">The new name of the file/folder</param>
		public static void Show(string name, ChangeAction ca, string newname)
		{					
			if (!Settings.General.Notifications) return;

            name = Common._name(name);
            newname = Common._name(newname);
            string body = string.Format(Common.Languages[ChangeAction.renamed, true], name, newname);
            NotificationReady.SafeInvoke(null, new NotificationArgs { Text = body });
		}

        /// <summary>
        /// Shows a notification that a file or folder was renamed.
        /// </summary>
        /// <param name="name">The old name of the file/folder</param>
        /// <param name="ca">file/folder ChangeAction, should be ChangeAction.renamed</param>
        /// /// <param name="newname">The new name of the file/folder</param>
        public static void Show(string name, ChangeAction ca, string newname)
        {
            if (!Settings.settingsGeneral.Notifications) return;

            name = Common._name(name);
            newname = Common._name(newname);
            string body = string.Format(Get_Message(ChangeAction.renamed, true), name, newname);
            InvokeNotificationReady(null, new NotificationArgs { Text = body });
        }

        /// <summary>
        /// Shows a notification regarding an action on one file OR folder
        /// </summary>
        /// <param name="name">The name of the file or folder</param>
        /// <param name="ca">The ChangeAction</param>
        /// <param name="file">True if file, False if Folder</param>
        public static void Show(string name, ChangeAction ca, bool file)
        {
            if (!Settings.settingsGeneral.Notifications) return;

            name = Common._name(name);
            string body = string.Format(Get_Message(ca, file), name);

            NotificationReady(null, new NotificationArgs { Text = body });
        }

        public ChangesetPath(ChangeAction action, string path)
        {
            if (string.IsNullOrEmpty(path))
            {
                throw new ArgumentOutOfRangeException("path", path, "Path cannot be null or empty.");
            }

            _action = action;
            _path = path.Trim();
        }

partial         void OnValidate(ChangeAction action)
        {
            using (CmsDataContext dc = new CmsDataContext())
            {
                if (this.ManufaturerId == null)
                    this.ManufaturerId = dc.DiscBrands.SingleOrDefault(m => m.Name == this.Manufacturer).Id;
                if (this.ManufaturerId != null)
                    this.Manufacturer = dc.DiscBrands.SingleOrDefault(m => m.Id == this.ManufaturerId).Name;
            }
        }

partial         void OnValidate(ChangeAction action)
        {
            if (action == ChangeAction.Insert)
            {
                using (var dc = new TecdocStoreDataContext())
                {
                    if (dc.NameCorrections.SingleOrDefault(
                         m => m.OriginalName == OriginalName) != null)
                        throw new ValidationException("это значение уже есть в списке");
                }
            }
        }

        /// <summary>
        /// Validates this instance.
        /// </summary>
        /// <param name="dao">The DAO for additional data validation.</param>
        /// <param name="changeAction">The change action.</param>
        internal override void Validate(GenericDao dao, ChangeAction changeAction)
        {
            // Perform custom validation
            if (changeAction == ChangeAction.Update)
            {
                this.ValidateGreaterThanZero(() => this.ReportGenerationBatchId);
            }

            if (changeAction == ChangeAction.Insert || changeAction == ChangeAction.Update)
            {
            }
        }

 /// <summary>
 /// Validates this instance.
 /// </summary>
 /// <param name="dao">The DAO for additional data validation.</param>
 /// <param name="changeAction">The change action.</param>
 internal override void Validate(GenericDao dao, ChangeAction changeAction)
 {
     // Perform custom validation
     if (changeAction == ChangeAction.Insert || changeAction == ChangeAction.Update)
     {
         Regex currencyRegex = new Regex("^[A-Z]{3}$");
         if (!currencyRegex.IsMatch(this.CurrencyCode))
         {
             this.Errors.Add("The currency code is invalid");
         }
     }
 }

partial         void OnValidate(ChangeAction action)
        {
            if (action == ChangeAction.Insert)
            {
                using (CmsDataContext dc = new CmsDataContext())
                {
                    if (dc.Brands.SingleOrDefault(
                        m => m.Name == Name && m.VehicleType == VehicleType ) != null )
                        throw new ValidationException("марка с названием '" +
                            Name +
                            "' уже существует");
                }
            }
        }

partial         void OnValidate(ChangeAction action)
        {
            if (action == ChangeAction.Insert)
            {
                using (CmsDataContext dc = new CmsDataContext())
                {
                    if (dc.Manufacturers.SingleOrDefault(
                        m => m.Name == Name) != null)
                        throw new ValidationException("производитель с названием '" +
                            Name +
                            "' уже существует");
                }
            }
        }

partial         void OnValidate(ChangeAction action)
        {
            if (action == ChangeAction.Insert)
            {
                using (var dc = new TecdocStoreDataContext())
                {
                    if (dc.CountryVisibilities.SingleOrDefault(
                         c => c.CountryID == CountryID) != null)
                        throw new ValidationException("эта страна уже есть в списке видимых");
                }
            }
            if (HttpContext.Current.Cache["visibleCountries"] != null)
                HttpContext.Current.Cache.Remove("visibleCountries");
        }

		partial void OnValidate(ChangeAction action)
		{
			if (action == ChangeAction.Update || action == ChangeAction.Insert) {
				if (ModelProgress < 0) ModelProgress = 0;
				if (ModelProgress > 100) ModelProgress = 100;

				if (TextureProgress < 0) TextureProgress = 0;
				if (TextureProgress > 100) TextureProgress = 100;

				if (ScriptProgress < 0) ScriptProgress = 0;
				if (ScriptProgress > 100) ScriptProgress = 100;


				OverallProgress = (int) (40*(ModelProgress/100.0) + 40*(TextureProgress/100.0) + 20*(ScriptProgress/100.0));
			}
		}

        /// <summary>
        /// Method is called before entity is persisted to the datastore.
        /// </summary>
        /// <param name="action">The action.</param>
        internal override void Committing(ChangeAction action)
        {
            DateTime auditDate = DateTime.Now;

            // If EntityState is New, then Set the Inserted audit information
            if (EntityState == EntityState.New)
            {
                this._InsertedDate = auditDate;
            }

            // Set the Update audit information
            if (EntityState != EntityState.Deleted)
            {
                this._UpdatedDate = auditDate;
                this._UpdatedByStaffId = Convert.ToInt32(BusinessUser.Current.UserKey);
            }
        }

        public IList<BusinessRuleViolation> GetBusinessRuleViolations(ChangeAction action)
        {
            var violations = new List<BusinessRuleViolation>();

            if (Login.IsNullOrEmpty())
                violations.Add(new BusinessRuleViolation("Login name is required.", "Login"));

            if ((action == ChangeAction.Insert) || (action == ChangeAction.Update))
            {
                if (Current.DB.Query<int>("select 1 from Users where Login = @Login and Id <> @Id", new { Login, Id }).Any())
                {
                    violations.Add(new BusinessRuleViolation("Login name must be unique.", "Login"));
                }
            }

            return violations;
        }