public static void ValidateApplicationUser(
            this UrfIdentityDataContext dbContext,
            DbEntityValidationResult result)
        {
            var entity = result.Entry.Entity as ApplicationUser;
            if (entity == null)
            {
                return;
            }

            ApplicationUser temp = dbContext
                .ApplicationUsers.FirstOrDefault(x => x.UserName == entity.UserName);

            if ((temp != null) && (temp.Id != entity.Id))
            {
                result.ValidationErrors.Add(
                    new DbValidationError(
                        // A {0} with the {1} of '{2}' is already registered ({3})
                        "UserName",
                        String.Format(
                            ModelValidationResources.NonUniqueField_NoReference,
                            AccountResources.User_Account,
                            AccountResources.UserName, entity.UserName)));
            }
        }
Ejemplo n.º 2
0
        protected override DbEntityValidationResult ValidateEntity(DbEntityEntry entityEntry,
                                                                   IDictionary<object, object> items)
        {
            if (entityEntry.State != EntityState.Added)
            {
                return base.ValidateEntity(entityEntry,
                                           items);
            }

            var user = entityEntry.Entity as User;
            // Check for uniqueness of user name
            if (user == null || !Users.Any(u => String.Equals(u.UserName,
                                                              user.UserName,
                                                              StringComparison.CurrentCultureIgnoreCase)))
            {
                return base.ValidateEntity(entityEntry,
                                           items);
            }

            var result = new DbEntityValidationResult(entityEntry,
                                                      new List<DbValidationError>());
            result.ValidationErrors.Add(new DbValidationError("User",
                                                              "User name must be unique."));
            return result;
        }
Ejemplo n.º 3
0
        protected override DbEntityValidationResult ValidateEntity(DbEntityEntry entityEntry, IDictionary<object, object> items)
        {
            var result = new DbEntityValidationResult(entityEntry, new List<DbValidationError>());

            if (entityEntry.Entity is Application && entityEntry.State == EntityState.Added)
            {
                Application app = entityEntry.Entity as Application;

                if (!app.IsValid)
                {
                    foreach (ValidationError ve in app.GetValidationErrors())
                    {
                        result.ValidationErrors.Add(new DbValidationError(ve.PropertyName, ve.ErrorMessage));
                    }
                }
            }

            if (result.ValidationErrors.Count > 0)
            {
                return result;
            }
            else
            {
                return base.ValidateEntity(entityEntry, items);
            }
        }
Ejemplo n.º 4
0
        protected override DbEntityValidationResult ValidateEntity(System.Data.Entity.Infrastructure.DbEntityEntry entityEntry, IDictionary<object, object> items)
        {
            var result = new DbEntityValidationResult(entityEntry, new List<DbValidationError>());

            if (entityEntry.Entity is Job && entityEntry.State == System.Data.EntityState.Added)
            {
                Job job = entityEntry.Entity as Job;

                if (Jobs.Where(x => x.name == job.name && x.curr_Revision==job.curr_Revision).Count() > 0)
                {
                    result.ValidationErrors.Add(new DbValidationError("name", "Job number and revision must be unique."));
                    Debug.WriteLine("Error thrown:  Jobs need to be unique");
                }
            }

            if (result.ValidationErrors.Count > 0)
            {
                return result;
            }
            else
            {
                Debug.WriteLine("No errors thrown here");
                return base.ValidateEntity(entityEntry, items);
            }
        }
        public static void WriteValiationResults(DbEntityValidationResult result)
        {
            Console.WriteLine("Type: {0}", result.Entry.Entity.GetType().Name);
            Console.WriteLine("Passed Validation: {0}",result.IsValid);

            foreach (DbValidationError dbValidationError in result.ValidationErrors)
            {
                Console.WriteLine("{0}: {1}", dbValidationError.PropertyName, dbValidationError.ErrorMessage);
            }
        }
		internal void AddErrorsToModelState(DbEntityValidationResult validation, ModelStateDictionary state)
		{
			if (validation == null || state == null || validation.IsValid)
			{
				return;
			}
			var errors = validation.ValidationErrors.Select(r => new { Property = r.PropertyName, ErrorMessage = r.ErrorMessage });
			foreach (var error in errors)
			{
				ModelState.AddModelError(error.Property, error.ErrorMessage);
			}
		}
        private static void AppendErrorMessages(DbEntityValidationResult dbEntityValidationResult, StringBuilder stringBuilder)
        {
            var entityName = dbEntityValidationResult.Entry.Entity.GetType().Name;

            foreach (var dbValidationError in dbEntityValidationResult.ValidationErrors)
            {
                var propertyName = dbValidationError.PropertyName;
                var validationError = dbValidationError.ErrorMessage;
                string error = String.Format("  Property {0} on entity {1} has validtion error : {2}", propertyName, entityName, validationError);

                stringBuilder.AppendLine(error);
            }
        }
