public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
        {
            var employeeIds = data.Employees.Select(e => e.Id).ToList();
            var projectIds = data.Projects.Select(p => p.Id).ToList();

            foreach (var employeeId in employeeIds)
            {
                var employeeProjectsCount = random.GetRandomNumber((int)(count * 0.5), (int)(count * 1.5));
                var currentProjects = new HashSet<int>();

                while (currentProjects.Count < employeeProjectsCount)
                {
                    var randomProjectId = projectIds[random.GetRandomNumber(0, projectIds.Count - 1)];
                    currentProjects.Add(randomProjectId);
                }

                foreach (var projectId in currentProjects)
                {
                    var endDateTimeSpan = random.GetRandomNumber(-500, 1000);
                    var startDateTimeSpan = endDateTimeSpan + random.GetRandomNumber(1, 500);

                    data.EmployeesInProjects.Add(new EmployeesInProject
                                                     {
                                                         EmployeeId = employeeId,
                                                         ProjectId = projectId,
                                                         StartDate = DateTime.Now.AddDays(-startDateTimeSpan),
                                                         EndDate = DateTime.Now.AddDays(-endDateTimeSpan)
                                                     });
                }
            }
        }
        private static void Main()
        {
            var random = RandomDataGenerator.Instance;
            var db = new CompanyEntities();
            var logger = new ConsoleLogger();

            db.Configuration.AutoDetectChangesEnabled = false;                  // Speed-up the application

            var listOfGenerators = new List<IDataGenerator>() {
                new DepartmentDataGenerator(random, db, 100, logger),           // Creates 100 departments
                new EmployeeDataGenerator(random, db, 5000, logger),            // Creates 5 000 employees
                new ProjectDataGenerator(random, db, 1000, logger),             // Creates 1 000 projects
                new ReportDataGenerator(random, db, 250000, logger),            // Creates 250 000 reports
            };

            foreach (var generator in listOfGenerators)
            {
                generator.Generate();
                db.SaveChanges();
            }

            AddManagers(random, db);

            db.Configuration.AutoDetectChangesEnabled = true;
        }
 public DataGenerator(IRandomDataGenerator randomDataGenerator, CompanyEntities companyEntities, int countOfGeneratedObjects, IConsoleLogger consoleLogger)
 {
     this.random = randomDataGenerator;
     this.db = companyEntities;
     this.count = countOfGeneratedObjects;
     this.logger = consoleLogger;
 }
        public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
        {
            var allAddedEmployees = new List<Employee>();
            var departmentIds = data.Departments.Select(d => d.Id).ToList();

            for (int i = 0; i < count; i++)
            {
                var employee = new Employee
                                   {
                                       FirstName = random.GetRandomString(random.GetRandomNumber(5, 20)),
                                       LastName = random.GetRandomString(random.GetRandomNumber(5, 20)),
                                       Salary = random.GetRandomNumber(50000, 200000),
                                       DepartmentId =
                                           departmentIds[random.GetRandomNumber(0, departmentIds.Count - 1)]
                                   };

                if (allAddedEmployees.Count > 0 && random.GetRandomNumber(1, 100) <= 95)
                {
                    employee.Employee1 = allAddedEmployees[random.GetRandomNumber(0, allAddedEmployees.Count - 1)];
                }

                allAddedEmployees.Add(employee);
            }

            data.Employees.AddRange(allAddedEmployees);
        }
 public CompanyGeneratorsFactory(IRandomDataGenerator random, ILogger logger, CompanyEntities databaseContext, int checkPointFrequency = 1000)
 {
     this.random = random;
     this.logger = logger;
     this.databaseContext = databaseContext;
     this.checkPointFrequency = checkPointFrequency;
 }
        public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
        {
            var employeeIds = data.Employees.Select(x => x.EmployeeId);
            var projectIds = data.Projects.Select(x => x.ProjectId).ToList();

            foreach (var employee in employeeIds)
            {
                var employeeProjects = random.GetRandomNumber((int)count / 2, (int)(count * 1.5));

                for (var i = 0; i < employeeProjects; i++)
                {
                    var projectId = projectIds[random.GetRandomNumber(1, projectIds.Count - 1)];

                    var startDate = DateTime.Now.AddDays(-random.GetRandomNumber(-500, 1000));
                    var endDate = startDate.AddDays(random.GetRandomNumber(1, 1234));

                    var employeeInProj = new Employees_Projects
                    {
                        ProjectId = projectId,
                        Startdate = startDate,
                        Enddate = endDate,
                        EmployeeId = employee
                    };

                    data.Employees_Projects.Add(employeeInProj);
                }
            }
        }
