Beispiel #1
0
        protected override void Seed(WebAppDbContext context)
        {
            var userStore   = new UserStore <User>(context);
            var userManager = new UserManager <User>(userStore);

            // Create Roles
            context.Roles.AddOrUpdate(r => r.Name, new IdentityRole {
                Name = "Admin"
            });
            context.Roles.AddOrUpdate(r => r.Name, new IdentityRole {
                Name = "Student"
            });
            context.SaveChanges();

            #region Default Users

            var users = new List <RegisterViewModel> {
                new RegisterViewModel {
                    FirstName   = "Joshua",
                    LastName    = "Azemoh",
                    Sex         = "Male",
                    Password    = "******",
                    Email       = "*****@*****.**",
                    AccountType = "Admin"
                },
                new RegisterViewModel {
                    FirstName   = "Samuel",
                    LastName    = "Ajayi",
                    Sex         = "Male",
                    Password    = "******",
                    Email       = "*****@*****.**",
                    AccountType = "Student"
                },
                new RegisterViewModel {
                    FirstName   = "Angela",
                    LastName    = "Olawale",
                    Sex         = "Female",
                    Password    = "******",
                    Email       = "*****@*****.**",
                    AccountType = "Student"
                },
                new RegisterViewModel {
                    FirstName   = "Felix",
                    LastName    = "Nosa",
                    Sex         = "Male",
                    Password    = "******",
                    Email       = "*****@*****.**",
                    AccountType = "Student"
                },
                new RegisterViewModel {
                    FirstName   = "Grace",
                    LastName    = "Okoro",
                    Sex         = "Female",
                    Password    = "******",
                    Email       = "*****@*****.**",
                    AccountType = "Student"
                }
            };

            foreach (RegisterViewModel model in users)
            {
                if (!context.Users.Any(u => u.UserName == model.Email))
                {
                    var user = new User {
                        FirstName   = model.FirstName,
                        LastName    = model.LastName,
                        Sex         = model.Sex,
                        Email       = model.Email,
                        UserName    = model.Email,
                        AccountType = model.AccountType
                    };
                    IdentityResult result = userManager.Create(user, model.Password);
                    if (result.Succeeded)
                    {
                        userManager.AddClaim(user.Id, new Claim(ClaimTypes.GivenName, model.FirstName));
                        userManager.AddToRole(user.Id, user.AccountType);
                        if (user.AccountType == "Student")
                        {
                            var service = new StudentService(context);
                            // Add Student
                            service.AddStudent(user.Id);
                        }
                    }
                }
            }

            context.SaveChanges();

            #endregion Default Users

            #region Default_Tests

            var test = new List <Test> {
                new Test {
                    Title     = "CSS",
                    Questions = new List <TestQuestion> {
                        new TestQuestion {
                            Code     = "",
                            Question = "Are CSS property names case-sensitive?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "Yes", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "No", IsCorrect = true
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "",
                            Question = "Does setting margin-top and margin-bottom have an affect on an inline element?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "Yes", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "No", IsCorrect = true
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "",
                            Question = "Does setting padding-top and padding-bottom on an inline element add to its dimensions?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "Yes", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "No", IsCorrect = true
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "",
                            Question = "The pseudo class :checked will select inputs with type radio or checkbox, but not option elements.",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "True", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "False", IsCorrect = true
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "",
                            Question = "In a HTML document, the pseudo class :root always refers to the <html> element.",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "True", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "False", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "<p id=\"example\">Hello</p>\n<style>#example { margin-bottom: -5px; }</style>",
                            Question = "What will happen to the position of #example?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "It will move 5px downwards", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "Elements succeeding #example with move 5px upwards", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "Neither", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "<p id=\"example\">Hello</p>\n<style>#example { margin-left: -5px; }</style>",
                            Question = "What will happen to the position of #example?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "It will move 5px left", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "All elements preceding #example with move 5px to the right", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "Neither", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "<ul class=\"shopping-list\" id=\"awesome\">\n<li><span>Milk</span></li>\n<li class=\"favorite\" id=\"must-buy\"><span class=\"highlight\">Sausage</span></li>\n</ul>\n<style>\nul { color: red; }\nli { color: blue; }\n</style>",
                            Question = "What is the color of the text Sausage ?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "Red", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "Blue", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "Neither", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "<ul class=\"shopping-list\" id=\"awesome\">\n<li><span>Milk</span></li>\n<li class=\"favorite\" id=\"must-buy\"><span class=\"highlight\">Sausage</span></li>\n</ul>\n<style>\n.shopping-list .favorite { color: red; }\n#must-buy { color: blue; }\n</style>",
                            Question = "What is the color of the text Sausage ?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "Red", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "Blue", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "Neither", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "@media only screen and (max-width: 1024px)",
                            Question = "Does the screen keyword apply to the device's physical screen or the browser's viewport?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "Device's physical screen", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "Browser's viewport", IsCorrect = true
                                }
                            }
                        }
                    }
                },

                new Test {
                    Title     = "HTML",
                    Questions = new List <TestQuestion> {
                        new TestQuestion {
                            Code     = "",
                            Question = "Is keygen a valid HTML5 element?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "Yes", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "No", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "",
                            Question = "bdo tag change the direction of text",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "false", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "True", IsCorrect = true
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "<figure>\n<img src=\"myimage.jpg\" alt=\"My image\">\n<figcaption>This is my self portrait.</figcaption>\n</figure>",
                            Question = "Is the above HTML valid?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "Yes", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "No", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "",
                            Question = "If a web page contains organic, multiple h1 tags, will it affect the SEO negativley?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "Yes", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "No", IsCorrect = true
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "",
                            Question = "If you have a page of search results and want to highlight the search term, what HTML tag would you use?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "strong", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "mark", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "em", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "highlight", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "",
                            Question = "Does HTML5 support block-level links?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "Yes", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "No", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "<img src=\"mypic.jpg\" style=\"visibility: hidden\" alt=\"My picture\">",
                            Question = "Does the HTML above trigger a http request when the page first loads ?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "Yes", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "No", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "<link href=\"style.css\" rel=\"stylesheet\">\n<script> alert(\"Hello World\"); </script>",
                            Question = "Does style.css have to be downloaded and parsed before Hello World is alerted?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "Yes", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "No", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "<link href=\"style1.css\" rel=\"stylesheet\">\n<link href=\"style2.css\" rel=\"stylesheet\">",
                            Question = "Does style1.css have to be downloaded and parsed before style2.css can be fetched? ",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "Yes", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "No", IsCorrect = true
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "",
                            Question = "Which tag is not supported in HTML5?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "map", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "frameset", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "area", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "embed", IsCorrect = false
                                }
                            }
                        }
                    }
                },

                new Test {
                    Title     = "JavaScript",
                    Questions = new List <TestQuestion> {
                        new TestQuestion {
                            Code     = "\"1\" + 2 + \"3\" + 4",
                            Question = "What does the above statement evaluate to?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "10", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "1234", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "37", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "4 + 3 + 2 + \"1\"",
                            Question = "What does the above statement evaluate to?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "10", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "4321", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "91", IsCorrect = true
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "\"1\" + 2 + \"3\" + 4",
                            Question = "What does the above statement evaluate to?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "10", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "1234", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "37", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "var foo = 1;\nfunction bar() {\n   foo = 10;\n    return;\n    function foo() {}\n}\nbar();\nalert(foo);",
                            Question = "What is alerted?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "1", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "10", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "undefined", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "Error", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "function bar() {\nreturn foo;\nfoo = 10;\nfunction foo() {}\nvar foo = 11;\n}\nalert(typeof bar());",
                            Question = "What is alerted?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "number", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "function", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "undefined", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "Error", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "x = 1;\nfunction bar() {\nthis.x = 2;\nreturn x;\n}\nvar foo = new bar();\nalert(foo.x);",
                            Question = "What value is alerted?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "1", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "2", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "undefined", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "function foo(a) {\nalert(arguments.length);\n}\nfoo(1, 2, 3);",
                            Question = "What value is alerted?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "1", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "2", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "3", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "4", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "var foo = function bar() {};\nalert(typeof bar);",
                            Question = "What value is alerted?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "function", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "object", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "undefined", IsCorrect = true
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "var arr = [];\narr[0]  = 'a';\narr[1]  = 'b';\narr.foo = 'c';\nalert(arr.length);",
                            Question = "What value is alerted?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "1", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "2", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "3", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "undefined", IsCorrect = false
                                }
                            }
                        },
                        new TestQuestion {
                            Code     = "function foo(){};\ndelete foo.length;\nalert(typeof foo.length);",
                            Question = "What value is alerted?",
                            Options  = new List <TestOption> {
                                new TestOption {
                                    Option = "number", IsCorrect = true
                                },
                                new TestOption {
                                    Option = "undefined", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "object", IsCorrect = false
                                },
                                new TestOption {
                                    Option = "Error", IsCorrect = false
                                }
                            }
                        }
                    }
                }
            };

            #endregion Default_Tests

            test.ForEach(t => context.Tests.AddOrUpdate(i => i.Title, t));
            context.SaveChanges();

            var testScores = new List <TestScore> {
                new TestScore {
                    StudentId = 1, TestId = 2, Score = 80
                },
                new TestScore {
                    StudentId = 2, TestId = 1, Score = 90
                },
                new TestScore {
                    StudentId = 1, TestId = 3, Score = 70
                },
                new TestScore {
                    StudentId = 3, TestId = 2, Score = 80
                },
                new TestScore {
                    StudentId = 3, TestId = 1, Score = 70
                },
            };

            testScores.ForEach(t => context.TestScores.Add(t));
            context.SaveChanges();
        }