Ejemplo n.º 8
0
 // This method ensures that user names are always unique
 protected override DbEntityValidationResult ValidateEntity(DbEntityEntry entityEntry, IDictionary<object, object> items)
 {
     if (entityEntry.State == EntityState.Added)
     {
         User user = entityEntry.Entity as User;
         // Check for uniqueness of user name
         if (user != null && Users.Where(u => u.UserName.ToUpper() == user.UserName.ToUpper()).Count() > 0)
         {
             var result = new DbEntityValidationResult(entityEntry, new List<DbValidationError>());
             result.ValidationErrors.Add(new DbValidationError("User", "User name must be unique."));
             return result;
         }
     }
     return base.ValidateEntity(entityEntry, items);
 }
        protected override DbEntityValidationResult ValidateEntity(
            System.Data.Entity.Infrastructure.DbEntityEntry entityEntry, IDictionary<object, object> items)
        {
            var result = new DbEntityValidationResult(entityEntry, new List<DbValidationError>());

            if (entityEntry.Entity is Employee && entityEntry.State == EntityState.Added)
            {
                Employee emp = entityEntry.Entity as Employee;
                //check for uniqueness of post title
                if (Employees.Where(e => e.Username == emp.Username).Count() > 0)
                    result.ValidationErrors.Add(
                            new System.Data.Entity.Validation.DbValidationError("Username",
                            "this username is not available")
                            );
            }
            if (result.ValidationErrors.Count() > 0)
            {
                return result;
            }
            else
            {
                return base.ValidateEntity(entityEntry, items);
            }
        }
Ejemplo n.º 10
0
        protected override DbEntityValidationResult ValidateEntity(System.Data.Entity.Infrastructure.DbEntityEntry entityEntry, IDictionary<object, object> items)
        {
            var result = new DbEntityValidationResult(entityEntry, new List<DbValidationError>());
            if (entityEntry.Entity is MachineInfo && entityEntry.State == EntityState.Modified)
            {
                MachineInfo machineInfo = (MachineInfo)entityEntry.Entity;
                //check for uniqueness of post title
                if (MachineInfos.Where(m => m.Id == machineInfo.Id).Count() > 0)
                {
                    result.ValidationErrors.Add(
                            new System.Data.Entity.Validation.DbValidationError("Title",
                            "Appapp id måste vara unikt."));
                }
            }

            if (entityEntry.Entity is Resident && entityEntry.State == EntityState.Modified)
            {
                var resident = (Resident)entityEntry.Entity;
                //check for uniqueness of post title
                if (Residents.Any(m => m.Email == resident.Email))
                {
                    result.ValidationErrors.Add(
                            new System.Data.Entity.Validation.DbValidationError("Fel",
                            "Appapp mailadressen måste vara unikt."));
                }
            }

            if (result.ValidationErrors.Count > 0)
            {
                return result;
            }
            else
            {
                return base.ValidateEntity(entityEntry, items);
            }
        }
Ejemplo n.º 11
0
        protected override DbEntityValidationResult ValidateEntity(DbEntityEntry entityEntry, System.Collections.Generic.IDictionary<object, object> items)
        {
            var result = new DbEntityValidationResult(entityEntry, new List<DbValidationError>());

            //Sender
            if (entityEntry.Entity is Application)
            {
                Application current = entityEntry.Entity as Application;

                if (current.Sender == "")
                {
                    result.ValidationErrors.Add(new DbValidationError("Sender", "Application missing Sender!!!"));
                }
            }

            if (entityEntry.Entity is Application)
            {
                Application current = entityEntry.Entity as Application;

                if (current.Sender.Length > 30)
                {
                    result.ValidationErrors.Add(new DbValidationError("Subject", "Sender cannot be longer than 30 characters!!!"));
                }
            }

            //subject
            if (entityEntry.Entity is Application)
            {
                Application current = entityEntry.Entity as Application;

                if (current.Subject == "")
                {
                    result.ValidationErrors.Add(new DbValidationError("Subject", "Application missing subject!!!"));
                }
            }

            if (entityEntry.Entity is Application)
            {
                Application current = entityEntry.Entity as Application;

                if (current.Subject.Length > 30)
                {
                    result.ValidationErrors.Add(new DbValidationError("Subject", "Subject cannot be longer than 50 characters!!!"));
                }
            }

            //RegNum
            if (entityEntry.Entity is Application)
            {
                Application current = entityEntry.Entity as Application;

                if (current.Subject.Length > 20)
                {
                    result.ValidationErrors.Add(new DbValidationError("ReigistrationNumber", "RegistrationNumber cannot be longer than 20 characters!!!"));
                }
            }

            if (entityEntry.Entity is Application)
            {
                Application current = entityEntry.Entity as Application;

                if (current.Sender == "")
                {
                    result.ValidationErrors.Add(new DbValidationError("Sender", "Application missing registration number!!!"));
                }
            }

            if (result.ValidationErrors.Count > 0)
            {
                return result;
            }
            else
            {
                return base.ValidateEntity(entityEntry, items);
            }
        }