Example #7
0
        public static void Main()
        {
            var dataGeneratorExecutors = new List<DataGeneratorExecutor>
                                             {
                                                 new DataGeneratorExecutor(new DepartmentDataGenerator(), 100),
                                                 new DataGeneratorExecutor(new EmployeeDataGenerator(), 5000),
                                                 new DataGeneratorExecutor(new ProjectsDataGenerator(), 1000),
                                                 new DataGeneratorExecutor(new EmployeesInProjectsDataGenerator(), 10), // per employee
                                                 new DataGeneratorExecutor(new ReportsDataGenerator(), 50), // per employee
                                             };

            foreach (var dataGeneratorExecutor in dataGeneratorExecutors)
            {
                using (var data = new CompanyEntities())
                {
                    data.Configuration.AutoDetectChangesEnabled = false;
                    //// data.Configuration.ProxyCreationEnabled = false;

                    Console.WriteLine("Staring {0}...", dataGeneratorExecutor.DataGenerator.GetType().Name);
                    dataGeneratorExecutor.Execute(data, RandomGenerator.Instance);
                    Console.WriteLine("Saving {0}...", dataGeneratorExecutor.DataGenerator.GetType().Name);
                    data.SaveChanges();
                    Console.WriteLine("Finished {0}.", dataGeneratorExecutor.DataGenerator.GetType().Name);
                }
            }
        }
 public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
 {
     for (int i = 0; i < count; i++)
     {
         var project = new Project { Name = random.GetRandomString(random.GetRandomNumber(5, 50)) };
         data.Projects.Add(project);
     }
 }
        public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
        {
            for (var i = 0; i < count; i++)
            {
                var department = new Department
                {
                    Name = random.GetRandomString(random.GetRandomNumber(10, 50))
                };

                data.Departments.Add(department);
            }
        }
Example #10
0
        public void GenerateData(CompanyEntities context, IRandomGenerator random, int count)
        {
            for (var i = 0; i < count; i++)
            {
                var name = random.GetString(10, 50);

                var department = new Department
                {
                    Name = name
                };

                context.Departments.Add(department);
            }
        }
        public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
        {
            var uniqueNames = new HashSet<string>();

            while (uniqueNames.Count < count)
            {
                uniqueNames.Add(random.GetRandomString(random.GetRandomNumber(10, 50)));
            }

            foreach (var uniqueName in uniqueNames)
            {
                var department = new Department { Name = uniqueName };
                data.Departments.Add(department);
            }
        }
        public static void Main()
        {
            var random = RandomData.Instance;
            var db = new CompanyEntities();
            db.Configuration.AutoDetectChangesEnabled = false;

            var listOfGenerators = new List<IDataGenerator>
            {
                new DepartmentsGenerator(db, random, 100),
                new EmployeesGenerator(db, random, 5000),
                new ProjectsGenerator(db, random, 1000),
                new ReportsGenerator(db, random, 250000)
            };

            foreach (var generator in listOfGenerators)
            {
                generator.Generate();
                db.SaveChanges();
            }
        }
        private static void Main()
        {
            var databaseContext = new CompanyEntities();
            databaseContext.Configuration.AutoDetectChangesEnabled = false;
            var generatorFacotry = new CompanyGeneratorsFactory(new RandomDataGenerator(), new ConsoleLogger(), databaseContext, 100);
            var generators = new List<DataGenerator>
                                 {
                                     generatorFacotry.GetDepartmentGenerator(100),
                                     generatorFacotry.GetEmployeeGenerator(5000),
                                     generatorFacotry.GetProjectGenerator(100),
                                     generatorFacotry.GetReportGenerator(250)
                                 };

            foreach (var generator in generators)
            {
                generator.Generate();
                databaseContext.SaveChanges();
            }

            databaseContext.Configuration.AutoDetectChangesEnabled = true;
        }
        public void Import()
        {
            Assembly.GetExecutingAssembly()
                .GetTypes()
                .Where(t => typeof(IImporter).IsAssignableFrom(t)
                && !t.IsInterface
                && !t.IsAbstract)
                .Select(t => Activator.CreateInstance(t))
                .OfType<IImporter>()
                .OrderBy(i => i.Order)
                .ToList()
                .ForEach(i =>
                    {
                        textWriter.Write(i.Message);

                        var db = new CompanyEntities();
                        i.Get(db, this.textWriter);

                        textWriter.WriteLine();
                    });
        }
        private static void AddManagers(IRandomDataGenerator random, CompanyEntities db)
        {
            var employeeIDs = db.Employees.Select(c => c.ID).ToList();
            int i = 0;

            foreach (var employee in db.Employees)
            {
                if (random.GetRandomNumber(0, employeeIDs.Count - 1) < 95 * employeeIDs.Count / 100)
                {
                    var managerID = random.GetRandomNumber(1, employeeIDs.Count - 1);
                    while (managerID == i)
                    {
                        managerID = random.GetRandomNumber(1, employeeIDs.Count - 1);
                    }

                    employee.ManagerID = managerID;
                    db.SaveChanges();
                }

                i++;
            }
        }