Beispiel #2
0
        protected void UpdateClaims_Click(object sender, EventArgs e)
        {
            Button btn = sender as Button;

            var userStore = new UserStore <IdentityUser>();
            var manager   = new UserManager <IdentityUser>(userStore);

            var updateUser = manager.FindById(btn.CommandArgument);

            var claims = manager.GetClaims(updateUser.Id);

            if (manager.IsInRole(updateUser.Id, "Pillar"))
            {
                foreach (var claim in claims)
                {
                    manager.RemoveClaim(updateUser.Id, claim);
                }

                var selectedClaims = Pillar_List.Items
                                     .Cast <ListItem>()
                                     .Where(n => n.Selected)
                                     .ToList();

                if (selectedClaims.Count == 0)
                {
                    ScriptManager.RegisterStartupScript(Page, Page.GetType(), "infoModal", "$('#infoModal').modal();", true);
                }
                else
                {
                    foreach (var selectedClaim in selectedClaims)
                    {
                        manager.AddClaim(updateUser.Id, new Claim("Pillar", selectedClaim.Value));
                    }
                }
            }
            else if (manager.IsInRole(updateUser.Id, "Partner"))
            {
                foreach (var claim in claims)
                {
                    manager.RemoveClaim(updateUser.Id, claim);
                }

                var selectedClaims = Implementing_Partner_List.Items
                                     .Cast <ListItem>()
                                     .Where(n => n.Selected)
                                     .ToList();

                if (selectedClaims.Count == 0)
                {
                    ScriptManager.RegisterStartupScript(Page, Page.GetType(), "infoModal", "$('#infoModal').modal();", true);
                }
                else
                {
                    foreach (var selectedClaim in selectedClaims)
                    {
                        manager.AddClaim(updateUser.Id, new Claim("Project", selectedClaim.Value));
                        //To update the User (Not Needed though)
                        //manager.Update(updateUser);
                    }
                }
            }
            ScriptManager.RegisterStartupScript(Page, Page.GetType(), "updateClaimsModal", "$('#updateClaimsModal').modal('hide');", true);
        }
        protected override void Seed(IdentityClaim.Models.ApplicationDbContext context)
        {
            #region User

            if (context.Users.Count() == 0)
            {
                var roleStore   = new RoleStore <IdentityRole>(context);
                var roleManager = new RoleManager <IdentityRole>(roleStore);
                var userStore   = new UserStore <ApplicationUser>(context);
                var userManager = new UserManager <ApplicationUser>(userStore);

                string[] roles = { "SupperAdmin", "Admin", "Manager", "User", "Editor" };
                foreach (var item in roles)
                {
                    var role = roleManager.FindByName(item);
                    if (role == null)
                    {
                        role = new IdentityRole(item);
                        roleManager.Create(role);
                    }
                }


                //AdminUser
                ApplicationUser newuser = new ApplicationUser
                {
                    EmailConfirmed       = true,
                    UserName             = "******",
                    Email                = "*****@*****.**",
                    PhoneNumberConfirmed = true,
                    TwoFactorEnabled     = false,
                    AccessFailedCount    = 0,
                    SecurityStamp        = Guid.NewGuid().ToString("D")
                };
                userManager.Create(newuser, "P@ssw0rd");
                userManager.SetLockoutEnabled(newuser.Id, false);
                userManager.AddToRole(newuser.Id, "SupperAdmin");

                //Set Default Permissions For Admin User

                userManager.AddClaim(newuser.Id, new Claim("Permission", "Home.Index"));
                userManager.AddClaim(newuser.Id, new Claim("Permission", "Home.Permissions"));

                //Add Clients
                for (int i = 1; i <= 5; i++)
                {
                    ApplicationUser client = new ApplicationUser
                    {
                        EmailConfirmed       = true,
                        UserName             = "******" + i + "@yourdomain.com",
                        Email                = "User" + i + "@yourdomain.com",
                        PhoneNumberConfirmed = true,
                        TwoFactorEnabled     = false,
                        AccessFailedCount    = 0,
                        SecurityStamp        = Guid.NewGuid().ToString("D")
                    };
                    userManager.Create(client, "P@ssw0rd");
                    userManager.SetLockoutEnabled(client.Id, false);
                    userManager.AddToRole(client.Id, "User");

                    //Set Default Permissions For Clients
                    userManager.AddClaim(client.Id, new Claim("Permission", "Home.Index"));
                }
            }
            #endregion
        }
Beispiel #4
0
        public static void InitializeMySqlDatabase()
        {
            // Ajout du compte superviseur et creation de la base si pas exister
            using (var context = new ApplicationDbContext())
            {
                var userStore    = new UserStore <ApplicationUser>(context);
                var userManager  = new UserManager <ApplicationUser>(userStore);
                var userToInsert = new ApplicationUser {
                    UserName = "******", Email = "*****@*****.**", PhoneNumber = "0797697898"
                };
                var exist = userManager.FindByEmail("*****@*****.**");
                if (exist == null)
                {
                    userManager.Create(userToInsert, "pti.preu");

                    // ADD ROLE SUPERVISOR TO USER
                    var RoleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(context));
                    if (!RoleManager.RoleExists("Supervisor"))
                    {
                        IdentityRole   newRole = new IdentityRole("Supervisor");
                        IdentityResult result  = RoleManager.CreateAsync(newRole).Result;
                    }

                    userManager.AddToRoleAsync(userToInsert.Id, "Supervisor");
                }
            }

            // passage du fichier de migration
            Space spaceSupervision = new Space();

            using (var db = new MySqlIdentityDbContext())
            {
                string filPath       = AppDomain.CurrentDomain.BaseDirectory + "/Migration/initializeQuery.sql";
                string creationQuery = File.ReadAllText(filPath);
                db.Database.ExecuteSqlCommand(creationQuery);

                // Create Supervision space
                if (db.Spaces.Where(a => a.Name == "Root").FirstOrDefault() == null)
                {
                    spaceSupervision.Name = "Root";
                    db.Spaces.Add(spaceSupervision);
                    db.SaveChanges();
                }
            }

            // Ajout de l'espace au compte superviseur
            using (var context2 = new ApplicationDbContext())
            {
                var userStore   = new UserStore <ApplicationUser>(context2);
                var userManager = new UserManager <ApplicationUser>(userStore);

                var exist = userManager.FindByEmail("*****@*****.**");
                if (exist != null)
                {
                    var claims = userManager.GetClaims(exist.Id);
                    var claim  = claims.Where(a => a.Type == "SpaceId").FirstOrDefault();
                    if (claim == null)
                    {
                        userManager.AddClaim(exist.Id, new Claim("SpaceId", spaceSupervision.Id));
                    }
                }
            }
        }
 public void ClaimsIdentitySyncTest()
 {
     var db = UnitTestHelper.CreateDefaultDb();
     var manager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(db));
     var role = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(db));
     var user = new IdentityUser("Hao");
     var claimsFactory = manager.ClaimsIdentityFactory as ClaimsIdentityFactory<IdentityUser, string>;
     Assert.NotNull(claimsFactory);
     UnitTestHelper.IsSuccess(manager.Create(user));
     UnitTestHelper.IsSuccess(role.Create(new IdentityRole("Admin")));
     UnitTestHelper.IsSuccess(role.Create(new IdentityRole("Local")));
     UnitTestHelper.IsSuccess(manager.AddToRole(user.Id, "Admin"));
     UnitTestHelper.IsSuccess(manager.AddToRole(user.Id, "Local"));
     Claim[] userClaims =
     {
         new Claim("Whatever", "Value"),
         new Claim("Whatever2", "Value2")
     };
     foreach (var c in userClaims)
     {
         UnitTestHelper.IsSuccess(manager.AddClaim(user.Id, c));
     }
     var identity = manager.CreateIdentity(user, "test");
     var claims = identity.Claims;
     Assert.NotNull(claims);
     Assert.NotNull(claims);
     Assert.True(
         claims.Any(c => c.Type == claimsFactory.UserNameClaimType && c.Value == user.UserName));
     Assert.True(claims.Any(c => c.Type == claimsFactory.UserIdClaimType && c.Value == user.Id));
     Assert.True(claims.Any(c => c.Type == claimsFactory.RoleClaimType && c.Value == "Admin"));
     Assert.True(claims.Any(c => c.Type == claimsFactory.RoleClaimType && c.Value == "Local"));
     Assert.True(
         claims.Any(
             c =>
                 c.Type == ClaimsIdentityFactory<IdentityUser>.IdentityProviderClaimType &&
                 c.Value == ClaimsIdentityFactory<IdentityUser>.DefaultIdentityProviderClaimValue));
     foreach (var cl in userClaims)
     {
         Assert.True(claims.Any(c => c.Type == cl.Type && c.Value == cl.Value));
     }
 }
        protected override void Seed(ApplicationDbContext context)
        {
            //Seed identity tables here
            var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));
            var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new ApplicationDbContext()));


            roleManager.Create(new IdentityRole {
                Id = "Admin", Name = "Admin"
            });
            roleManager.Create(new IdentityRole {
                Id = "AllSalesRegions", Name = "All Sales Regions"
            });
            roleManager.Create(new IdentityRole {
                Id = "EasternSalesRegion", Name = "Eastern Sales Region"
            });
            roleManager.Create(new IdentityRole {
                Id = "CentralSalesRegion", Name = "Central Sales Region"
            });
            roleManager.Create(new IdentityRole {
                Id = "WesternSalesRegion", Name = "Western Sales Region"
            });

            userManager.Create(new ApplicationUser {
                Email = "*****@*****.**", UserName = "******", DisplayName = "Jason Borne"
            }, "Password1");
            userManager.AddToRole(userManager.FindByEmail("*****@*****.**").Id, "Admin");
            userManager.AddToRole(userManager.FindByEmail("*****@*****.**").Id, "All Sales Regions");

            userManager.Create(new ApplicationUser {
                Email = "*****@*****.**", UserName = "******", DisplayName = "James Bond"
            }, "Password1");
            userManager.AddToRole(userManager.FindByEmail("*****@*****.**").Id, "Eastern Sales Region");
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "MA"));
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "CT"));
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "NY"));
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "NJ"));
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "PA"));

            userManager.Create(new ApplicationUser {
                Email = "*****@*****.**", UserName = "******", DisplayName = "Maxwell Smart"
            }, "Password1");
            userManager.AddToRole(userManager.FindByEmail("*****@*****.**").Id, "Central Sales Region");
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "FL"));
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "GA"));
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "NC"));
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "LA"));
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "Al"));

            userManager.Create(new ApplicationUser {
                Email = "*****@*****.**", UserName = "******", DisplayName = "Emma Peel"
            }, "Password1");
            userManager.AddToRole(userManager.FindByEmail("*****@*****.**").Id, "Western Sales Region");
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "AZ"));
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "NM"));
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "TX"));

            userManager.Create(new ApplicationUser {
                Email = "*****@*****.**", UserName = "******", DisplayName = "Austin Powers"
            }, "Password1");
            userManager.AddToRole(userManager.FindByEmail("*****@*****.**").Id, "Eastern Sales Region");
            userManager.AddToRole(userManager.FindByEmail("*****@*****.**").Id, "Central Sales Region");
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "UT"));
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "CO"));
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "AZ"));
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "NM"));
            userManager.AddClaim(userManager.FindByEmail("*****@*****.**").Id, new Claim("ViewState", "TX"));

            context.SaveChanges();

            //userManager.AddToRole("*****@*****.**", "EasternRegion");

            //8context.SaveChanges();
        }
 public ActionResult TeacherEdit(User input)
 {
     UserManager manager = new UserManager();
     User user = manager.findById(input.Id);
     if (ModelState.IsValid) {
         manager.AddClaim(input.Id, new Claim(ClaimTypes.Role, "teacher"));
         return RedirectToAction("Index");
     }
     return View(user);
 }