Ejemplo n.º 12
0
 private void ValidateInventoryItem(DbEntityValidationResult result)
 {
     var inventoryItem = result.Entry.Entity as InventoryItem;
     if (!Inventories.Any(i => i.InventoryId == inventoryItem.InventoryId))
     {
         result.ValidationErrors.Add(new DbValidationError("InventoryId", "Inventory does not exist in the system"));
     }
     if (!Products.Any(p => p.ProductId == inventoryItem.ProductId))
     {
         result.ValidationErrors.Add(new DbValidationError("ProductId", "Product does not exist in the system"));
     }
 }
Ejemplo n.º 13
0
 private void ValidateInstitutionBase(DbEntityValidationResult result)
 {
     var entity = result.Entry.Entity as InstitutionBase;
     if ((String.IsNullOrWhiteSpace(entity.DeaLicense) && (result.Entry.Entity.GetType().BaseType == typeof(Manufacturer) || result.Entry.Entity.GetType().BaseType == typeof(Wholesaler)))
         || (result.Entry.Entity.GetType().BaseType == typeof(Client) && entity.EntityId == Domain.Constants.MasterPharmacyId)
         || (result.Entry.Entity.GetType().BaseType == typeof(Manufacturer) && entity.EntityId == Domain.Constants.CatchAllManufacturerId))
     {
         return;
     }
     if (Clients.Any(c => c.DeaLicense.Trim().Equals(entity.DeaLicense.Trim(), StringComparison.OrdinalIgnoreCase) && c.ClientId != entity.EntityId))
     {
         result.ValidationErrors.Add(new DbValidationError("DeaLicense", "DEA license already exist in the system (client)"));
     }
     if (Manufacturers.Any(m => m.DeaLicense.Trim().Equals(entity.DeaLicense.Trim(), StringComparison.OrdinalIgnoreCase) && m.ManufacturerId != entity.EntityId))
     {
         result.ValidationErrors.Add(new DbValidationError("DeaLicense", "DEA license already exist in the system (manufacturer)"));
     }
     if (Wholesalers.Any(w => w.DeaLicense.Trim().Equals(entity.DeaLicense.Trim(), StringComparison.OrdinalIgnoreCase) && w.WholesalerId != entity.EntityId))
     {
         result.ValidationErrors.Add(new DbValidationError("DeaLicense", "DEA license already exist in the system (wholesaler)"));
     }
 }
 public ValidationResult(DbEntityValidationResult result)
 {
     _result = result;
 }
Ejemplo n.º 15
0
 private void ValidateProductForm(DbEntityValidationResult result)
 {
     var productForm = result.Entry.Entity as ProductForm;
     if (ProductForms.Any(p => p.Name.Trim().Equals(productForm.Name.Trim(), StringComparison.OrdinalIgnoreCase) && p.ProductFormId != productForm.ProductFormId))
     {
         result.ValidationErrors.Add(new DbValidationError("Name", "Name already exist in the system"));
     }
 }
Ejemplo n.º 16
0
 /// <summary>
 /// 自定义验证:每一个目的地类Destination下不能有同名的住宿类Lodging
 /// </summary>
 /// <param name="result"></param>
 private void ValidateLodging(DbEntityValidationResult result)
 {
     var lodging = result.Entry.Entity as DbContexts.Model.Lodging;
     if (lodging != null && lodging.DestinationId != 0)
     {
         if (Lodgings.Any(l => l.Name == lodging.Name && l.DestinationId == lodging.DestinationId))
         {
             result.ValidationErrors.Add(new DbValidationError("Lodging", "There is already a lodging named " + lodging.Name + " at this destination."));
         }
     }
 }
Ejemplo n.º 17
0
 private void Validate(DbEntityValidationResult result)
 {
     ValidatePerson(result);
 }
