RadDataForm field validation via DataAnnotation fields

2 posts, 0 answers
  1. Peter
    Peter avatar
    13 posts
    Member since:
    May 2012

    Posted 30 May 2012 Link to this post

    Hi,

    My WPF application uses an SQlite database which exposes is functionality by an OpenAccess ORM Domain Model, and is then wrapped in an MVVM schema. One of the tables in the database is called ValidUsers, I have created a Metadata class called ValidUsersMetadata as per the guidance in the OpenAccess documentation and is shown below:

    using System;
    using System.Linq;
    using System.ComponentModel;
    using System.ComponentModel.DataAnnotations;
     
    namespace VisorDataModel
    {
        [MetadataTypeAttribute(typeof(ValidUser.ValidUserMetadata))]
        public partial class ValidUser : IEditableObject
        {
     
            internal sealed class ValidUserMetadata
            {
     
                public ValidUserMetadata()
                {
                }
     
                [Required(ErrorMessage = "User ID is required")]
                public int UserID
                {
                    get;
                    set;
                }
     
               [Required(ErrorMessage = "User Name is required.")]
               [StringLength(6,ErrorMessage="User name must be at least 6 characters")]
               public string UserName
                {
                    get;
                    set;
                }
     
               [Required(ErrorMessage = "Password is required.")]
               [StringLength(6, ErrorMessage = "Password must be at least 6 characters")]
               public string UserPassword
                {
                    get;
                    set;
                }
     
               [Required(ErrorMessage = "User Class is required.")]
               public int UserClass
                {
                    get;
                    set;
                }
     
            }
        }
    }

    The base ValidUser definition is in the class VisorDataModel which is generated by the OpenAccess Domain Model wizard.

    The rest of the MVVM definitions for ValidUsers are shown below:
    using System;
    using System.Collections.Generic;
    using System.Linq;
     
    namespace VisorDataModel
    {
        public interface IValidUsersModel
        {
            IEnumerable<ValidUser> LoadValidUsers();
            IEnumerable<UserClass> LoadUserClasses();
            ValidUser NewValidUser();
            void AddValidUser(ValidUser validUser);
            void DeleteValidUser(ValidUser validUser);
            void SaveChanges();
        }
    }
    using System;
    using System.Collections.Generic;
    using System.Linq;
     
    namespace VisorDataModel
    {
     
        /// <summary>
        /// Represents a source of ValidUsers
        /// </summary>
        public class ValidUsersModel : IValidUsersModel
        {
            private EntitiesModel dbContext = new EntitiesModel();
     
            public IEnumerable<ValidUser> LoadValidUsers()
            {
                return dbContext.ValidUsers.ToList();
            }
     
            public IEnumerable<UserClass> LoadUserClasses()
            {
                return dbContext.UserClasses.ToList();
            }
     
            public ValidUser NewValidUser()
            {
                ValidUser newValidUser = new ValidUser { UserName = "New User", UserPassword = "New Password", UserClass = 0 };
     
                int newUserId = 0;
                try
                {
                    newUserId = (from vu in dbContext.ValidUsers
                                 select (vu.UserID)).Max() +1;
                }
                catch
                {
                    newUserId = 0;
                }
                newValidUser.UserID = newUserId;
                return newValidUser;
           }
            public void AddValidUser(ValidUser validUser)
            {
                dbContext.Add(validUser);
                dbContext.SaveChanges();
            }
     
            public void DeleteValidUser(ValidUser validUser)
            {
                dbContext.Delete(validUser);
                dbContext.SaveChanges();
            }
     
            public void SaveChanges()
            {
                dbContext.SaveChanges();
            }
        }
    }
    using System;
    using System.Linq;
    using System.Collections.ObjectModel;
    using System.ComponentModel;
     
    namespace VisorDataModel
    {
        public class ValidUsersViewModel : INotifyPropertyChanged
        {
     
            private readonly IValidUsersModel dataModel;
            private ValidUser _selectedValidUser;
            private DelegateCommand _addValidUserCommand;
            private DelegateCommand _deleteValidUserCommand;
            private DelegateCommand _saveChangesCommand;
            private ObservableCollection<ValidUser> _validUsers;
            private ObservableCollection<UserClass> _userClasses;
            public event PropertyChangedEventHandler PropertyChanged;
            private ObservableCollection<ValidUser> _originalValidUsers;
     
            #region initialisation
            public ValidUsersViewModel()
            {
                this.dataModel = new ValidUsersModel();
            }
            #endregion
     
            public ObservableCollection<ValidUser> ValidUsers
            {
                get
                {
                    if (this._validUsers == null)
                    {
                        this._validUsers = new ObservableCollection<ValidUser>();
     
                        if (this._originalValidUsers == null)
                        {
                            this._originalValidUsers = this._validUsers;
                        }
     
                        LoadValidUsers();
                    }
     
                    return this._validUsers;
                }
            }
     
            public ObservableCollection<UserClass> UserClasses
            {
                get
                {
                    if (this._userClasses == null)
                    {
                        this._userClasses = new ObservableCollection<UserClass>();
                        LoadUserClasses();
                    }
                    return this._userClasses;
                }
            }
     
            #region SelectValidUser property
            public ValidUser SelectedValidUser
            {
                get
                {
                    return _selectedValidUser;
                }
                set
                {
                    if (this._selectedValidUser == value)
                        return;
                    this._selectedValidUser = value;
                    this.OnPropertyChanged("SelectedValidUser");
                }
            }
            #endregion
     
            public DelegateCommand AddValidUserCommand
            {
                get
                {
                    if (this._addValidUserCommand == null)
                        this._addValidUserCommand = new DelegateCommand(this.OnAddCommandExecute);
                    return _addValidUserCommand;
                }
            }
     
            public DelegateCommand DeleteValidUserCommand
            {
                get
                {
                    if (this._deleteValidUserCommand == null)
                        this._deleteValidUserCommand = new DelegateCommand(this.OnDeleteCommandExecute);
                    return _deleteValidUserCommand;
                }
            }
     
            public DelegateCommand SaveChangesCommand
            {
                get
                {
                    if (this._saveChangesCommand == null)
                        this._saveChangesCommand = new DelegateCommand(this.OnSaveCommandExecute);
                    return _saveChangesCommand;
                }
            }
     
            private void LoadValidUsers()
            {
                this._validUsers.Clear();
                foreach (var item in this.dataModel.LoadValidUsers())
                {
                    this._validUsers.Add(item);
                }
            }
     
            private void LoadUserClasses()
            {
                this._userClasses.Clear();
                foreach (var item in this.dataModel.LoadUserClasses())
                {
                    this._userClasses.Add(item);
                }
            }
     
            private void OnAddCommandExecute(object parameter)
            {
                ValidUser newValidUser = this.dataModel.NewValidUser();
                this.ValidUsers.Add(newValidUser);
                this.SelectedValidUser = newValidUser;
                this.dataModel.AddValidUser(newValidUser);
            }
     
            private void OnDeleteCommandExecute(object parameter)
            {
                if (this.SelectedValidUser != null)
                {
                    this.dataModel.DeleteValidUser(this.SelectedValidUser);
                    this.ValidUsers.Remove(this.SelectedValidUser);
                }
            }
     
            private void OnSaveCommandExecute(object parameter)
            {
                this.dataModel.SaveChanges();
            }
     
            protected virtual void OnPropertyChanged(string info)
            {
                if (this.PropertyChanged != null)
                    this.PropertyChanged(this, new PropertyChangedEventArgs(info));
            }
        }
    }



    One of the functions of the application is to display/add/delete/edit ValidUser records. This is accomplished by a RadDataGrid and a pop-up RadDataForm. The RadDataForm uses custom fields, one of which is defined as a DataFormComboBoxField.

    All of this works fine but I now want to use the DataAnnotations which I have added in the ValidUserMetadata class. So far I have not found how to do this.

    Any help gratefully received.

    Thanks
  2. Ivan Ivanov
    Admin
    Ivan Ivanov avatar
    1127 posts

    Posted 04 Jun 2012 Link to this post

    Hello,

    Would you please share with us which version of RadControls you are currently using, as the item-level validation feature was introduced with Q3 2011? Would it be possible for you to send us a simple demo project that illustrates your scenario through a support ticket? Support tickets, not only allow clients to attach files, but have high priority 24h response time.

    All the best,
    Ivan Ivanov
    the Telerik team
    Explore the entire Telerik portfolio by downloading the Ultimate Collection trial package. Get it now >>
  3. UI for WPF is Visual Studio 2017 Ready
Back to Top