Beispiel #8
0
        //le mandamos todos los datos del usuario que se va a hacer la cuenta
        public static Response CreateUserASP(UserRequest userRequest)
        {
            try
            {
                //nos conecta con el administrador de usuarios
                var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(userContext));
                //busca si existe por un email, que es la clave
                var oldUserASP = userManager.FindByEmail(userRequest.EMail);
                //si alguien se ha hecho la cuenta anteriormente con ese email, da fallo
                if (oldUserASP != null)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = "001. User already exists.",
                    });
                }

                //guardamos los datos principales del usuario
                var userASP = new ApplicationUser
                {
                    Email       = userRequest.EMail,
                    UserName    = userRequest.EMail,
                    PhoneNumber = userRequest.Phone,
                };
                //creamos el usuario
                var result = userManager.Create(userASP, userRequest.Password);

                //si la creacion fue exitosa guardamos los datos adicionales como claims
                if (result.Succeeded)
                {
                    var newUserASP = userManager.FindByEmail(userRequest.EMail);
                    userManager.AddClaim(newUserASP.Id, new System.Security.Claims.Claim(ClaimTypes.GivenName, userRequest.FirstName));
                    userManager.AddClaim(newUserASP.Id, new System.Security.Claims.Claim(ClaimTypes.Name, userRequest.LastName));

                    if (!string.IsNullOrEmpty(userRequest.Address))
                    {
                        userManager.AddClaim(newUserASP.Id, new System.Security.Claims.Claim(ClaimTypes.StreetAddress, userRequest.Address));
                    }

                    if (!string.IsNullOrEmpty(userRequest.ImagePath))
                    {
                        userManager.AddClaim(newUserASP.Id, new System.Security.Claims.Claim(ClaimTypes.Uri, userRequest.ImagePath));
                    }

                    return(new Response
                    {
                        IsSuccess = true,
                    });
                }

                var errors = string.Empty;
                foreach (var error in result.Errors)
                {
                    errors += $"{error}, ";
                }

                return(new Response
                {
                    IsSuccess = false,
                    Message = errors,
                });
            }
            catch (Exception ex)
            {
                return(new Response
                {
                    IsSuccess = false,
                    Message = ex.Message,
                });
            }
        }
 public void AddClaim()
 {
     var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(this._session));
     var user = new ApplicationUser() { UserName = "******", Email = "*****@*****.**", EmailConfirmed = true };
     userManager.Create(user, "Welcome");
     userManager.AddClaim(user.Id, new Claim(ClaimTypes.Role, "Admin"));
     Assert.AreEqual(1, userManager.GetClaims(user.Id).Count());
 }
Beispiel #10
0
        protected override void Seed(Notes.Models.ApplicationDbContext context)
        {
            // Add the initial 'admin' user...
            if (context.Users.Count() == 0)
            {
                // First, initialize a user manager
                var um = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));

                // Attempt to create an 'admin' user
                var admin = new ApplicationUser {
                    FirstName = "App", LastName = "Administrator", UserName = "******", Email = "*****@*****.**"
                };
                var result = um.Create(admin, "Password123!");

                // Attempt to add role claims
                if (result.Succeeded)
                {
                    um.AddClaim(admin.Id, new Claim(ClaimTypes.Email, admin.Email));
                    um.AddClaim(admin.Id, new Claim(ClaimTypes.GivenName, admin.FirstName));
                    um.AddClaim(admin.Id, new Claim(ClaimTypes.Surname, admin.LastName));
                    um.AddClaim(admin.Id, new Claim(ClaimTypes.Role, "Administrator"));
                }
            }

            // Add the 'organizational units' and the 'employees'

            // Create a reference to the app's data manager
            Controllers.Manager m = new Controllers.Manager();

            // Load the OUs
            if (context.OUs.Count() == 0)
            {
                // Add some OUs...
                context.OUs.Add(new OU {
                    OUName = "Executive Office"
                });
                context.OUs.Add(new OU {
                    OUName = "Electrical"
                });
                context.OUs.Add(new OU {
                    OUName = "Editorial"
                });
                context.OUs.Add(new OU {
                    OUName = "Research & Development"
                });
                context.OUs.Add(new OU {
                    OUName = "Talent"
                });
                context.OUs.Add(new OU {
                    OUName = "Human Resources"
                });
                context.OUs.Add(new OU {
                    OUName = "Production"
                });
                context.OUs.Add(new OU {
                    OUName = "Creative"
                });

                context.SaveChanges();
            }

            // Load the Employees
            if (context.Employees.Count() == 0)
            {
                // File system path to the data file (in this project's App_Data folder)
                // Not yet tested with Azure - if it is problematic...
                // ...contact your professor for help (or with the solution)
                string path = System.Web.Hosting.HostingEnvironment.MapPath("~/App_Data/Employees.csv");

                // Create a stream reader object, to read from the file system
                StreamReader sr = File.OpenText(path);

                // Create the CsvHelper object
                var csv = new CsvReader(sr);

                // Create the AutoMapper mapping
                Mapper.CreateMap <Controllers.EmployeeAdd, Models.Employee>();

                // Go through the data file
                while (csv.Read())
                {
                    // Read one line in the source file
                    EmployeeAdd newItem = csv.GetRecord <EmployeeAdd>();

                    // Create a new employee object
                    Employee addedItem = Mapper.Map <Employee>(newItem);

                    // Add the new object to the data store
                    context.Employees.Add(addedItem);
                }

                context.SaveChanges();

                // Clean up
                sr.Close();
                sr = null;
            }
        }
        public static void Configure(EntityFrameworkServiceOptions options)
        {
            using (var db = new ScopeConfigurationDbContext(options.ConnectionString, options.Schema))
            {
                if (!db.Scopes.Any())
                {
                    foreach (var s in StandardScopes.All)
                    {
                        var e = s.ToEntity();
                        db.Scopes.Add(e);
                    }

                    foreach (var s in StandardScopes.AllAlwaysInclude)
                    {
                        var e = s.ToEntity();
                        db.Scopes.Add(e);
                    }

                    db.SaveChanges();
                }
            }

            using (var db = new Context(options.ConnectionString))
            {
                if (!db.Users.Any())
                {
                    using (var userManager = new UserManager(new UserStore(db)))
                    {
                        var defaultUserPassword = "******"; // Must be atleast 6 characters
                        var user = new User
                        {
                            UserName       = "******",
                            FirstName      = "Luke",
                            LastName       = "Skywalker",
                            Email          = "*****@*****.**",
                            EmailConfirmed = true
                        };
                        userManager.Create(user, defaultUserPassword);
                        userManager.AddClaim(user.Id,
                                             new Claim(Core.Constants.ClaimTypes.WebSite, "https://www.johanbostrom.se/"));
                    }

                    db.SaveChanges();
                }
            }

            using (var db = new ClientConfigurationDbContext(options.ConnectionString, options.Schema))
            {
                if (!db.Clients.Any())
                {
                    var defaultHybridClient = new Client
                    {
                        ClientName    = "Default Hybrid Client",
                        ClientId      = "default.hybrid",
                        Flow          = Flows.Hybrid,
                        ClientSecrets = new List <Secret>
                        {
                            new Secret("default.hybrid.password".Sha256())
                        },
                        AllowedScopes = new List <string>
                        {
                            Core.Constants.StandardScopes.OpenId,
                            Core.Constants.StandardScopes.Profile,
                            Core.Constants.StandardScopes.Email,
                            Core.Constants.StandardScopes.Roles,
                            Core.Constants.StandardScopes.Address,
                            Core.Constants.StandardScopes.Phone,
                            Core.Constants.StandardScopes.OfflineAccess
                        },
                        ClientUri              = "https://localhost:44300/",
                        RequireConsent         = false,
                        AccessTokenType        = AccessTokenType.Reference,
                        RedirectUris           = new List <string>(),
                        PostLogoutRedirectUris = new List <string>
                        {
                            "https://localhost:44300/"
                        },
                        LogoutSessionRequired = true
                    };

                    db.Clients.Add(defaultHybridClient.ToEntity());
                    db.SaveChanges();
                }
            }
        }