Ejemplo n.º 18
0
 public DbEntityValidationResultBase(System.Data.Entity.Validation.DbEntityValidationResult dbEntityValidationResult)
 {
     _dbEntityValidationResult = dbEntityValidationResult;
 }
Ejemplo n.º 19
0
 private void ValidateClient(DbEntityValidationResult result)
 {
     var client = result.Entry.Entity as Client;
     if (Clients.Any(c => c.Name.Trim().Equals(client.Name.Trim(), StringComparison.OrdinalIgnoreCase) && c.ClientId != client.ClientId))
     {
         result.ValidationErrors.Add(new DbValidationError("Name", "Client name already exist in the system"));
     }
     if (Clients.Any(c => c.DeaLicense.Trim().Equals(client.DeaLicense.Trim(), StringComparison.OrdinalIgnoreCase) && c.ClientId != client.ClientId))
     {
         result.ValidationErrors.Add(new DbValidationError("DeaLicense", "DEA license already exist in the system"));
     }
     if (Clients.Any(c => c.StateLicense.Trim().Equals(client.StateLicense.Trim(), StringComparison.OrdinalIgnoreCase) && c.ClientId != client.ClientId))
     {
         result.ValidationErrors.Add(new DbValidationError("StateLicense", "State license already exist in the system"));
     }
     if (client.WholesalerAccountId.HasValue && !Wholesalers.Any(w => w.WholesalerId == client.WholesalerAccountId))
     {
         result.ValidationErrors.Add(new DbValidationError("WholesalerAccountId", "Wholesaler does not exist in the system"));
     }
 }
Ejemplo n.º 20
0
 private void ValidateUserAccount(DbEntityValidationResult result)
 {
     var userAccount = result.Entry.Entity as UserAccount;
     //if (!Enum.IsDefined(typeof(AccessLevel), userAccount.AccessLevel))
     //{
     //    result.ValidationErrors.Add(new DbValidationError("AccessLevel", "Invalid access level"));
     //}
     if (!Clients.Any(c => c.ClientId == userAccount.ClientId))
     {
         result.ValidationErrors.Add(new DbValidationError("ClientId", "Invalid associated client"));
     }
     if (UserAccounts.Any(ua => ua.EmailAddress.Trim().Equals(userAccount.EmailAddress.Trim(), StringComparison.OrdinalIgnoreCase) && ua.UserAccountId != userAccount.UserAccountId))
     {
         result.ValidationErrors.Add(new DbValidationError("EmailAddress", "Email address already exist in the system"));
     }
     if (UserAccounts.Any(ua => ua.UserName.Trim().Equals(userAccount.UserName.Trim(), StringComparison.OrdinalIgnoreCase) && ua.UserAccountId != userAccount.UserAccountId))
     {
         result.ValidationErrors.Add(new DbValidationError("UserName", "Username already exist in the system"));
     }
 }
 internal static string GetErrorMessage(DbEntityValidationResult validationResult)
 {
     return GetErrorMessage(validationResult.ValidationErrors);
 }
Ejemplo n.º 22
0
 private void ValidateManufacturer(DbEntityValidationResult result)
 {
     var manufacturer = result.Entry.Entity as Manufacturer;
     if (Manufacturers.Any(m => m.Name.Trim().Equals(manufacturer.Name.Trim(), StringComparison.OrdinalIgnoreCase) && m.ManufacturerId != manufacturer.ManufacturerId))
     {
         result.ValidationErrors.Add(new DbValidationError("Name", "Manufacturer name already exist in the system"));
     }
     if (!String.IsNullOrWhiteSpace(manufacturer.DeaLicense) && Manufacturers.Any(m => m.DeaLicense.Trim().Equals(manufacturer.DeaLicense.Trim(), StringComparison.OrdinalIgnoreCase) && m.ManufacturerId != manufacturer.ManufacturerId))
     {
         result.ValidationErrors.Add(new DbValidationError("DeaLicense", "DEA license already exist in the system"));
     }
     if (Manufacturers.Any(m => m.NdcPrefix.Trim().Equals(manufacturer.NdcPrefix.Trim(), StringComparison.OrdinalIgnoreCase) && m.ManufacturerId != manufacturer.ManufacturerId))
     {
         result.ValidationErrors.Add(new DbValidationError("NdcPrefix", "NDC prefix already exist in the system"));
     }
     if (manufacturer.ReturnToManufacturerId.HasValue && !Manufacturers.Any(m => m.ManufacturerId == manufacturer.ReturnToManufacturerId))
     {
         result.ValidationErrors.Add(new DbValidationError("ReturnToManufacturerId", "Return to manufacturer does not exist in the system"));
     }
 }
