public ContactController(ContactContext context)
{
_context = context;
for (int i = 1; i <= 5; i++)
{
if (_context.ContactItems.Count() >= 5)
{
break;
}
_context.ContactItems.Add(new Contact {
Username = $"xx_xx round {i}", Password = "******", Email = $"first_{i}@hotmail.com", FullName = "nope"
});
_context.SaveChangesAsync();
}
}
/// <summary>
/// Method to see the database. Should not be used in production: demo purposes only.
/// </summary>
/// <param name="options">The configured options.</param>
/// <param name="count">The number of contacts to seed.</param>
/// <returns>The <see cref="Task"/>.</returns>
public static async Task EnsureDbCreatedAndSeedWithCountOfAsync(DbContextOptions <ContactContext> options, int count)
{
// empty to avoid logging while inserting (otherwise will flood console)
var factory = new LoggerFactory();
var builder = new DbContextOptionsBuilder <ContactContext>(options)
.UseLoggerFactory(factory);
using var context = new ContactContext(builder.Options);
// result is true if the database had to be created
if (await context.Database.EnsureCreatedAsync())
{
var seed = new SeedContacts();
await seed.SeedDatabaseWithContactCountOfAsync(context, count);
}
}
public CaontactControllerTest()
{
//_logger = logger;
dbContext = MockDBContext.GetMockContext("DBContacts");
var serviceProvider = new ServiceCollection()
.AddLogging()
.BuildServiceProvider();
var factory = serviceProvider.GetService <ILoggerFactory>();
var logger = factory.CreateLogger <ContactsController>();
IContactRepository repository = new ContactRepository(dbContext);
controller = new ContactsController(repository, logger);
}
public void RetrievePrimaryAddress()
{
var dbContext = new ContactContext("SimpleContactMgrDb");
var bugsBunny = (from p in dbContext.Set <Person>()
where p.FirstName == "Bugs" && p.LastName == "Bunny"
select p).FirstOrDefault();
Assert.IsNotNull(bugsBunny);
var primaryAddr = bugsBunny.PrimaryAddress;
Assert.IsNotNull(primaryAddr);
Assert.IsNotNull(primaryAddr.Address);
Assert.AreEqual(primaryAddr.Address.City, "Albuquerque");
}
private static void ReadAll()
{
using (var db = new ContactContext())
{
var records = db.Contacts
.Include(e => e.EmailAddresses)
.Include(p => p.PhoneNumbers)
.ToList();
foreach (var c in records)
{
Console.WriteLine($"{c.FirstName} {c.LastName}");
}
}
}
// PUT api/contact/5
public bool Put(int id, [FromBody] Contact updatedContact)
{
using (var db = new ContactContext())
{
var target = db.Contacts.Where(c => c.Id == updatedContact.Id).FirstOrDefault();
if (target != default(Contact))
{
target.Name = updatedContact.Name;
target.Number = updatedContact.Number;
}
db.SaveChangesAsync();
return(true);
}
return(false);//TODO : Trycatch to this
}
public static ContactContext GetContactDbContext(string dbName)
{
// Create options for DbContext instance
var options = new DbContextOptionsBuilder <ContactContext>()
.UseInMemoryDatabase(databaseName: dbName)
.Options;
// Create instance of DbContext
var dbContext = new ContactContext(options);
// Add entities in memory
dbContextExtensions.Seed(dbContext);
return(dbContext);
}
private async Task PopulateTypes(ContactsQueryOpts m)
{
List <ContactType> l = new List <ContactType>();
var types = await ContactContext.ListTypes();
foreach (var type in types)
{
var t = new ContactType
{
Id = type.ID,
Name = type.TypeName // map it to a more user friendly name later.
};
l.Add(t);
}
m.Types = l.ToArray();
}
public Guid Post([FromBody] WriteContact writeContact)
{
var contact = new Contact
{
Email = writeContact.Email,
Address = writeContact.Address,
Name = writeContact.Name,
PhoneNumber = writeContact.PhoneNumber
};
ContactContext.Add(contact);
ContactContext.SaveChanges();
return(contact.Id);
}
public ActionResult Create(Contact contact)
{
if (!ModelState.IsValid)
{
return(View(contact));
}
using (ContactContext context = new ContactContext())
{
context.Contacts.Add(contact);
context.SaveChanges();
}
return(this.RedirectToAction("List"));
}
private static void Seed(ContactContext context)
{
var customers = new[]
{
new Contacts
{
UUID = Guid.Parse("9f35b48d-cb87-4783-bfdb-21e36012930a"),
Name = "Recai",
Surname = "Cingoz",
Company = "Rega",
}
};
context.Contacts.AddRange(customers);
context.SaveChanges();
}
static void CreateDbIfNotExists(IHost host)
{
using var scope = host.Services.CreateScope();
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <ContactContext>();
ContactContext.Initialize(context);
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred creating the DB.");
}
}
public async Task <bool> RemoveContactInformationToPerson(Guid contactId, CancellationToken cancellationToken)
{
if (contactId == Guid.Empty)
{
throw new ArgumentNullException($"{nameof(RemoveContactInformationToPerson)} contactId must not be null");
}
try
{
ContactContext.ContactInformations.Remove(await ContactContext.ContactInformations.FirstOrDefaultAsync(x => x.ContactId == contactId, cancellationToken));
return(await ContactContext.SaveChangesAsync(cancellationToken) > 0);
}
catch (Exception ex)
{
throw new Exception($"{nameof(RemoveContactInformationToPerson)} : {ex.Message}");
}
}
public ContactController(ContactContext context)
{
_context = context;
if (_context.Contacts.Count() == 0)
{
_context.Contacts.Add(new Contact
{
First_name = "Dro",
Last_name = "Tavarez",
Job_title = "Software Developer",
Phone_number = "978-239-9784",
Email = "*****@*****.**"
});
_context.SaveChanges();
}
}
public void Edit(int id, Contact entity)
{
ContactContext db = new ContactContext();
var con = db.Contact.Find(id);
if (con != null)
{
con.Email = entity.Email;
con.FirstName = entity.FirstName;
con.LastName = entity.LastName;
con.PhoneNumber = entity.PhoneNumber;
con.Status = entity.Status;
db.SaveChanges();
}
}
public ContactController(ContactContext context)
{
_context = context;
if (_context.Contacts.Count() == 0)
{
_context.Contacts.Add(new Contact {
Name = "Joe Gledhill",
Address = "1230 SE 3rd Ave",
City = "Canby",
State = "OR",
Zip = "97013",
Email = "*****@*****.**"
});
_context.SaveChanges();
}
}
public async Task <ActionResult> Contacts_Create(Contact model)
{
using (var contactsDB = new ContactContext())
{
var contact = new Contact
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
Company = model.Company,
PhoneNumber = model.PhoneNumber,
SubmittedDate = DateTime.UtcNow,
};
contactsDB.Contacts.Add(contact);
await contactsDB.SaveChangesAsync();
}
return(Json(model));
}
public async Task <bool> AddContactInformationToPerson(ContactInformations model, CancellationToken cancellationToken)
{
if (model == null)
{
throw new ArgumentNullException($"{nameof(AddAsync)} entity must not be null");
}
try
{
await ContactContext.ContactInformations.AddAsync(model, cancellationToken);
return(await ContactContext.SaveChangesAsync(cancellationToken) > 0);
}
catch (Exception ex)
{
throw new Exception($"{nameof(model)} could not be saved: {ex.Message}");
}
}
// GET: /Contact/List
public ActionResult List(string searchQuery)
{
IEnumerable <Contact> contacts;
using (ContactContext context = new ContactContext())
{
if (!string.IsNullOrEmpty(searchQuery))
{
contacts = context.SearchContacts(searchQuery).ToList();
}
else
{
contacts = context.Contacts.ToList();
}
}
return(View(contacts));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="dbContext"></param>
public ContactRepository(ContactContext dbContext)
{
_dbContext = dbContext;
if (!_dbContext.Contacts.Any())
{
//Adding in memory cotact object
_dbContext.Contacts.Add(new Contact
{
ContactId = 1,
FirstName = "Sonali",
LastName = "Thakur",
Email = "*****@*****.**",
PhoneNumber = "9823242090",
Status = true
});
Save();
}
}
public void ShouldNotSaveMergedCartUsingPublicApiIfAnonymousCartHasNoCartLines()
{
// Arrange
var currentCart = new Cart {
ShopName = "My", ExternalId = "GUID", Lines = new ReadOnlyCollectionAdapter <CartLine> {
new CartLine {
ExternalCartLineId = "1", Product = new CartProduct {
ProductId = "Audi"
}
}
}
};
var cartAnonymous = new Cart {
ShopName = "My"
};
this.cartServiceProvider.CreateOrResumeCart(Arg.Is <CreateOrResumeCartRequest>(r => r.UserId == "John Carter")).Returns(new CartResult {
Cart = currentCart
});
this.cartServiceProvider.CreateOrResumeCart(Arg.Is <CreateOrResumeCartRequest>(r => r.UserId == ID.Parse(this.contactId).ToString())).Returns(new CartResult {
Cart = cartAnonymous
});
var contactModel = new FakeContact();
contactModel.Id = new ID(this.contactId);
contactModel.Identifiers.Identifier = string.Empty;
var contact = new ContactContext(contactModel);
var tracker = Substitute.For <ITracker>();
tracker.Contact.Returns(contact);
var testCart = new Cart();
// Act
using (new Switcher <ITracker, TrackerSwitcher>(tracker))
{
this.service.MergeCarts(testCart);
}
// Assert
this.cartServiceProvider.DidNotReceive().SaveCart(Arg.Is <SaveCartRequest>(r => r.Cart == currentCart));
}
public async static void Initialize(ContactContext context)
{
if (context.Contacts.Any())
{
return;
}
await context.Contacts.AddAsync(
new Contact
{
Name = "John",
DateOfBirth = DateTime.Now,
Maried = true,
Phone = "380665747859",
Salary = 500
}
);
context.SaveChanges();
}
public async Task <ActionResult> Contacts_Update(Contact models)
{
using (var contactsDB = new ContactContext())
{
var update = contactsDB.Contacts
.Where(c => c.ContactID == models.ContactID)
.SingleOrDefault();
if (update != null)
{
update.FirstName = models.FirstName;
update.LastName = models.LastName;
update.Email = models.Email;
update.Company = models.Company;
update.PhoneNumber = models.PhoneNumber;
await contactsDB.SaveChangesAsync();
}
return(Json(update));
}
}
//Creates Test Contact
public ContactController(ContactContext context)
{
_context = context;
if (_context.Contacts.Count() == 0)
{
_context.Contacts.Add(new Contact
{
FirstName = "Test",
LastName = "Contact",
PhonePersonal = 5555555555,
Email = "*****@*****.**",
Address = "231 N. Pine Grove",
City = "Chicago",
State = "IL"
});
_context.SaveChanges();
}
}
public async Task <ActionResult> Contacts_Read()
{
using (var contactsDB = new ContactContext())
{
var result = await contactsDB.Contacts
.Select(c => new ContactVM
{
ContactID = c.ContactID,
FirstName = c.FirstName,
LastName = c.LastName,
Email = c.Email,
Company = c.Company,
PhoneNumber = c.PhoneNumber,
SubmittedDate = c.SubmittedDate,
})
.OrderByDescending(c => c.SubmittedDate)
.ToListAsync();
return(Json(result, JsonRequestBehavior.AllowGet));
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ContactContext contactContext)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
AutoMapper.Mapper.Initialize(cfg =>
{
cfg.CreateMap <Models.PeopleContact, Dtos.PeopleContactPutDto>();
cfg.CreateMap <Models.PeopleContact, Dtos.PeopleContactDto>()
.ForMember(dst => dst.Gender, opts => opts.MapFrom(src => src.Gender == Models.Gender.Male ? "Male" : "Female"));
cfg.CreateMap <Dtos.PeopleContactPostDto, Models.PeopleContact>();
cfg.CreateMap <Dtos.PeopleContactPutDto, Models.PeopleContact>();
});
contactContext.Initializer();
app.UseMvc();
}
public void AddAddressToExistingPerson()
{
// Create new address
var dbContext = new ContactContext("SimpleContactMgrDb");
var daffyDuck = (from p in dbContext.Set <Person>()
where p.FirstName == "Daffy" && p.LastName == "Duck"
select p).FirstOrDefault();
Assert.IsNotNull(daffyDuck);
daffyDuck.PersonAddresses.Add(new PersonAddress()
{
Person = daffyDuck,
AddressType = AddressTypes.Home,
Address = new Address()
{
AddrLine1 = "123 Nowhere Lane",
City = "Nowhere",
State = "UT",
ZipCode = "00001"
}
});
dbContext.SaveChanges();
// Load into new DB context and verify
var dbContext2 = new ContactContext("SimpleContactMgrDb");
var daffyDuck2 = (from p in dbContext.Set <Person>()
where p.FirstName == "Daffy" && p.LastName == "Duck"
select p).FirstOrDefault();
Assert.IsNotNull(daffyDuck2);
var nowhereLane = (from addr in daffyDuck2.PersonAddresses
where addr.AddressType == AddressTypes.Home
select addr).FirstOrDefault();
Assert.IsNotNull(nowhereLane);
Assert.AreEqual(nowhereLane.Address.AddrLine1, "123 Nowhere Lane");
Assert.AreEqual(nowhereLane.Address.State, "UT");
}
public void AddDupAddressType()
{
var dbContext = new ContactContext("SimpleContactMgrDb");
var bugsBunny = (from p in dbContext.Set <Person>()
where p.FirstName == "Bugs" && p.LastName == "Bunny"
select p).FirstOrDefault();
Assert.IsNotNull(bugsBunny);
bugsBunny.PersonAddresses.Add(new PersonAddress()
{
Person = bugsBunny,
AddressType = AddressTypes.Office,
Address = new Address()
{
AddrLine1 = "123 Nowhere Lane",
ZipCode = "78148"
}
});
dbContext.SaveChanges();
}
/* The database context is injected in the controller
* using dependency injection
*/
public ContactController(ContactContext context)
{
//This context is used for all operations on the database
_context = context;
/*if there exist no elements in the db
* three new contacts are added to the db
*/
if (_context.ContactItems.Count() == 0)
{
_context.ContactItems.Add(new ContactItem {
Name = "John", Email = "*****@*****.**", Number = "9876543210"
});
_context.ContactItems.Add(new ContactItem {
Name = "Jane", Email = "*****@*****.**", Number = "6173838383"
});
_context.ContactItems.Add(new ContactItem {
Name = "Jack", Email = "*****@*****.**", Number = "8578339399"
});
_context.SaveChanges();
}
}
public async Task <bool> DeleteContacts(int empId)
{
try
{
using (var ctx = new ContactContext())
{
var values = ctx.Contact.Where(c => c.Id == empId).FirstOrDefault();
if (values == null)
{
return(false);
}
ctx.Contact.Remove(values);
await ctx.SaveChangesAsync();
return(true);
}
}
catch (Exception)
{
return(false);
}
}
public MessagesRepository()
{
_db = new ContactContext();
}
public static void RunExample()
{
//select all records in database
// ### Add a db record
ContactContext c = new ContactContext();
c.Configuration.ValidateOnSaveEnabled = false;
Contact myC = new Contact
{
FirstName = "dsdf",
SecondName = "Said",
TelNumber = "1234",
};
Address myAddress = new Address
{
address1 = "ABC",
address2 = "DEF",
};
Contact myC2 = new Contact
{
FirstName = "dsdf2",
SecondName = "Said2",
TelNumber = "12342",
};
Address myAddress1 = new Address
{
address1 = "ABC2",
address2 = "DEF2",
};
Address myAddress2 = new Address
{
address1 = "ABC3",
address2 = "DEF3",
};
c.myContact.Add(myC);
c.myContact.Add(myC2);
myC2.addresses.Add(myAddress1);
myC2.addresses.Add(myAddress2);
myC.addresses.Add(myAddress);
c.SaveChanges();
//selecting top 2 using Take keyword
var contacts = (from a in c.myContact
// where a.FirstName.StartsWith("G")
orderby a.Id
select a);
// Contact myC = contacts.ToList<Contact>().Find(c => c.Id == 5);
// Console.WriteLine("Test " + myC.Id + " " + myC.FirstName);
foreach (var con in contacts)
{
Console.WriteLine(con.Id + " " + con.FirstName + " " + con.SecondName + " " + con.TelNumber);
foreach (Address a in con.addresses)
{
Console.WriteLine(a.address1 + " " + a.address2);
}
/*
if (c.Id==4)
{
context.myContact.Remove(c);
}*/
}
c.SaveChanges();
contacts = from a in c.myContact
// where a.FirstName.StartsWith("G")
orderby a.FirstName
select a;
foreach (var con in contacts)
{
con.FirstName = con.FirstName + " Updated";
}
c.SaveChanges();
}
public ContactContext contact() {
ContactContext _localctx = new ContactContext(Context, State);
EnterRule(_localctx, 154, RULE_contact);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 1695; k_contact();
State = 1699;
ErrorHandler.Sync(this);
_la = TokenStream.La(1);
while (_la==SCOL) {
{
{
State = 1696; contparam();
}
}
State = 1701;
ErrorHandler.Sync(this);
_la = TokenStream.La(1);
}
State = 1702; Match(COL);
State = 1703; text();
State = 1704; Match(CRLF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return _localctx;
}
public AddressUnitOfWork()
{
_context = new ContactContext();
SetContext(_context);
}
public ContactUnitOfWork()
{
_context = new ContactContext();
SetContext(_context);
}