Beispiel #12
0
        public void Update()
        {
            var user = UserManager.FindById(User.Identity.GetUserId());

            UserManager.AddClaim(user.Id, new Claim("FirstName", user.FirstName));
        }
        private static void SeedUsersAndRoles(TechWallDbContext context)
        {
            string roleAdmin        = "admin";
            string roleEshopManager = "eshopmanager";
            string roleCustomer     = "customer";

            if (!context.Roles.Any(u => u.Name == "admin"))
            {
                var roleStore    = new RoleStore <IdentityRole>(context);
                var roleManager  = new RoleManager <IdentityRole>(roleStore);
                var identityRole = new IdentityRole {
                    Name = roleAdmin
                };
                roleManager.Create(identityRole);
            }

            if (!context.Roles.Any(u => u.Name == "eshopmanager"))
            {
                var roleStore    = new RoleStore <IdentityRole>(context);
                var roleManager  = new RoleManager <IdentityRole>(roleStore);
                var identityRole = new IdentityRole {
                    Name = roleEshopManager
                };
                roleManager.Create(identityRole);
            }

            if (!context.Roles.Any(u => u.Name == "customer"))
            {
                var roleStore    = new RoleStore <IdentityRole>(context);
                var roleManager  = new RoleManager <IdentityRole>(roleStore);
                var identityRole = new IdentityRole {
                    Name = roleCustomer
                };
                roleManager.Create(identityRole);
            }


            if (!context.Users.Any(u => u.UserName == "*****@*****.**"))
            {
                var store = new UserStore <ApplicationUser>(context);

                var manager = new UserManager <ApplicationUser>(store);

                var user = new ApplicationUser {
                    UserName       = "******",
                    Email          = "*****@*****.**",
                    EmailConfirmed = true,
                    Picture        = new ProfilePicture {
                        URL = "~/Images/Users/0.jpg"
                    }
                };

                manager.Create(user, "!Admin#1234");
                manager.AddToRole(user.Id, roleAdmin);
                manager.AddClaim(user.Id, new Claim("ProfilePicture", user.Picture.URL));
            }


            if (!context.Users.Any(u => u.UserName == "*****@*****.**"))
            {
                var store = new UserStore <ApplicationUser>(context);

                var manager = new UserManager <ApplicationUser>(store);

                var user = new ApplicationUser {
                    UserName       = "******",
                    Email          = "*****@*****.**",
                    EmailConfirmed = true,
                    Picture        = new ProfilePicture {
                        URL = "~/Images/Users/0.jpg"
                    }
                };

                manager.Create(user, "!Admin#1234");

                manager.AddToRole(user.Id, roleEshopManager);
                manager.AddClaim(user.Id, new Claim("ProfilePicture", user.Picture.URL));
            }



            if (!context.Users.Any(u => u.UserName == "*****@*****.**"))
            {
                var store = new UserStore <ApplicationUser>(context);

                var manager = new UserManager <ApplicationUser>(store);

                var user = new ApplicationUser {
                    UserName       = "******",
                    Email          = "*****@*****.**",
                    EmailConfirmed = true,
                    Picture        = new ProfilePicture {
                        URL = "~/Images/Users/0.jpg"
                    }
                };                                   //DEN EXEI DHMIOURGITHEI

                manager.Create(user, "!Admin#1234"); //to 2o einai to password, opote thelei Kefalaio-mikro ktl

                manager.AddToRole(user.Id, roleCustomer);
                manager.AddClaim(user.Id, new Claim("ProfilePicture", user.Picture.URL));
            }
        }
Beispiel #14
0
        protected void CreateUser_Click(object sender, EventArgs e)
        {
            // Default UserStore constructor uses the default connection
            // string named: DefaultConnection
            var userStore = new UserStore <IdentityUser>();
            var manager   = new UserManager <IdentityUser>(userStore);

            var user = new IdentityUser()
            {
                UserName = UserName.Text.Trim(),
                Email    = Email.Text.Trim()
            };
            IdentityResult result = manager.Create(user, Password.Text.Trim());

            if (result.Succeeded)
            {
                //Add the created user to the selected role
                var currentUser = manager.FindByName(user.UserName);
                var roleResult  = manager.AddToRole(currentUser.Id, RolesList.SelectedItem.Text);

                //Add the created user to the selected claims/projects
                foreach (ListItem item in Implementing_Partner_List.Items)
                {
                    if (item.Selected)
                    {
                        manager.AddClaim(currentUser.Id, new Claim("Project", item.Value));
                    }
                }
                foreach (ListItem item in Pillars_List.Items)
                {
                    if (item.Selected)
                    {
                        manager.AddClaim(currentUser.Id, new Claim("Pillar", item.Value));
                    }
                }

                //Sign in the created user

                /*var authenticationManager = HttpContext.Current.GetOwinContext().Authentication;
                 * var userIdentity = manager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);
                 * authenticationManager.SignIn(new AuthenticationProperties() { }, userIdentity);
                 * Response.Redirect("~/Account/Login.aspx");*/

                //====================================================+
                //  Send Email Message to Welcome Registered user     |
                //====================================================+

                //Create the mail message
                MailMessage mail = new MailMessage();

                //Add multiple addresses
                mail.To.Add(new MailAddress(user.Email, user.UserName));

                //Set the content
                mail.Subject = "Welcome to the FSD Africa MRM Reporting System";

                System.Text.StringBuilder sbuilder = new System.Text.StringBuilder();
                //sbuilder.Append("Hello " + currentUser.UserName + ",").AppendLine().AppendLine();
                sbuilder.Append("You have recently been registered on the " +
                                "‘FSD Africa MRM Reporting System’.").AppendLine().AppendLine();
                sbuilder.Append("Your current login details are:").AppendLine().AppendLine();
                sbuilder.Append("Username: "******"Default Password: "******"You can access the system here: http://results.fsdafrica.org ").AppendLine().AppendLine();
                sbuilder.Append("Thank you").AppendLine().AppendLine();
                sbuilder.Append("MRM team").AppendLine().AppendLine().AppendLine();
                sbuilder.Append("*This email is automatically generated - please do not reply").AppendLine();

                mail.Body = sbuilder.ToString();

                //Send the message
                SmtpClient smtp = new SmtpClient();
                /****SMTP Client is defined in the Web.Config File****/

                ServicePointManager.ServerCertificateValidationCallback = delegate(
                    object s, X509Certificate certificate, X509Chain chain,
                    SslPolicyErrors sslPolicyErrors)
                { return(true); }; //Always accept

                try
                {
                    smtp.Send(mail);
                    ScriptManager.RegisterStartupScript(Page, Page.GetType(), "infoModal", "$('#infoModal').modal();", true);
                    SuccessLbl.Text = currentUser.UserName + " Has been Successfully Registered";
                }
                catch (Exception ex)
                {
                    StatusMessage.Text = "MESSAGE NOT SENT " + ex.Message + "br />" + ex.StackTrace;
                }
                //=============================================+
                //                  END SEND MAIL              |
                //=============================================+
            }
            else
            {
                StatusMessage.Text = result.Errors.FirstOrDefault();
            }
        }
        protected override void Seed(DevReadyAcademy.Models.ApplicationDbContext context)
        {
            //  This method will be called after migrating to the latest version.

            //  You can use the DbSet<T>.AddOrUpdate() helper extension method
            //  to avoid creating duplicate seed data.


            // Use Code First Migrations to Seed the Database
            // https://docs.microsoft.com/en-us/aspnet/web-api/overview/data/using-web-api-with-entity-framework/part-3

            //Categories
            context.Categories.AddOrUpdate(
                c => c.Name,
                new Category {
                Name = "Unspecified"
            },
                new Category {
                Name = "Programming"
            },
                new Category {
                Name = "Data Science"
            },
                new Category {
                Name = "Database"
            }
                );

            //Courses
            context.Courses.AddOrUpdate(
                p => p.Title,
                new Course {
                Title = "Analyzing Data with Power BI", CategoryId = 1, PublishDate = DateTime.Now
            },
                new Course {
                Title = "Querying Microsoft SQL Server", CategoryId = 1, PublishDate = DateTime.Now
            },
                new Course {
                Title = "Administering Microsoft SQL Server Databases", CategoryId = 1, PublishDate = DateTime.Now
            },
                new Course {
                Title = "Implementing a Data Warehouse with Microsoft SQL Server", CategoryId = 1, PublishDate = DateTime.Now
            },
                new Course {
                Title = "Programming in C#", CategoryId = 1, PublishDate = DateTime.Now
            },
                new Course {
                Title = "Developing ASP.NET MVC 5 Web Applications", CategoryId = 1, PublishDate = DateTime.Now
            }

                );


            //Users and Roles
            var adminRoleName     = RoleName.Admin;
            var adminUserName     = "******";
            var adminEmailAddress = "*****@*****.**";

            var instructorRoleName     = RoleName.Instructor;
            var instructorUserName     = "******";
            var instructorEmailAddress = "*****@*****.**";

            var usersRoleName = RoleName.Users;


            var defaultPassword = "******";
            //var hashedPassword = new PasswordHasher().HashPassword("Pa55w.rd");

            //Role and Users
            var roleStore   = new RoleStore <IdentityRole>(context);
            var roleManager = new RoleManager <IdentityRole>(roleStore);

            var userStore   = new UserStore <ApplicationUser>(context);
            var userManager = new UserManager <ApplicationUser>(userStore);


            //Admin
            if (!context.Roles.Any(r => r.Name == adminRoleName))
            {
                var role = new IdentityRole {
                    Name = adminRoleName
                };
                roleManager.Create(role);
            }

            if (!context.Users.Any(u => u.UserName == adminUserName))
            {
                var user = new ApplicationUser
                {
                    UserName       = adminUserName,
                    Email          = adminEmailAddress,
                    FirstName      = "Admin",
                    LastName       = string.Empty,
                    EmailConfirmed = true
                };


                var result = userManager.Create(user, defaultPassword);


                if (result.Succeeded)
                {
                    //Assign User to a Role
                    userManager.AddToRole(user.Id, adminRoleName);

                    // Add User Claims for first and last name
                    userManager.AddClaim(user.Id, new Claim(ClaimType.FirstName, user.FirstName));
                    userManager.AddClaim(user.Id, new Claim(ClaimType.LastName, user.LastName));
                }
            }


            //Instructor
            if (!context.Roles.Any(r => r.Name == instructorRoleName))
            {
                var role = new IdentityRole {
                    Name = instructorRoleName
                };
                roleManager.Create(role);
            }

            if (!context.Users.Any(u => u.UserName == instructorUserName))
            {
                var user = new ApplicationUser
                {
                    UserName       = instructorUserName,
                    Email          = instructorEmailAddress,
                    FirstName      = "Instructor",
                    LastName       = string.Empty,
                    EmailConfirmed = true
                };

                var result = userManager.Create(user, defaultPassword);



                if (result.Succeeded)
                {
                    //Assign User to a Role
                    userManager.AddToRole(user.Id, instructorRoleName);

                    // Add User Claims for first and last name
                    userManager.AddClaim(user.Id, new Claim(ClaimType.FirstName, user.FirstName));
                    userManager.AddClaim(user.Id, new Claim(ClaimType.LastName, user.LastName));
                }
            }


            //Users
            if (!context.Roles.Any(r => r.Name == usersRoleName))
            {
                var role = new IdentityRole {
                    Name = usersRoleName
                };
                roleManager.Create(role);
            }
        }
 public void FindByEmailAggregated()
 {
     var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(this._session));
     var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(this._session));
     userManager.Create(new ApplicationUser() { UserName = "******", Email = "*****@*****.**", EmailConfirmed = true }, "Welcome");
     var x = userManager.FindByEmail("*****@*****.**");
     roleManager.CreateAsync(new IdentityRole("Admin"));
     userManager.AddClaim(x.Id, new Claim("role", "admin"));
     userManager.AddClaim(x.Id, new Claim("role", "user"));
     userManager.AddToRole(x.Id, "Admin");
     userManager.AddLogin(x.Id, new UserLoginInfo("facebook", "1234"));
     this._session.Clear();
     x = userManager.FindByEmail("*****@*****.**");
     Assert.IsNotNull(x);
     Assert.AreEqual(2, x.Claims.Count);
     Assert.AreEqual(1, x.Roles.Count);
     Assert.AreEqual(1, x.Logins.Count);
 }
