public string Execute(EmployeesDbContext context, string[] args)
{
int employeeId = int.Parse(args[0]);
Employee employee = context.Employees.Find(employeeId);
if (employee == null)
{
return($"No employee with ID {employeeId} found");
}
StringBuilder sb = new StringBuilder();
sb.AppendLine($"ID: {employeeId} - {employee.FirstName} {employee.LastName} - ${employee.Salary}");
string birthday =
employee.Birthday?.ToString("dd-MM-yyyy", CultureInfo.InvariantCulture)
?? "N/A";
sb.AppendLine($"Birthday: {birthday}");
string address = employee.Address ?? "N/A";
sb.AppendLine($"Address: {address}");
return(sb.ToString());
}
private static void Seed(EmployeesDbContext context)
{
var employee1 = new Employee {
Name = "Pesho"
};
var employee2 = new Employee {
Name = "Ivan"
};
var employee3 = new Employee {
Name = "Maria"
};
var itDepartment = new Department {
Name = "IT"
};
var financeDepartment = new Department {
Name = "Finance"
};
itDepartment.Employees.Add(employee1);
itDepartment.Employees.Add(employee2);
financeDepartment.Employees.Add(employee3);
context.Departments.Add(itDepartment);
context.Departments.Add(financeDepartment);
context.SaveChanges();
Console.WriteLine("Database EmployeesDb created.");
}
private static void InitializeDatabase(EmployeesDbContext context)
{
Console.WriteLine("Initializing database...");
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
}
public string Execute(EmployeesDbContext context, string[] args)
{
int managerId = int.Parse(args[0]);
Employee manager = context.Employees
.Include(e => e.ManagedEmployees)
.FirstOrDefault(e => e.Id == managerId);
if (manager == null)
{
return($"No manager with ID {managerId} found");
}
ManagerDto managerDto = Mapper.Map <ManagerDto>(manager);
StringBuilder sb = new StringBuilder();
sb.AppendLine(
$"{managerDto.FirstName} {managerDto.LastName} | Employees: {managerDto.ManagedEmployeesCount}");
foreach (var employeeDto in managerDto.ManagedEmployees)
{
sb.AppendLine($" - {employeeDto.FirstName} {employeeDto.LastName} - ${employeeDto.Salary}");
}
return(sb.ToString());
}
public string Execute(EmployeesDbContext context, string[] args)
{
int employeeId = int.Parse(args[0]);
int managerId = int.Parse(args[1]);
Employee employee = context.Employees.Find(employeeId);
if (employee == null)
{
return($"No employee with ID {employeeId} found");
}
Employee manager = context.Employees.Find(managerId);
if (manager == null)
{
return($"No manager with ID {managerId} found");
}
employee.Manager = manager;
context.SaveChanges();
return
($"{manager.FirstName} {manager.LastName} successfully set to manage {employee.FirstName} {employee.LastName}");
}
public static void Main()
{
using (var context = new EmployeesDbContext())
{
InitializeDatabase(context);
Seed(context);
}
}
public static void Main()
{
var context = new EmployeesDbContext();
Mapper.Initialize(cfg => cfg.CreateMap <Employee, EmployeeDto>());
var employee = context.Employees.FirstOrDefault();
var employeeDto = Mapper.Map <EmployeeDto>(employee);
}
public void Initiate()
{
EmployeesDbContext employeesDbContext = new EmployeesDbContext("EmployeeConnectionString");
EmployeeRepository employeeRepository = new EmployeeRepository(employeesDbContext);
_employeeService = new EmployeeService(employeeRepository, _logger);
AddEmployees(employeesDbContext);
}
static void Main(string[] args)
{
var context = new EmployeesDbContext();
//var employees = new[]
//{
// new Employee{FirstName="GIvan", LastName="petrov", Salary=6788.98m },
// new Employee{FirstName="Vpetkan", LastName="Ivanov", Salary=1988.98m },
// new Employee{FirstName="Dragan", LastName="stefanof", Salary=2673.98m },
// new Employee{FirstName="Maria", LastName="Manolova", Salary=3788.98m },
// new Employee{FirstName="Ivanka", LastName="Petrova", Salary=63488.98m },
// new Employee{FirstName="Draganka", LastName="georgieva", Salary=67883.8m },
//};
//context.Employees.AddRange(employees);
//context.SaveChanges();
////Native SQL Queries - All comulns have to be included, JOINS cannot be used
//var query=@"SELECT TOP(2) id,FirstName, LAstName, Salary FROM Employees";
//var employees = context
// .Employees
// .FromSql(query)
// .ToArray();
//Console.WriteLine(employees.Count());
//// Execute procedures
//var query = @"EXEC usp_UpdateSalary {0}, {1}"; //{} params
//var result = context.Database.ExecuteSqlCommand(query,1,5000);
//Console.WriteLine(result);
//Bulk opperations - Z.EntityFramework.Plus.EFCore
//var result = context.Employees.Where(e => e.Salary < 7000).Delete();
//This si from Z.EF.Plus Can be achieved with RemoveRange from LINQ but it is slower
//EF Core update
//var employees = context.
// Employees
// .Where(e => e.Salary < 3000);
//foreach (var employee in employees)
//{
// employee.Salary += 200;
//}
//Bulk update
context.Employees
.Where(e => e.Salary < 3000)
.Update(e => new Employee()
{
Salary = e.Salary + 2000m
});
context.SaveChanges();
}
private static void ResetDatabase()
{
using (var db = new EmployeesDbContext())
{
db.Database.EnsureDeleted();
db.Database.EnsureCreated();
SeedDb(db);
Console.WriteLine("Database Initialized");
}
}
public EmployeesController(IConfiguration configuration)
{
var optionsBuilder = new DbContextOptionsBuilder <EmployeesDbContext>();
var connectionString = configuration["ConnectionStrings:EmployeesDBConnectionString"];
optionsBuilder.UseSqlServer(connectionString);
_employeesDbContext = new EmployeesDbContext(optionsBuilder.Options);
}
public InMemoryDbTest()
{
var dbInstanceName = Guid.NewGuid().ToString();
var dbContextOptions = new DbContextOptionsBuilder <EmployeesDbContext>()
.UseInMemoryDatabase(dbInstanceName)
.Options;
DbContext = new EmployeesDbContext(dbContextOptions);
DbContext.Database.EnsureDeleted();
}
private static void AddEmployees(EmployeesDbContext employeesDbContext)
{
//Arrange
employeesDbContext.Employees.AddOrUpdate(c => c.IdNo, new Employee("Ahmed", "Dev", "111", DateTime.Today.AddYears(-30)));
employeesDbContext.Employees.AddOrUpdate(c => c.IdNo, new Employee("Mohamed", "Dev", "112", DateTime.Today.AddYears(-30)));
employeesDbContext.Employees.AddOrUpdate(c => c.IdNo, new Employee("Ali", "Dev", "123", DateTime.Today.AddYears(-30)));
employeesDbContext.Employees.AddOrUpdate(c => c.IdNo
, new Employee("Mahmoud", "Dev", "124", DateTime.Today.AddYears(-30)));
employeesDbContext.SaveChanges();
}
public static void Main()
{
Mapper.Initialize(cfg => cfg.AddProfile <EmployeesProfile>());
using (var context = new EmployeesDbContext())
{
context.Database.Migrate();
var engine = new Engine(context);
engine.StartInterpretingCommands();
}
}
public string Execute(EmployeesDbContext context, string[] args)
{
int employeeId = int.Parse(args[0]);
Employee employee = context.Employees.Find(employeeId);
if (employee == null)
{
return($"No employee with ID {employeeId} found");
}
var employeeDto = Mapper.Map <EmployeeDto>(employee);
return($"ID: {employeeId} - {employeeDto.FirstName} {employeeDto.LastName} - ${employeeDto.Salary}");
}
private static void PrintCompanyEmployeesWithSetSessionContextInInterceptor()
{
Console.WriteLine($"Employees of company with unknown id (it's being set in interceptor)");
using (var ctx = new EmployeesDbContext())
{
var employees = ctx.Employees.AsNoTracking().ToList();
foreach (var employee in employees)
{
Console.WriteLine(employee.ToString());
}
}
Console.WriteLine("---");
}
private static void PrintCompanyEmployeesWithSetSessionContextOnDbConnectionOpened(ICompany company)
{
Console.WriteLine($"Employees of company with id {company.Id}:");
using (var ctx = new EmployeesDbContext(company: company, parameterToChangeMethodSignature: true))
{
var employees = ctx.Employees.AsNoTracking().ToList();
foreach (var employee in employees)
{
Console.WriteLine(employee.ToString());
}
}
Console.WriteLine("---");
}
private static void PrintCompanyEmployeesWithSetSessionContextInCtor(ICompany company)
{
Console.WriteLine($"Employees of company with id {company.Id}:");
using (var ctx = new EmployeesDbContext(company))
{
var employees = ctx.Employees.AsNoTracking().ToList();
foreach (var employee in employees)
{
Console.WriteLine(employee.ToString());
}
}
Console.WriteLine("---");
}
public string Execute(EmployeesDbContext context, string[] args)
{
EmployeeDto employeeDto = new EmployeeDto
{
FirstName = args[0],
LastName = args[1],
Salary = decimal.Parse(args[2])
};
var employee = Mapper.Map <Employee>(employeeDto);
context.Employees.Add(employee);
context.SaveChanges();
return("Employee successfully added");
}
static void Main(string[] args)
{
using (var db = new EmployeesDbContext(new DbContextOptions <EmployeesDbContext>()))
{
// Loading The Item from DB
IEnumerable <Employee> enumerableEmployess = db.Employees.Take(3);
// Using Memory to get the data
enumerableEmployess = enumerableEmployess.Take(2);
Console.WriteLine(JsonSerializer.Serialize(enumerableEmployess));
}
using (var db = new EmployeesDbContext(new DbContextOptions <EmployeesDbContext>()))
{
IQueryable <Employee> queryableEmployess = db.Employees.Take(3);
queryableEmployess = queryableEmployess.Take(2);
Console.WriteLine(JsonSerializer.Serialize(queryableEmployess));
}
}
public string Execute(EmployeesDbContext context, string[] args)
{
int employeeId = int.Parse(args[0]);
DateTime date = DateTime.ParseExact(args[1], "dd-MM-yyyy", CultureInfo.InvariantCulture);
Employee employee = context.Employees.Find(employeeId);
if (employee == null)
{
return($"No employee with ID {employeeId} found");
}
employee.Birthday = date;
context.SaveChanges();
return($"Birthday of employee {employee.FirstName} {employee.LastName} updated successfully");
}
public string Execute(EmployeesDbContext context, string[] args)
{
int employeeId = int.Parse(args[0]);
string address = string.Join(' ', args.Skip(1));
Employee employee = context.Employees.Find(employeeId);
if (employee == null)
{
return($"No employee with ID {employeeId} found");
}
employee.Address = address;
context.SaveChanges();
return($"Address of employee {employee.FirstName} {employee.LastName} updated successfully");
}
private static void SeedDb(EmployeesDbContext db)
{
db.AddRange(new List <Employee>
{
new Employee
{
FirstName = "Mickey",
LastName = "Mouse",
Address = "Disneyland",
Salary = 5000,
Birthday = new DateTime(1986, 7, 25)
},
new Employee
{
FirstName = "Donald",
LastName = "Duck",
Address = "Disneyland",
Salary = 6000,
Birthday = new DateTime(1984, 4, 15),
ManagerId = 1
},
new Employee
{
FirstName = "Minnnie",
LastName = "Mouse",
Address = "Disneyland",
Salary = 15000,
Birthday = new DateTime(1986, 1, 1),
ManagerId = 1
},
new Employee
{
FirstName = "Pluto",
LastName = "n/a",
Address = "Disneyland",
Salary = 1000,
Birthday = new DateTime(1987, 10, 10)
}
});
db.SaveChanges();
}
public string Execute(EmployeesDbContext context, string[] args)
{
int age = int.Parse(args[0]);
var employees = context.Employees
.Where(e => e.Birthday.HasValue && e.Birthday.Value.AddYears(age) <= DateTime.Now)
.OrderByDescending(e => e.Salary)
.ProjectTo <EmployeeOlderThanDto>()
.ToArray();
StringBuilder sb = new StringBuilder();
foreach (var employee in employees)
{
var manager = employee.Manager;
var managerStr = manager == null ? "[no manager]" : $"{manager.FirstName} {manager.LastName}";
sb.AppendLine($"{employee.FirstName} {employee.LastName} - ${employee.Salary} - Manager: {managerStr}");
}
return(sb.ToString());
}
public ManagerCommands(EmployeesDbContext context, IMapper mapper)
{
this.context = context;
this.mapper = mapper;
}
public YearSalariesController(EmployeesDbContext context)
{
_context = context;
}
public static async Task <EmployeeViewModel> CreateViewModelAsync(EmployeesDbContext context, int id) => new EmployeeViewModel(await context.Employees.FirstAsync(e => e.Id == id));
public ParserController(EmployeesDbContext context, IParser parser, ILogger <ParserController> logger)
{
_context = context;
_parser = parser;
_logger = logger;
}
public EmployeeController(EmployeesDbContext context, IMapper mapper)
{
this.context = context;
this.mapper = mapper;
}
public DepartmentsController(EmployeesDbContext context)
{
_context = context;
}
