static void Main(string[] args)
{
try
{
ManageDatabase();
using (var ctx = new PersonDBContext())
{
var person = new Person()
{
PersonName = "Rajneesh",
Gender = "Male",
Age = 30
};
ctx.Persons.Add(person);
ctx.SaveChanges();
Console.WriteLine("Added person");
foreach (var p in ctx.Persons.ToList())
{
// Use interpolation in C# 6.0
// This is equavalent to String builter. Mutable string object
Console.WriteLine($"{p.PersonId} {p.PersonName} {p.Age} {p.Gender}");
}
}
}
catch (Exception ex)
{
Console.WriteLine($"{ex.Message}");
}
Console.ReadLine();
}
public ICollection <GenderModel> GetGenders()
{
using (var db = new PersonDBContext())
{
return(db.Gender.ToList().Select(Map).ToList());
}
}
public async Task PersonOperation_ShouldReturnCorrectCountofAllPersons()
{
var dbContext = new PersonDBContext(ContextOptions);
var result = await new CountPersonsService().Execute(dbContext);
Assert.Equal(2, result.Value.NumberOfPersons);
}
public async Task PersonOperation_ShouldReturnAllPersons()
{
var dbContext = new PersonDBContext(ContextOptions);
var result = await new GetPersonsService().Execute(dbContext);
Assert.Equal(2, result.Value.Count());
}
public ICollection <PersonModel> GetPersons()
{
using (var db = new PersonDBContext())
{
return(db.Person.ToList().Select(Map).ToList());
}
}
public ICollection <PhoneTypeModel> GetPhoneTypes()
{
using (var db = new PersonDBContext())
{
return(db.PhoneType.ToList().Select(Map).ToList());
}
}
public ICollection <RelationTypeModel> GetPersonRelationTypes()
{
using (var db = new PersonDBContext())
{
return(db.RelationTypes.ToList().Select(Map).ToList());
}
}
public ICollection <CityModel> GetCities()
{
using (var db = new PersonDBContext())
{
return(db.City.ToList().Select(Map).ToList());
}
}
public async Task <IActionResult> Execute(PersonDBContext _context, Person person)
{
_context.Person.Add(person);
await _context.SaveChangesAsync();
return(new NoContentResult());
}
// This method will make sure that if the database is already available, then delete it
static void ManageDatabase()
{
using (var ctx = new PersonDBContext())
{
ctx.Database.EnsureDeleted();
ctx.Database.EnsureCreated();
}
}
public async Task <ActionResult <PersonCount> > Execute(PersonDBContext _context)
{
var persons = await _context.Person.ToListAsync();
return(new PersonCount {
NumberOfPersons = persons.Count()
});
}
public static Person GetPerson(int id)
{
using (var db = new PersonDBContext())
{
var person = db.People.FirstOrDefault(x => x.Id == id);
return(person);
}
}
public static List <Person> GetPeople()
{
using (var db = new PersonDBContext())
{
var peopleList = db.People.Where(x => x.FirstName != null).ToList();
return(peopleList);
}
}
public void DeleteRelatedPerson(PersonModel person, PersonModel relatedPerson)
{
using (var db = new PersonDBContext())
{
var dbModel =
db.PersonToPerson.Single(a => a.PersonId == person.Id && a.RelatedPersonId == relatedPerson.Id);
db.PersonToPerson.Remove(dbModel);
db.SaveChanges();
}
}
public PersonModel GetPersonById(int id)
{
using (var db = new PersonDBContext())
{
return(db.Person.Include(i => i.PersonToPersonPerson)
.ThenInclude(i => i.RelatedPerson)
.Where(a => a.Id == id).ToList()
.Select(Map).FirstOrDefault());
}
}
public async Task PersonOperation_ShoulDeleteThePersonByIdProvided()
{
var idToDelete = 111;
var id = 112;
var dbContext = new PersonDBContext(ContextOptions);
var result = await new DeletePersonService().Execute(dbContext, idToDelete);
Assert.Empty(dbContext.Person.Where(p => p.Id == idToDelete));
Assert.Single(dbContext.Person.Where(p => p.Id == id));
}
public async Task PersonOperation_ShouldAddAPersonWithProvidedData()
{
var firstName = "FirstName3";
var lastName = "LastName3";
var dbContext = new PersonDBContext(ContextOptions);
var person = new Person(113, firstName, lastName);
var result = await new AddPersonService().Execute(dbContext, person);
Assert.Equal(firstName, dbContext.Person.Single(p => p.Id == 113).FirstName);
Assert.Equal(lastName, dbContext.Person.Single(p => p.Id == 113).LastName);
}
public void AddRelatedPerson(PersonModel person, PersonModel relatedPerson, int relationTypeId)
{
using (var db = new PersonDBContext())
{
var model = new PersonToPerson();
model.PersonId = person.Id;
model.RelatedPersonId = relatedPerson.Id;
model.RelationTypeId = relationTypeId;
db.Add(model);
db.SaveChanges();
}
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
using (var ctx = new PersonDBContext()){
var q = ctx.People.Count();
};
}
private void Seed()
{
var context = new PersonDBContext(ContextOptions);
context.Database.EnsureDeleted();
context.AddRange(
new Person(111, "FirstName1", "LastName1"),
new Person(112, "FirstName1", "LastName2")
);
context.SaveChanges();
}
private static void AddUsers(IList <User> users)
{
foreach (User user in users)
{
using (PersonDBContext fctxt = new PersonDBContext())
{
Console.WriteLine(user.ToString());
fctxt.Users.AddAsync(user);
fctxt.Entry(user).State = EntityState.Added;
fctxt.SaveChangesAsync();
}
}
}
public async Task PersonOperation_ShoulUpdateThePersonWithProvidedData()
{
var newName = "New FirstName";
var dbContext = new PersonDBContext(ContextOptions);
var person = new Person
{
Id = 111,
FirstName = newName
};
var result = await new UpdatePersonService().Execute(dbContext, person);
Assert.Equal(newName, dbContext.Person.Single(p => p.Id == person.Id).FirstName);
}
private static void AddPersons(IList <Person> persons)
{
foreach (Person person in persons)
{
using (PersonDBContext fctxt = new PersonDBContext())
{
Console.WriteLine(person.ToString());
fctxt.Persons.AddAsync(person);
fctxt.Entry(person).State = EntityState.Added;
fctxt.SaveChangesAsync();
}
}
}
public async Task <IActionResult> Execute(PersonDBContext _context, long id)
{
var person = await _context.Person.FindAsync(id);
if (person == null)
{
return(new NotFoundResult());
}
_context.Person.Remove(person);
await _context.SaveChangesAsync();
return(new NoContentResult());
}
public PersonController(PersonDBContext context,
IAddPersonService addPersonService,
IUpdatePersonService updatePersonService,
IDeletePersonService deletePersonService,
ICountePersonsService countePersonsService,
IGetPersonsService getPersonsService)
{
_context = context;
this.addPersonService = addPersonService;
this.updatePersonService = updatePersonService;
this.deletePersonService = deletePersonService;
this.countePersonsService = countePersonsService;
this.getPersonsService = getPersonsService;
}
public void AddPerson(Person person)
{
using var db = new PersonDBContext();
var newPerson = new Person()
{
FirstName = person.FirstName,
LastName = person.LastName,
Position = person.Position,
StartDate = person.StartDate,
DateEnd = person.DateEnd
};
db.People.Add(newPerson);
db.SaveChanges();
}
/// <summary>
/// The perform database operations.
/// </summary>
public static void PerformDatabaseOperations()
{
using (var db = new PersonDBContext())
{
var person = new Person
{
FirstName = "Biju",
LastName = "Joseph",
BirthDate = DateTime.Now
};
db.Persons.Add(person);
db.SaveChanges();
}
}
public void UpdatePerson(PersonModel person)
{
using (var db = new PersonDBContext())
{
var dbModel = db.Person.Single(a => a.Id == person.Id);
dbModel.FirstName = person.FirstName;
dbModel.LastName = person.LastName;
dbModel.PersonalNumber = person.PersonalNumber;
dbModel.GenderiD = person.GenderiD;
dbModel.CityId = person.CityId;
dbModel.BirthDate = person.BirthDate;
dbModel.ImagePath = person.ImagePath ?? dbModel.ImagePath;
db.Update(dbModel);
db.SaveChanges();
}
}
public async Task <IActionResult> Execute(PersonDBContext _context, Person person)
{
_context.Entry(person).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!_context.Person.Any(e => e.Id == person.Id))
{
return(new NotFoundResult());
}
else
{
throw;
}
}
return(new NoContentResult());
}
public int CreatePerson(PersonModel person)
{
using (var db = new PersonDBContext())
{
var model = new Person
{
FirstName = person.FirstName,
LastName = person.LastName,
PersonalNumber = person.PersonalNumber,
GenderiD = person.GenderiD,
CityId = person.CityId,
BirthDate = person.BirthDate,
ImagePath = person.ImagePath
};
db.Add(model);
db.SaveChanges();
return(model.Id);
}
}