Beispiel #17
0
        public static Response CreateUserASP(UserRequest userRequest)
        {
            try
            {
                var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(userContext));
                var oldUserASP  = userManager.FindByEmail(userRequest.EMail);

                //aqui filtro si el usurio existe:
                if (oldUserASP != null)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        //el 001 es el simbolo del error, para traducirlos en los diferentes idiomas en el from:
                        Message = "001. User already exists.",
                    });
                }

                //aqui creo el usurio si no exite
                var userASP = new ApplicationUser
                {
                    Email = userRequest.EMail,
                    //alias del usurio, el mismo email:
                    UserName    = userRequest.EMail,
                    PhoneNumber = userRequest.Phone,
                };

                var result = userManager.Create(userASP, userRequest.Password);
                if (result.Succeeded)
                {
                    var newUserASP = userManager.FindByEmail(userRequest.EMail);
                    //aqui le grabo datos adiciolas:
                    userManager.AddClaim(newUserASP.Id, new System.Security.Claims.Claim(ClaimTypes.GivenName, userRequest.FirstName));
                    userManager.AddClaim(newUserASP.Id, new System.Security.Claims.Claim(ClaimTypes.Name, userRequest.LastName));

                    //aqui guardo los datos de la las propiedades como claims:
                    if (!string.IsNullOrEmpty(userRequest.Address))
                    {
                        userManager.AddClaim(newUserASP.Id, new System.Security.Claims.Claim(ClaimTypes.StreetAddress, userRequest.Address));
                    }

                    if (!string.IsNullOrEmpty(userRequest.ImagePath))
                    {
                        userManager.AddClaim(newUserASP.Id, new System.Security.Claims.Claim(ClaimTypes.Uri, userRequest.ImagePath));
                    }

                    return(new Response
                    {
                        IsSuccess = true,
                    });
                }

                var errors = string.Empty;
                foreach (var error in result.Errors)
                {
                    errors += $"{error}, ";
                }

                return(new Response
                {
                    IsSuccess = false,
                    Message = errors,
                });
            }
            catch (Exception ex)
            {
                return(new Response
                {
                    IsSuccess = false,
                    Message = ex.Message,
                });
            }
        }
 public void CreateWithoutCommitingTransactionScopeShouldNotInsertRows()
 {
     var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(this._session));
     var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(this._session));
     using (var ts = new TransactionScope(TransactionScopeOption.RequiresNew))
     {
         // session is not opened inside the scope so we need to enlist it manually
         ((System.Data.Common.DbConnection)_session.Connection).EnlistTransaction(System.Transactions.Transaction.Current);
         userManager.Create(new ApplicationUser() { UserName = "******", Email = "*****@*****.**", EmailConfirmed = true }, "Welcome1");
         var x = userManager.FindByEmail("*****@*****.**");
         roleManager.Create(new IdentityRole("Admin"));
         userManager.AddClaim(x.Id, new Claim("role", "admin"));
         userManager.AddClaim(x.Id, new Claim("role", "user"));
         userManager.AddToRole(x.Id, "Admin");
         userManager.AddLogin(x.Id, new UserLoginInfo("facebook", "1234"));
     }
     var x2 = userManager.FindByEmail("*****@*****.**");
     Assert.IsNull(x2);
 }
Beispiel #19
0
        protected override void Seed(AuthContext context)
        {
            //UserManager<ApplicationUser> userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>());
            //var user = userManager.FindByName("*****@*****.**");

            UserManager <ApplicationUser> userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new AuthContext()));

            ApplicationUser user = new ApplicationUser
            {
                Id           = Guid.NewGuid().ToString(),
                UserName     = "******",
                Email        = "*****@*****.**",
                PasswordHash = userManager.PasswordHasher.HashPassword("123456"),
            };

            userManager.Create(user);
            userManager.AddClaim(user.Id, new Claim(ClaimTypes.NameIdentifier, user.Id, ClaimValueTypes.String));

            ListOfTasks list1 = new ListOfTasks()
            {
                Id     = 1,
                Name   = "My list 1",
                UserId = user.Id,
                Tasks  = new List <Task>
                {
                    new Task()
                    {
                        Id      = 1,
                        Name    = "Task 1.1",
                        Created = DateTime.Now.AddDays(-2),
                        End     = DateTime.Now,
                        IsDone  = false
                    }
                }
            };

            ListOfTasks list2 = new ListOfTasks()
            {
                Id     = 2,
                Name   = "Today",
                UserId = user.Id,
                Tasks  = new List <Task>
                {
                    new Task()
                    {
                        Id      = 2,
                        Name    = "Task 2.1",
                        Created = DateTime.Now.AddDays(-1),
                        End     = DateTime.Now.AddDays(3),
                        IsDone  = false
                    },
                    new Task()
                    {
                        Id      = 3,
                        Name    = "Task 2.2",
                        Created = DateTime.Now.AddMinutes(-45),
                        End     = DateTime.Now.AddMinutes(45),
                        IsDone  = true
                    },
                    new Task()
                    {
                        Id      = 4,
                        Name    = "Task 2.3",
                        Created = DateTime.Now.AddMinutes(-15),
                        End     = DateTime.Now.AddMinutes(30),
                        IsDone  = true
                    }
                }
            };

            ListOfTasks list3 = new ListOfTasks()
            {
                Id     = 3,
                Name   = "Home",
                UserId = user.Id,
                Tasks  = new List <Task> {
                    new Task()
                    {
                        Id      = 5,
                        Name    = "Task 3.1",
                        Created = DateTime.Now,
                        End     = DateTime.Now.AddDays(4),
                        IsDone  = false
                    },
                    new Task()
                    {
                        Id      = 6,
                        Name    = "Task 3.2",
                        Created = DateTime.Now,
                        End     = DateTime.Now.AddMinutes(57),
                        IsDone  = false
                    }
                }
            };

            context.TaskLists.Add(list1);
            context.TaskLists.Add(list2);
            context.TaskLists.Add(list3);
        }
 public void CreateWithoutCommitingNHibernateTransactionShouldNotInsertRows()
 {
     var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(this._session));
     var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(this._session));
     using (var ts = _session.BeginTransaction())
     {
         userManager.Create(new ApplicationUser() { UserName = "******", Email = "*****@*****.**", EmailConfirmed = true }, "Welcome1");
         var x = userManager.FindByEmail("*****@*****.**");
         roleManager.Create(new IdentityRole("Admin"));
         userManager.AddClaim(x.Id, new Claim("role", "admin"));
         userManager.AddClaim(x.Id, new Claim("role", "user"));
         userManager.AddToRole(x.Id, "Admin");
         userManager.AddLogin(x.Id, new UserLoginInfo("facebook", "1234"));
     }
     var x2 = userManager.FindByEmail("*****@*****.**");
     Assert.IsNull(x2);
 }
        public virtual ApplicationIdentityResult AddClaim(int userId, Claim claim)
        {
            var identityResult = _userManager.AddClaim(userId, claim);

            return(identityResult.ToApplicationIdentityResult());
        }