Example #16
0
        public static void Main(string[] args)
        {
            var dataGeneratorExecutors = new List<DataGeneratorExecutor>
                                             {
                                                 new DataGeneratorExecutor(new DepartmentDataGenerator(), 100),
                                                 new DataGeneratorExecutor(new EmployeeDataGenerator(), 5000),
                                                 new DataGeneratorExecutor(new ProjectDataGenerator(), 1000),
                                                 new DataGeneratorExecutor(new EmployeesInProjectsDataGenerator(), 10), // per employee
                                                 new DataGeneratorExecutor(new ReportsDataGenerator(), 50), // per employee
                                             };

            foreach (var dataGeneratorExecutor in dataGeneratorExecutors)
            {
                using (var data = new CompanyEntities())
                {
                    data.Configuration.AutoDetectChangesEnabled = false;

                    dataGeneratorExecutor.Execute(data, RandomGenerator.Instance);
                    data.SaveChanges();
                }
            }
        }
        public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
        {
            var employeeIds = data.Employees.Select(e => e.Id).ToList();

            foreach (var employeeId in employeeIds)
            {
                var reportsCount = random.GetRandomNumber((int)(0.5 * count), (int)(1.5 * count));

                for (int i = 0; i < reportsCount; i++)
                {
                    var timeSpanForReport = random.GetRandomNumber(0, 60 * 60 * 24 * 1000);

                    var report = new Report
                                     {
                                         EmployeeId = employeeId,
                                         Time = DateTime.Now.AddSeconds(-timeSpanForReport)
                                     };

                    data.Reports.Add(report);
                }
            }
        }
Example #18
0
        static void Main(string[] args)
        {
            var random = RandomDataGenerator.Instance;
            var db = new CompanyEntities();
            db.Configuration.AutoDetectChangesEnabled = false;

            var listOfGenerators = new List<IDataGenerator>
            {
                new DepartmentDataGenerator(random, db, 100),
                new EmployeeDataGenerator(random, db, 2000),
                new ProjectDataGenerator(random, db, 2000),
                new EmployeeProjectRelationDataGenerator(random, db, 2000),
                new ReportDataGenerator(random, db, 250000)
            };

            foreach (var generator in listOfGenerators)
            {
                generator.Generate();
                db.SaveChanges();
            }

            db.Configuration.AutoDetectChangesEnabled = true;
        }
Example #19
0
        public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
        {
            var allEmployees = new List<Employee>();

            for (var i = 0; i < count; i++)
            {
                var employee = new Employee
                {
                    DepartmentId = random.GetRandomNumber(1, data.Departments.Count()),
                    Firstname = random.GetRandomString(random.GetRandomNumber(5, 20)),
                    Lastname = random.GetRandomString(random.GetRandomNumber(5, 20)),
                    Salary = random.GetRandomNumber(50000, 200000)
                };

                if (allEmployees.Any() && random.GetRandomNumber(1, 100) <= 95)
                {
                    employee.Employee1 = allEmployees[random.GetRandomNumber(0, data.Employees.Count() - 1)];
                }

                allEmployees.Add(employee);
            }

            data.Employees.AddRange(allEmployees);
        }
 public void Execute(CompanyEntities data, IRandomGenerator randomGenerator)
 {
     //this.DataGenerator.GenerateData(data, randomGenerator, this.EntriesCount);
 }
Example #21
0
 public void GenerateData(CompanyEntities context, IRandomGenerator random, int count)
 {
 }