Ejemplo n.º 23
0
 private void ValidateManufacturerPolicy(DbEntityValidationResult result)
 {
     var manufacturerPolicy = result.Entry.Entity as ManufacturerPolicy;
     if (!Manufacturers.Any(m => m.ManufacturerId == manufacturerPolicy.ManufacturerId))
     {
         result.ValidationErrors.Add(new DbValidationError("ManufacturerId", "Manufacturer does not exist in the system"));
     }
 }
		public void OnValidateEntity(DbEntityValidationResult result, DbEntityEntry entityEntry, IDictionary<object, object> items)
		{
			Entries.Add(entityEntry);
		}
Ejemplo n.º 25
0
 private void ValidateWholesaler(DbEntityValidationResult result)
 {
     var wholesaler = result.Entry.Entity as Wholesaler;
     if (Wholesalers.Any(w => w.Name.Trim().Equals(wholesaler.Name.Trim(), StringComparison.OrdinalIgnoreCase) && w.WholesalerId != wholesaler.WholesalerId))
     {
         result.ValidationErrors.Add(new DbValidationError("Name", "Wholesaler name already exist in the system"));
     }
     if (!String.IsNullOrWhiteSpace(wholesaler.DeaLicense) && Wholesalers.Any(w => w.DeaLicense.Trim().Equals(wholesaler.DeaLicense.Trim(), StringComparison.OrdinalIgnoreCase) && w.WholesalerId != wholesaler.WholesalerId))
     {
         result.ValidationErrors.Add(new DbValidationError("DeaLicense", "DEA license already exist in the system"));
     }
 }
Ejemplo n.º 26
0
 protected override DbEntityValidationResult ValidateEntity(DbEntityEntry entityEntry, IDictionary<object, object> items)
 {
     var result = new DbEntityValidationResult(entityEntry, new List<DbValidationError>());
     Validate(result);
     if (!result.IsValid)
     {
         return result;
     }
     return base.ValidateEntity(entityEntry, items);
 }
Ejemplo n.º 27
0
 private void ValidateInventory(DbEntityValidationResult result)
 {
     var inventory = result.Entry.Entity as Inventory;
     if (inventory.Status != InventoryStatus.Inventory && String.IsNullOrWhiteSpace(inventory.DebitNumber))
     {
         result.ValidationErrors.Add(new DbValidationError("DebitNumber", "Return must have debit number"));
     }
     if (!String.IsNullOrWhiteSpace(inventory.DebitNumber) && Inventories.Any(i => i.DebitNumber.Trim() == inventory.DebitNumber.Trim() && i.InventoryId != inventory.InventoryId))
     {
         result.ValidationErrors.Add(new DbValidationError("DebitNumber", "Debit number already exist in the system"));
     }
 }
Ejemplo n.º 28
0
 private void ValidatePerson(DbEntityValidationResult result)
 {
     Person po = null;
     po = result.Entry.Entity as Person;
     if (po != null)
     {
         if (result.Entry.State == EntityState.Added && po.Age < 18)
         {
             result.ValidationErrors.Add(new DbValidationError("Person", "La edad no puede ser menor a 18"));
         }
     }
 }
Ejemplo n.º 29
0
 /// <summary>
 /// 多个验证规则
 /// </summary>
 private void ValidateReservation(DbEntityValidationResult result)
 {
     var reservation = result.Entry.Entity as DbContexts.Model.Reservation;
     if (reservation != null)
     {
         if (result.Entry.State == EntityState.Added && reservation.Payments.Count == 0)
         {
             result.ValidationErrors.Add(new DbValidationError("Reservation", "New reservation must have a payment."));
         }
     }
 }
		static string DetermineKey( DbContext context, DbEntityValidationResult validationResult )
		{
			var key = context.AsTo<IObjectContextAdapter, ObjectContext>( y => y.ObjectContext ).ExtractKey( validationResult.Entry.Entity );
			var result = string.Join( ", ", key.EntityKeyValues.Select( x => x.ToString() ) );
			return result;
		}
Ejemplo n.º 31
0
 private void ValidateProduct(DbEntityValidationResult result)
 {
     var product = result.Entry.Entity as Product;
     if (!product.IsProductIdValid())
     {
         result.ValidationErrors.Add(new DbValidationError("ProductId", "ProductId does not match FullProductId"));
     }
     // should we use result.Entry.State == EntityState.Added ?
     if (Products.Count(p => p.ProductId == product.ProductId) > 1)
     {
         result.ValidationErrors.Add(new DbValidationError("ProductId", "Product already exist in the system"));
     }
 }