Beispiel #22
0
        /// <summary>
        /// Seed method attempts to intsert the initial data into the database everytime when database is being updated after migration
        /// </summary>
        /// <param name="context">Database context on which seed method is being called (Not used in this scenario because repositories are used to insert the data)</param>
        protected override void Seed(RAMS.Data.DataContext context)
        {
            // Add users
            using (var applicationDbContext = new ApplicationDbContext())
            {
                var userStore = new UserStore <ApplicationUser>(applicationDbContext);

                var userManager = new UserManager <ApplicationUser>(userStore);

                if (userManager.FindByName("john.doe") == null)
                {
                    var users = GetUsers();

                    foreach (var user in users)
                    {
                        userManager.Create(user, "123RAMSApp!");

                        // Add user claims for each user
                        if (user.UserName == "superuser")
                        {
                            userManager.AddClaim(user.Id, new Claim("FullName", "superuser"));
                            userManager.AddClaim(user.Id, new Claim("Role", "Manager"));
                            userManager.AddClaim(user.Id, new Claim("UserType", "Admin"));
                            userManager.AddClaim(user.Id, new Claim("UserStatus", "Active"));
                        }
                        else if (user.UserName == "john.doe")
                        {
                            userManager.AddClaim(user.Id, new Claim("FullName", "John Doe"));
                            userManager.AddClaim(user.Id, new Claim("Role", "Manager"));
                            userManager.AddClaim(user.Id, new Claim("UserType", "Agent"));
                            userManager.AddClaim(user.Id, new Claim("UserStatus", "Active"));
                        }
                        else if (user.UserName == "james.smith")
                        {
                            userManager.AddClaim(user.Id, new Claim("FullName", "James Smith"));
                            userManager.AddClaim(user.Id, new Claim("Role", "Employee"));
                            userManager.AddClaim(user.Id, new Claim("UserType", "Agent"));
                            userManager.AddClaim(user.Id, new Claim("UserStatus", "Active"));
                        }
                        else if (user.UserName == "mary.watson")
                        {
                            userManager.AddClaim(user.Id, new Claim("FullName", "Mary Watson"));
                            userManager.AddClaim(user.Id, new Claim("Role", "Employee"));
                            userManager.AddClaim(user.Id, new Claim("UserType", "Agent"));
                            userManager.AddClaim(user.Id, new Claim("UserStatus", "Active"));
                        }
                        else if (user.UserName == "tommy.jordan")
                        {
                            userManager.AddClaim(user.Id, new Claim("FullName", "Tommy Jordan"));
                            userManager.AddClaim(user.Id, new Claim("Role", "Employee"));
                            userManager.AddClaim(user.Id, new Claim("UserType", "Admin"));
                            userManager.AddClaim(user.Id, new Claim("UserStatus", "Active"));
                        }
                        else if (user.UserName == "kathy.doe")
                        {
                            userManager.AddClaim(user.Id, new Claim("FullName", "Kathy Doe"));
                            userManager.AddClaim(user.Id, new Claim("Role", "Employee"));
                            userManager.AddClaim(user.Id, new Claim("UserType", "Admin"));
                            userManager.AddClaim(user.Id, new Claim("UserStatus", "Active"));
                        }
                        else if (user.UserName == "jimmy.thomson")
                        {
                            userManager.AddClaim(user.Id, new Claim("FullName", "Jimmy Thomson"));
                            userManager.AddClaim(user.Id, new Claim("Role", "Employee"));
                            userManager.AddClaim(user.Id, new Claim("UserType", "Client"));
                            userManager.AddClaim(user.Id, new Claim("UserStatus", "Active"));
                        }
                        else if (user.UserName == "nancy.clinton")
                        {
                            userManager.AddClaim(user.Id, new Claim("FullName", "Nancy Clinton"));
                            userManager.AddClaim(user.Id, new Claim("Role", "Employee"));
                            userManager.AddClaim(user.Id, new Claim("UserType", "Client"));
                            userManager.AddClaim(user.Id, new Claim("UserStatus", "Active"));
                        }
                    }
                }
            }

            // Add departments
            if (!departmentRepository.GetAll().Any())
            {
                GetDepartments().ForEach(d => departmentRepository.Add(d));

                unitOfWork.Commit();
            }

            // Add agents
            if (!agentRepository.GetAll().Any())
            {
                GetAgents().ForEach(a => agentRepository.Add(a));

                unitOfWork.Commit();
            }

            // Add clients
            if (!clientRepository.GetAll().Any())
            {
                GetClients().ForEach(c => clientRepository.Add(c));

                unitOfWork.Commit();
            }

            // Add admins
            if (!adminRepository.GetAll().Any())
            {
                GetAdmins().ForEach(a => adminRepository.Add(a));

                unitOfWork.Commit();
            }

            // Add categories
            if (!categoryRepository.GetAll().Any())
            {
                GetCategories().ForEach(c => categoryRepository.Add(c));

                unitOfWork.Commit();
            }

            // Add positions
            if (!positionRepository.GetAll().Any())
            {
                GetPositions().ForEach(p => positionRepository.Add(p));

                unitOfWork.Commit();
            }

            // Add candidates
            if (!candidateRepository.GetAll().Any())
            {
                GetCandidates().ForEach(c => candidateRepository.Add(c));

                unitOfWork.Commit();
            }

            // Add interiews
            if (!interviewRepository.GetAll().Any())
            {
                GetInterviews().ForEach(i => interviewRepository.Add(i));

                unitOfWork.Commit();
            }

            // Add notifications
            if (!notificationRepository.GetAll().Any())
            {
                GetNotifications().ForEach(n => notificationRepository.Add(n));

                unitOfWork.Commit();
            }
        }
Beispiel #23
0
        public static Response CreateUserASP(UserRequest userRequest)
        {
            try
            {
                var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(userContext));
                var oldUserASP  = userManager.FindByEmail(userRequest.EMail);
                if (oldUserASP != null)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = "001. User already exists.",
                    });
                }

                var userASP = new ApplicationUser
                {
                    Email       = userRequest.EMail,
                    UserName    = userRequest.EMail,
                    PhoneNumber = userRequest.Phone,
                };

                var result = userManager.Create(userASP, userRequest.Password);
                if (result.Succeeded)
                {
                    var newUserASP = userManager.FindByEmail(userRequest.EMail);
                    userManager.AddClaim(newUserASP.Id, new System.Security.Claims.Claim(ClaimTypes.GivenName, userRequest.FirstName));
                    userManager.AddClaim(newUserASP.Id, new System.Security.Claims.Claim(ClaimTypes.Name, userRequest.LastName));

                    if (!string.IsNullOrEmpty(userRequest.Address))
                    {
                        userManager.AddClaim(newUserASP.Id, new System.Security.Claims.Claim(ClaimTypes.StreetAddress, userRequest.Address));
                    }

                    if (!string.IsNullOrEmpty(userRequest.ImagePath))
                    {
                        userManager.AddClaim(newUserASP.Id, new System.Security.Claims.Claim(ClaimTypes.Uri, userRequest.ImagePath));
                    }

                    return(new Response
                    {
                        IsSuccess = true,
                    });
                }

                var errors = string.Empty;
                foreach (var error in result.Errors)
                {
                    errors += $"{error}, ";
                }

                return(new Response
                {
                    IsSuccess = false,
                    Message = errors,
                });
            }
            catch (Exception ex)
            {
                return(new Response
                {
                    IsSuccess = false,
                    Message = ex.Message,
                });
            }
        }
        protected override void Seed(ApplicationDbContext context)
        {
            #region Add Role Groups

            var home = new ApplicationRoleGroup
            {
                Name = "Home"
            };

            context.ApplicationRoleGroup.Add(home);

            #endregion


            #region Add Roles

            context.Roles.Add(new ApplicationRole
            {
                Name        = "Home_About",
                Description = "Access to About",
                RoleGroup   = home
            });

            context.Roles.Add(new ApplicationRole
            {
                Name        = "Home_Contact",
                Description = "Access to Contact",
                RoleGroup   = home
            });

            context.Roles.Add(new ApplicationRole
            {
                Name        = "Home_Permission",
                Description = "Access to Permission",
                RoleGroup   = home
            });

            #endregion


            #region Add users

            var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));

            var admin = new ApplicationUser
            {
                UserName     = "******",
                PasswordHash = userManager.PasswordHasher.HashPassword("123456")
            };

            var user = new ApplicationUser
            {
                UserName     = "******",
                PasswordHash = userManager.PasswordHasher.HashPassword("123456")
            };

            userManager.Create(admin);
            userManager.Create(user);

            userManager.AddClaim(admin.Id, new Claim(ClaimTypes.Role, "Home_About"));
            userManager.AddClaim(admin.Id, new Claim(ClaimTypes.Role, "Home_Contact"));
            userManager.AddClaim(admin.Id, new Claim(ClaimTypes.Role, "Home_Permission"));

            userManager.AddClaim(user.Id, new Claim(ClaimTypes.Role, "Home_About"));
            //for demo to use if permission view changes with current user logged in
            userManager.AddClaim(user.Id, new Claim(ClaimTypes.Role, "Home_Permission"));

            #endregion


            context.SaveChanges();

            base.Seed(context);
        }