Example #22
0
        static void Main(string[] args)
        {
            var random = RandomDataGenerator.Instance;
            var db = new CompanyEntities();
            db.Configuration.AutoDetectChangesEnabled = false;

            Console.WriteLine("\nAdding departments");

            for (int i = 0; i < 100; i++)
            {
                var department = new Department
                {
                    Name = random.GetRandomStringWithRandomLength(10,50)
                };

                db.Departments.Add(department);

                if (i%100 == 0)
                {
                    Console.Write(".");
                    db.SaveChanges();
                }
            }
            db.SaveChanges();
            Console.WriteLine("\nDepartents added");

            Console.WriteLine("\nAdding employees");

            var departmentIds = db.Departments.Select(d => d.Id).ToList();
            for (int i = 0; i < 5000; i++)
            {
              var employee = new Employee
                {
                    FirstName = random.GetRandomStringWithRandomLength(5,20),
                    LastName = random.GetRandomStringWithRandomLength(5,20),
                    DepartmentId = departmentIds[random.GetRandomNumber(0, departmentIds.Count - 1)],
                    YearSalary = random.GetRandomNumber(50000,200000),
                    ManagerId = (i > 250) ? i - 1 :(int?)null // 4750 employees will have a manager (95%) :)
                                                                  // it is very stupid i know but I left it for last and forgot it
                };

              db.Employees.Add(employee);

              if (i % 100 == 0)
              {
                  Console.Write(".");
                  db.SaveChanges();
              }
            }
            db.SaveChanges();
            Console.WriteLine("\nEmployees added");

            Console.WriteLine("\nAdding Projects"); //For some reason it does not want to work
            var employeeIds = db.Employees.Select(e => e.Id).ToList();
            for (int i = 0; i < 1000; i++)
            {
                var project = new Project
                {
                    Name = "Project" + i.ToString(),
                };

                var count = random.GetRandomNumber(5, 20);

                for (int j = 0; j < count; j++)
                {
                    var projectEmployee = new ProjectsEmployee
                    {
                        EmployeeId = employeeIds[i+j],
                        ProjectId = i+1,
                        StartDate = new DateTime(random.GetRandomNumber(1980, 2005), random.GetRandomNumber(1, 12), random.GetRandomNumber(1, 28)),
                        EndDate = new DateTime(random.GetRandomNumber(2005, 2020), random.GetRandomNumber(1, 12), random.GetRandomNumber(1, 28))

                    };

                    project.ProjectsEmployees.Add(projectEmployee);
                }

                db.Projects.Add(project);

                if (i % 100 == 0)
                {
                    Console.Write(".");
                    db.SaveChanges();
                }
            }
            db.SaveChanges();
            Console.WriteLine("\nProjects added");

            Console.WriteLine("\nAdding Reports");
            var employeeIds2 = db.Employees.Select(d => d.Id).ToList();
            for (int i = 0; i < 5000; i++)
            {
                var empId = employeeIds2[i];

                for (int j = 0; j < 50; j++) // every empolyee gets 50 reports
                {
                    var report = new Report
                    {
                        EmployeeId = empId,
                        TimeOfReport = new DateTime(random.GetRandomNumber(1980, 2014), random.GetRandomNumber(1, 12), random.GetRandomNumber(1, 28))
                    };
                    db.Reports.Add(report);
                }
                Console.Write(".");
                db.SaveChanges();

            }
            db.SaveChanges();
            Console.WriteLine("\nReports added");

            db.Configuration.AutoDetectChangesEnabled = true;
        }
Example #23
0
 public ReportsGenerator(CompanyEntities db, RandomData random, int count)
     : base(db, random, count)
 {
 }
 public DepartmentsGenerator(CompanyEntities db, RandomData random, int count)
     : base(db, random, count)
 {
 }
Example #25
0
 public DataGenerator(CompanyEntities db, RandomData random, int count)
 {
     this.db = db;
     this.random = random;
     this.count = count;
 }
 public EmployeesGenerator(CompanyEntities db, RandomData random, int count)
     : base(db, random, count)
 {
 }
 public EmployeeDataGenerator(IRandomDataGenerator randomDataGenerator, CompanyEntities toyStoreEntities, int countOfGeneratedObjects)
     :base(randomDataGenerator, toyStoreEntities, countOfGeneratedObjects)
 {
 }
 public DepartmentDataGenerator(IRandomDataGenerator randomDataGenerator, CompanyEntities companyEntities, int countOfGeneratedObjects, IConsoleLogger consoleLogger)
     : base(randomDataGenerator, companyEntities, countOfGeneratedObjects, consoleLogger)
 {
 }
 public EmployeeGenerator(int count, IRandomDataGenerator random, ILogger logger, CompanyEntities databaseContext, int checkPointFrequency = 1000)
     : base(count, random, logger, checkPointFrequency)
 {
     this.databaseContext = databaseContext;
 }
 public ProjectDataGenerator(IRandomDataGenerator randomDataGenerator, CompanyEntities companyEntities, int countOfGeneratedObjects)
     :base(randomDataGenerator, companyEntities, countOfGeneratedObjects)
 {
 }