Beispiel #25
0
 public void GetUserClaimSyncTest()
 {
     var db = UnitTestHelper.CreateDefaultDb();
     var manager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(db));
     var user = new IdentityUser("u1");
     var result = manager.Create(user);
     UnitTestHelper.IsSuccess(result);
     Assert.NotNull(user);
     var claims = new[]
     {
         new Claim("c1", "v1"),
         new Claim("c2", "v2"),
         new Claim("c3", "v3")
     };
     foreach (Claim c in claims)
     {
         UnitTestHelper.IsSuccess(manager.AddClaim(user.Id, c));
     }
     var userClaims = new List<Claim>(manager.GetClaims(user.Id));
     Assert.Equal(3, userClaims.Count);
     foreach (Claim c in claims)
     {
         Assert.True(userClaims.Exists(u => u.Type == c.Type && u.Value == c.Value));
     }
 }
Beispiel #26
0
        protected override void Seed(SchoolADM.DataLayer.ApplicationDbContext context)
        {
            try
            {
                //if (System.Diagnostics.Debugger.IsAttached == false)
                //    System.Diagnostics.Debugger.Launch();

                var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));

                userManager.UserValidator = new UserValidator <ApplicationUser>(userManager)
                {
                    AllowOnlyAlphanumericUserNames = false
                };
                userManager.PasswordValidator = new PasswordValidator
                {
                    RequiredLength          = 5,
                    RequireNonLetterOrDigit = false,
                    RequireDigit            = false,
                    RequireLowercase        = false,
                    RequireUppercase        = false,
                };

                #region roles
                var roleManager = new RoleManager <ApplicationRole>(new RoleStore <ApplicationRole>(new ApplicationDbContext()));
                if (null == roleManager.FindByName("Student"))
                {
                    var roleResult = roleManager.Create(new ApplicationRole("Student"));
                }
                if (null == roleManager.FindByName("Teacher"))
                {
                    var roleResult = roleManager.Create(new ApplicationRole("Teacher"));
                }
                #endregion roles

                #region admin
                string roleNameAdmin = "Admin";
                var    roleAdmin     = roleManager.FindByName(roleNameAdmin);
                if (roleAdmin == null)
                {
                    roleAdmin = new ApplicationRole(roleNameAdmin);
                    var roleResult = roleManager.Create(roleAdmin);
                }

                string adminName = "*****@*****.**";
                string password  = "******";
                string firstName = "Admin";

                var user = userManager.FindByName(adminName);
                if (user == null)
                {
                    user = new ApplicationUser {
                        UserName = adminName, Email = adminName, FirstName = firstName
                    };
                    var result = userManager.Create(user, password);
                    result = userManager.SetLockoutEnabled(user.Id, false);
                }
                var rolesForUser = userManager.GetRoles(user.Id);
                if (!rolesForUser.Contains(roleAdmin.Name))
                {
                    var result = userManager.AddToRole(user.Id, roleAdmin.Name);
                }
                #endregion admin

                #region other users

                if (null == userManager.FindByName("*****@*****.**"))
                {
                    user = new ApplicationUser {
                        UserName  = "******",
                        Email     = "*****@*****.**",
                        FirstName = "Name1",
                        LastName  = "Surname1"
                    };
                    var result = userManager.Create(user, "student1");

                    if (0 == user.Claims.Where(c => c.ClaimType == ClaimTypes.DateOfBirth).Count())
                    {
                        userManager.AddClaim(user.Id, new Claim(ClaimTypes.DateOfBirth, "1980-11-22"));
                    }
                    if (0 == user.Claims.Where(c => c.ClaimType == ClaimTypes.StreetAddress).Count())
                    {
                        userManager.AddClaim(user.Id, new Claim(ClaimTypes.StreetAddress, "address1"));
                    }
                    if (0 == user.Claims.Where(c => c.ClaimType == "MobilePhone").Count())
                    {
                        userManager.AddClaim(user.Id, new Claim("MobilePhone", "123456"));
                    }
                }

                if (null == userManager.FindByName("*****@*****.**"))
                {
                    user = new ApplicationUser
                    {
                        UserName  = "******",
                        Email     = "*****@*****.**",
                        FirstName = "Name2",
                        LastName  = "Surname2"
                    };
                    var result = userManager.Create(user, "student2");

                    if (0 == user.Claims.Where(c => c.ClaimType == ClaimTypes.DateOfBirth).Count())
                    {
                        userManager.AddClaim(user.Id, new Claim(ClaimTypes.DateOfBirth, "1970-12-10"));
                    }
                    if (0 == user.Claims.Where(c => c.ClaimType == ClaimTypes.StreetAddress).Count())
                    {
                        userManager.AddClaim(user.Id, new Claim(ClaimTypes.StreetAddress, "address2"));
                    }
                    if (0 == user.Claims.Where(c => c.ClaimType == "MobilePhone").Count())
                    {
                        userManager.AddClaim(user.Id, new Claim("MobilePhone", "555-55555"));
                    }
                }

                if (null == userManager.FindByName("*****@*****.**"))
                {
                    user = new ApplicationUser
                    {
                        UserName  = "******",
                        Email     = "*****@*****.**",
                        FirstName = "Name3",
                        LastName  = "Surname3"
                    };
                    var result = userManager.Create(user, "student3");

                    if (0 == user.Claims.Where(c => c.ClaimType == ClaimTypes.DateOfBirth).Count())
                    {
                        userManager.AddClaim(user.Id, new Claim(ClaimTypes.DateOfBirth, "1990-03-21"));
                    }
                    if (0 == user.Claims.Where(c => c.ClaimType == ClaimTypes.StreetAddress).Count())
                    {
                        userManager.AddClaim(user.Id, new Claim(ClaimTypes.StreetAddress, "address3"));
                    }
                    if (0 == user.Claims.Where(c => c.ClaimType == "MobilePhone").Count())
                    {
                        userManager.AddClaim(user.Id, new Claim("MobilePhone", "987654"));
                    }
                }

                if (null == userManager.FindByName("*****@*****.**"))
                {
                    user = new ApplicationUser
                    {
                        UserName  = "******",
                        Email     = "*****@*****.**",
                        FirstName = "Name4",
                        LastName  = "Surname4"
                    };
                    var result = userManager.Create(user, "student4");

                    if (0 == user.Claims.Where(c => c.ClaimType == ClaimTypes.DateOfBirth).Count())
                    {
                        userManager.AddClaim(user.Id, new Claim(ClaimTypes.DateOfBirth, "1982-05-05"));
                    }
                    if (0 == user.Claims.Where(c => c.ClaimType == ClaimTypes.StreetAddress).Count())
                    {
                        userManager.AddClaim(user.Id, new Claim(ClaimTypes.StreetAddress, "address4"));
                    }
                    if (0 == user.Claims.Where(c => c.ClaimType == "MobilePhone").Count())
                    {
                        userManager.AddClaim(user.Id, new Claim("MobilePhone", "456789"));
                    }
                }

                if (null == userManager.FindByName("*****@*****.**"))
                {
                    user = new ApplicationUser
                    {
                        UserName  = "******",
                        Email     = "*****@*****.**",
                        FirstName = "NameT1",
                        LastName  = "SurnameT1"
                    };
                    var result = userManager.Create(user, "teacher1");

                    if (0 == user.Claims.Where(c => c.ClaimType == "Department").Count())
                    {
                        userManager.AddClaim(user.Id, new Claim("Department", "Systems"));
                    }
                    if (0 == user.Claims.Where(c => c.ClaimType == "MobilePhone").Count())
                    {
                        userManager.AddClaim(user.Id, new Claim("MobilePhone", "222-222222222222"));
                    }
                }

                if (null == userManager.FindByName("*****@*****.**"))
                {
                    user = new ApplicationUser
                    {
                        UserName  = "******",
                        Email     = "*****@*****.**",
                        FirstName = "NameT2",
                        LastName  = "SurnameT2"
                    };
                    var result = userManager.Create(user, "teacher2");

                    if (0 == user.Claims.Where(c => c.ClaimType == "Department").Count())
                    {
                        userManager.AddClaim(user.Id, new Claim("Department", "Bioinformatics"));
                    }
                    if (0 == user.Claims.Where(c => c.ClaimType == "MobilePhone").Count())
                    {
                        userManager.AddClaim(user.Id, new Claim("MobilePhone", "333-33333"));
                    }
                }

                if (null == userManager.FindByName("*****@*****.**"))
                {
                    user = new ApplicationUser
                    {
                        UserName  = "******",
                        Email     = "*****@*****.**",
                        FirstName = "NameT3",
                        LastName  = "SurnameT3"
                    };
                    var result = userManager.Create(user, "teacher3");

                    if (0 == user.Claims.Where(c => c.ClaimType == "Department").Count())
                    {
                        userManager.AddClaim(user.Id, new Claim("Department", "Big Data Analytics"));
                    }
                    if (0 == user.Claims.Where(c => c.ClaimType == "MobilePhone").Count())
                    {
                        userManager.AddClaim(user.Id, new Claim("MobilePhone", "345-345345345"));
                    }
                }
                #endregion other users

                //context.SaveChanges();

                ////////////////////

                #region coursepaths

                context.CoursePath.AddOrUpdate(
                    c => c.CoursePathId,
                    new CoursePath
                {
                    CoursePathId   = 1,
                    CoursePathName = "Applied Math"
                });


                context.CoursePath.AddOrUpdate(
                    c => c.CoursePathId,
                    new CoursePath
                {
                    CoursePathId   = 2,
                    CoursePathName = "Logistics"
                });

                context.SaveChanges();

                var teacher1 = userManager.FindByName("*****@*****.**");

                context.Course.AddOrUpdate(
                    c => c.CourseId,
                    new Course
                {
                    CourseId     = 1,
                    CourseName   = "Mathematics 1",
                    CoursePathId = 1,
                    TeacherId    = teacher1.Id
                });

                var teacher2 = userManager.FindByName("*****@*****.**");

                context.Course.AddOrUpdate(
                    c => c.CourseId,
                    new Course
                {
                    CourseId     = 1,
                    CourseName   = "Mathematics 2",
                    CoursePathId = 1,
                    TeacherId    = teacher1.Id
                });

                context.SaveChanges();

                //context.Course.AddOrUpdate(
                // c => c.CourseId,
                // new Course
                // {
                //     CourseId = 2,
                //     CourseName = "Mathematics 2",
                //     Teacher = userManager.FindByName("*****@*****.**")
                // });



                #endregion coursepaths



                //string accountNumber = "ABC123";

                //context.Customers.AddOrUpdate(
                //    c => c.AccountNumber,
                //    new Customer
                //    {
                //        AccountNumber = accountNumber,
                //        CompanyName = "ABC Company of America",
                //        Address = "123 Main St.",
                //        City = "Anytown",
                //        State = "GA",
                //        ZipCode = "30071"
                //    });

                //context.SaveChanges();

                ////lo devo ricaricare per sapere la PK assegnata in automatico
                //Customer customer = context.Customers.First(c => c.AccountNumber == accountNumber);

                //string description = "Just another work order";

                //context.WorkOrders.AddOrUpdate(
                //    wo => wo.Description,
                //    new WorkOrder { Description = description, CustomerId = customer.CustomerId, WorkOrderStatus = WorkOrderStatus.Created }
                //    );

                //context.SaveChanges();

                //WorkOrder workOrder = context.WorkOrders.First(wo => wo.Description == description);

                //context.Parts.AddOrUpdate(
                //    p => p.InventoryItemCode,
                //    new Part { InventoryItemCode = "THING1", InventoryItemName = "Thing Number 1", Quantity = 1, UnitPrice = 1.23m, WorkOrderId = workOrder.WorkOrderId });

                //string categoryName = "Devices";

                //context.Categories.AddOrUpdate(
                //p => p.CategoryName,
                //new Category { CategoryName = categoryName });

                //context.SaveChanges();

                //Category category = context.Categories.First(c => c.CategoryName == categoryName);

                //context.InventoryItems.AddOrUpdate(
                //p => p.InventoryItemCode,
                //new InventoryItem { InventoryItemCode = "THING2", InventoryItemName = "A second kind of thing", UnitPrice = 3.33m, CategoryId = category.Id });


                /////////////Category
                //string categoryName = "Housing";

                //context.Categories.AddOrUpdate(
                //c => c.CategoryName,
                //new Category { CategoryName = categoryName });

                //context.SaveChanges();

                //Category category = context.Categories.First(c => c.CategoryName == categoryName);

                //context.Categories.AddOrUpdate(
                //        c => c.CategoryName,
                //        new Category { CategoryName = "Furniture", ParentCategoryId = category.Id },
                //        new Category { CategoryName = "Fixtures", ParentCategoryId = category.Id },
                //        new Category { CategoryName = "Building Materials", ParentCategoryId = category.Id }
                //        );

                //categoryName = "Learning Materials";

                //context.Categories.AddOrUpdate(
                //    c => c.CategoryName,
                //    new Category { CategoryName = categoryName });

                //context.SaveChanges();

                //category = context.Categories.First(c => c.CategoryName == categoryName);

                //context.Categories.AddOrUpdate(
                //      c => c.CategoryName,
                //      new Category { CategoryName = "Books", ParentCategoryId = category.Id },
                //      new Category { CategoryName = "Supplies", ParentCategoryId = category.Id }

                //      );

                //context.Categories.AddOrUpdate(
                //    c => c.CategoryName,
                //    new Category { CategoryName = "Food and Water" }

                //    );

                //context.SaveChanges();

                //////////////////////////////////

                //category = context.Categories.First(c => c.CategoryName == "Furniture");

                //context.InventoryItems.AddOrUpdate(
                //    ii => ii.InventoryItemName,
                //    new InventoryItem { CategoryId = category.Id, InventoryItemCode = "STUDENTDESK", InventoryItemName = "Student Desk", UnitPrice = 10m },
                //    new InventoryItem { CategoryId = category.Id, InventoryItemCode = "TESCHERDESK", InventoryItemName = "Teacher Desk", UnitPrice = 20m },
                //    new InventoryItem { CategoryId = category.Id, InventoryItemCode = "CHAIR", InventoryItemName = "Chair", UnitPrice = 6.95m }

                //    );

                //category = context.Categories.First(c => c.CategoryName == "Books");

                //context.InventoryItems.AddOrUpdate(
                //    ii => ii.InventoryItemName,
                //    new InventoryItem { CategoryId = category.Id, InventoryItemCode = "SCIENCETEXT", InventoryItemName = "Science Textbook", UnitPrice = 5.99m },
                //    new InventoryItem { CategoryId = category.Id, InventoryItemCode = "ARTTEXT", InventoryItemName = "Art History Textbook", UnitPrice = 6.40m },
                //    new InventoryItem { CategoryId = category.Id, InventoryItemCode = "POETRYTEXT", InventoryItemName = "Greatest Poems", UnitPrice = 3.23m }

                //    );

                //category = context.Categories.First(c => c.CategoryName == "Supplies");

                //context.InventoryItems.AddOrUpdate(
                //    ii => ii.InventoryItemName,
                //    new InventoryItem { CategoryId = category.Id, InventoryItemCode = "STUDENTSOUP", InventoryItemName = "Student Soup", UnitPrice = 3.45m },
                //    new InventoryItem { CategoryId = category.Id, InventoryItemCode = "TECHERSOUP", InventoryItemName = "Teacher Soup", UnitPrice = 4.45m },
                //    new InventoryItem { CategoryId = category.Id, InventoryItemCode = "MYSOUP", InventoryItemName = "My Soup", UnitPrice = 2.45m }

                //    );



                //category = context.Categories.First(c => c.CategoryName == "Housing");

                //context.InventoryItems.AddOrUpdate(
                //    ii => ii.InventoryItemName,
                //    new InventoryItem { CategoryId = category.Id, InventoryItemCode = "CLASSROOM", InventoryItemName = "Pre-fabricated classroom", UnitPrice = 3.45m }

                //    );


                //category = context.Categories.First(c => c.CategoryName == "Fixtures");

                //context.InventoryItems.AddOrUpdate(
                //    ii => ii.InventoryItemName,
                //    new InventoryItem { CategoryId = category.Id, InventoryItemCode = "WHITEBOARD", InventoryItemName = "Whiteboard", UnitPrice = 3.45m },
                //    new InventoryItem { CategoryId = category.Id, InventoryItemCode = "ARMOR", InventoryItemName = "Armor Plating Kit", UnitPrice = 3.45m }

                //    );


                //category = context.Categories.First(c => c.CategoryName == "Building Materials");

                //context.InventoryItems.AddOrUpdate(
                //    ii => ii.InventoryItemName,
                //    new InventoryItem { CategoryId = category.Id, InventoryItemCode = "BUILDING1", InventoryItemName = "Material 1", UnitPrice = 3.45m },
                //    new InventoryItem { CategoryId = category.Id, InventoryItemCode = "BUILDING2", InventoryItemName = "Material 2", UnitPrice = 3.45m }

                //    );

                //context.SaveChanges();


                //context.ServiceItems.AddOrUpdate(
                //   ii => ii.ServiceItemName,
                //   new ServiceItem { ServiceItemCode = "FORMANDOPUR", ServiceItemName = "Form and Pur", Rate = 35.56m },
                //   new ServiceItem { ServiceItemCode = "ERECTPREFS", ServiceItemName = "Prefabbgrifatoi", Rate = 45.56m }


                //   );


                //context.SaveChanges();


                ///////////
                //context.Customers.AddOrUpdate(
                //    cu => cu.AccountNumber,
                //    new Customer { AccountNumber = "GSTEMS", CompanyName = "Girls STEM School", Address = "35 Achievement Way", City = "Detroit", State = "MI", Phone = "123456", ZipCode = "43233" },
                //    new Customer { AccountNumber = "YWLS", CompanyName = "Young Women's Literary Society", Address = "15213 Aruna Lane", City = "Empoli", State = "IT", Phone = "1234565", ZipCode = "00100" },
                //    new Customer { AccountNumber = "TRS", CompanyName = "The Roosvelt School", Address = "731 Krasmer Street", City = "Parigi", State = "FR", Phone = "125555", ZipCode = "50100" }
                //);


                //context.SaveChanges();
            }
            catch (DbEntityValidationException e)
            {
                if (System.Diagnostics.Debugger.IsAttached == false)
                {
                    System.Diagnostics.Debugger.Launch();
                }

                foreach (var eve in e.EntityValidationErrors)
                {
                    Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
                                      eve.Entry.Entity.GetType().Name, eve.Entry.State);
                    foreach (var ve in eve.ValidationErrors)
                    {
                        Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
                                          ve.PropertyName, ve.ErrorMessage);
                    }
                }
                throw;
            }
            catch (Exception e)
            {
                if (System.Diagnostics.Debugger.IsAttached == false)
                {
                    System.Diagnostics.Debugger.Launch();
                }
                throw;
            }
        }