public void IntsToEntities()
{
WindsorRegistrar.RegisterSingleton(typeof(IUniRepo), typeof(UniRepo));
WindsorRegistrar.RegisterSingleton(typeof(IDbContextFactory), typeof(DbContextFactory));
using (var scope = new TransactionScope())
{
var repo = new Repo <Meal>(new DbContextFactory());
var meal1 = new Meal {
Name = "a"
};
var meal2 = new Meal {
Name = "b"
};
meal1 = repo.Add(meal1);
meal2 = repo.Add(meal2);
repo.Save();
var dinnerInput = new DinnerInput {
Meals = new int[] { meal1.Id, meal2.Id }
};
var dinner = new Dinner();
dinner.InjectFrom <IntsToEntities>(dinnerInput);
Assert.IsNotNull(dinner.Meals);
Assert.AreEqual(2, dinner.Meals.Count);
Assert.AreEqual(meal1.Id, dinner.Meals.First().Id);
}
}
public static void AddMember(Member member)
{
if (useStub())
{
getMemberDbStub().Add(member);
return;
}
repo.Add <Member>(member);
}
public static void AddStore(Store e)
{
if (useStub())
{
getDbStub().Add(e);
return;
}
repo.Add <Store>(e);
}
public IFoo CreateFoo(Repo repo)
{
var foo = new FooBar();
repo.Add(foo);
return(foo);
}
public void Commit_SingleChangeset_OutputsThatChangeset()
{
if (IsUsingPersistentClient)
{
Assert.Inconclusive("Hook tests does not function correctly under the persistent client");
return;
}
Repo.Init();
Repo.SetHook("commit");
File.WriteAllText(Path.Combine(Repo.Path, "test.txt"), "dummy");
Repo.Add("test.txt");
var command = new CustomCommand("commit")
.WithAdditionalArgument("-m")
.WithAdditionalArgument("dummy");
Repo.Execute(command);
var tipHash = Repo.Tip().Hash;
Assert.That(command.RawExitCode, Is.EqualTo(0));
Assert.That(command.RawStandardOutput, Is.StringContaining("LeftParentRevision:0000000000000000000000000000000000000000"));
Assert.That(command.RawStandardOutput, Is.StringContaining("RightParentRevision:" + Environment.NewLine));
Assert.That(command.RawStandardOutput, Is.StringContaining("CommittedRevision:" + tipHash));
}
/// <summary>
/// Fügt die Liste der Vorgänge dem Repository hinzu.
/// </summary>
/// <param name="Vorgaenge">Liste der hinzuzufügenden Objekte.</param>
private void ProcessInputVorgaenge(List <Vorgang> Vorgaenge)
{
foreach (var v in Vorgaenge)
{
Repo.Add(v);
}
}
public void Add(Order order)
{
repo.Add(order);
repo.Save();
var orderItems = order.OrderItem.ToList();
for (int i = 0; i < orderItems.Count; i++)
{
OrderItem orderItem = new OrderItem()
{
ItemSizeId = orderItems[i].ItemSizeId, MenuItemId = orderItems[i].MenuItemId, OrderId = order.Id, Quantity = orderItems[i].Quantity
};
repo.DbContext.OrderItem.Add(orderItem);
repo.DbContext.SaveChanges();
foreach (var orderItemAddon in orderItems[i].OrderItemAddon)
{
repo.DbContext.OrderItemAddon.Add(new OrderItemAddon()
{
AddonId = orderItemAddon.AddonId, OrderItemId = orderItem.Id, ItemSizeId = orderItemAddon.ItemSizeId
});
}
repo.DbContext.SaveChanges();
}
}
private static void AddAndCommit(Repo repo, object value)
{
CommitValue commitValue = CreateCommitValue(value);
repo.Add(commitValue);
repo.Commit();
}
public override void SetUp()
{
base.SetUp();
Repo.Init();
File.WriteAllText(Path.Combine(Repo.Path, "dummy.txt"), "dummy");
Repo.Add("dummy.txt");
}
public ActionResult Create(FormCollection collection)
{
// TODO: Add insert logic here
var v = new Contractor();
UpdateModel(v);
Repo.Add(v);
return(RedirectToAction("Index"));
}
private void btnEkle_Click(object sender, EventArgs e)
{
Departman departman = new Departman(txtAdi.Text, txtAciklama.Text);
DepartmanDepo.Add(departman);
dgvDepartmanlar.DataSource = DepartmanDepo.SelectAll();
txtAdi.Text = null;
txtAciklama.Text = null;
}
public void Remove_UncommittedFile_ThrowsMercurialExecutionException()
{
if (ClientExecutable.GetVersion() < new Version(1, 7, 0, 0))
{
Assert.Ignore("This is not reported as a problem in Mercurial <1.7");
}
Repo.Init();
File.WriteAllText(Path.Combine(Repo.Path, "test.txt"), "contents");
Repo.Add("test.txt");
Assert.Throws <MercurialExecutionException>(() => Repo.Remove("test.txt"));
}
public Request CreateRequest(Request request, RequestTypes requestType)
{
request.CreatedUtc = DateTime.UtcNow;
request.LastModifiedUtc = DateTime.UtcNow;
request.Status = (int)RequestStatus.New;
request.RequestType = (int)requestType;
Repo.Add <Request>(request);
Repo.SaveChanges();
return(request);
}
public Phrase Add(Phrase item)
{
if (item.IsValid())
{
var model = Mapper.Map <Data.Phrase>(item);
var result = Repo.Add(model);
return(Mapper.Map <Phrase>(result));
}
return(item);
}
public void Add(Password entity)
{
if (useStub())
{
DataAccessDriver.Passwords.GetList().Add(entity);
}
else
{
repo.Add <Password>(entity);
//return passwordObjList;
}
}
public virtual IActionResult Create(TViewModel item)
{
if (item == null)
{
return(BadRequest());
}
TDataModel entry = Repo.Add(Mapper.Map <TViewModel, TDataModel>(item));
item = Mapper.Map <TDataModel, TViewModel>(entry);
return(CreatedAtRoute(RouteNameGet, new { id = item.Id }, item));
}
public void TestInsert()
{
var repo = new Repo <Country>(new DbContextFactory());
var country = new Country {
Name = "testCountry"
};
country = repo.Add(country);
repo.Save();
var country1 = repo.Get(country.Id);
Assert.AreEqual(country.Name, country1.Name);
}
public void Add_ExistingFile_AddsItToTheRepository()
{
Repo.Init();
File.WriteAllText(Path.Combine(Repo.Path, "test.txt"), "contents");
Repo.Add("test.txt");
FileStatus[] status = Repo.Status().ToArray();
CollectionAssert.AreEqual(
status, new[]
{
new FileStatus(FileState.Added, "test.txt"),
});
}
public ActionResult Create(Product v)
{
try
{
Repo.Add(v);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public virtual async Task <IActionResult> Add([FromBody] TVm vm)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var e = Mapper.Map <TE>(vm);
e = await Repo.Add(e);
vm = Mapper.Map <TVm>(e);
return(Ok(vm));
}
public void Add_ExistingFileWithUnicodeCharacterInName_AddsItToTheRepository(string filename)
{
Repo.Init();
PrepareMercurialConfig(Repo.Path);
File.WriteAllText(Path.Combine(Repo.Path, filename), "contents");
Repo.Add(filename);
FileStatus[] status = Repo.Status().ToArray();
CollectionAssert.AreEqual(
status, new[]
{
new FileStatus(FileState.Added, filename),
});
}
public Dto.ProfileDto Add(string name, string description)
{
var profile = new Domain.Profile()
{
Name = name,
Key = Guid.NewGuid(),
Description = description,
};
var result = Repo.Add(profile);
Repo.Complete();
return(MapToDto(result));
}
public override async Task <IActionResult> Add(ProductViewModel vm)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var e = Mapper.Map <ProductEntity>(vm);
e.Seller = CurrentSellerProfile;
e = await Repo.Add(e);
vm = Mapper.Map <ProductViewModel>(e);
return(Ok(vm));
}
private void btnKayit_Click(object sender, EventArgs e)
{
//Nesne Oluşturma
Personel personel = new Personel(txtAdi.Text, txtSoyadi.Text, mtxtTc.Text, Convert.ToInt32(mtxtYas.Text), Convert.ToInt32(mtxtMaas.Text), cbDepartmanAdi.SelectedIndex + 1);
PersonelDepo.Add(personel);
dataGridView1.DataSource = PersonelDepo.SelectAll();
//Textboxları temizleme
txtAdi.Clear();
txtSoyadi.Clear();
mtxtTc.Clear();
mtxtYas.Clear();
mtxtMaas.Clear();
}
public async Task <ActionResult <ModelResponse <JudgeFormModel> > > Create([FromBody] JudgeCreateNewFormModel fm)
{
var userManager = ServiceProvider.GetRequiredService <UserManager <User> >();
var user = await ServiceProvider.GetRepo <User>()
.GetOne(u => u.NormalizedEmail == fm.Email.ToUpper());
if (user == null)
{
user = new User {
UserName = fm.Email, Email = fm.Email
};
var result = await userManager.CreateAsync(user);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await ServiceProvider.GetRequiredService <AuthService>().SendActivationEmail(user, Url, Request.Scheme);
}
if (await Repo.Any(j => j.User == user))
{
return(BadRequest($"This user is already a judge."));
}
if (!await userManager.IsInRoleAsync(user, "Jury"))
{
await userManager.AddToRoleAsync(user, "Jury");
}
var e = new JudgeEntity
{
Category = ServiceProvider.GetRepo <CategoryEntity>()
.Attach(new CategoryEntity {
Id = fm.Category.Id
}),
AvailableFor = fm.AvailableFor,
User = user
};
e = await Repo.Add(e);
var vm = MapF(e);
return(OkModel(vm));
}
public static void TestRemove()
{
var repo = new Repo <Country>(new DbContextFactory());
var country = new Country {
Name = "testCountry"
};
country = repo.Add(country);
repo.Save();
repo.Delete(country);
repo.Save();
var country1 = repo.Get(country.Id);
Assert.IsTrue(country1.IsDeleted);
}
public void Remove_UncommittedFileWithForce_RemovesFile()
{
Repo.Init();
File.WriteAllText(Path.Combine(Repo.Path, "test.txt"), "contents");
Repo.Add("test.txt");
Repo.Remove(
"test.txt", new RemoveCommand
{
ForceRemoval = true,
});
CollectionAssert.AreEqual(
Repo.Status(),
new[]
{
new FileStatus(FileState.Unknown, "test.txt"),
});
}
private void BtneAdd_Click(object sender, EventArgs e)
{
var yeni = AddEntity();
var sonuç = Repo.Kontrolet(yeni);
if (sonuç.Hata)
{
MsgError(sonuç.HataAçıklama, "Hata");
return;
}
Repo.Add(yeni);
if (DbManager.UnitWork.Complete() > 0)
{
addcollection(Main.MainForm.User, yeni);
Msg("Eklendi");
Main.MainForm.Form1_Load(null, null);
}
}
public User CreateUser(User user, UserProfile userProfile, string password, string userRole)
{
WebSecurity.CreateUserAndAccount(user.UserName, password);
var newUser = Repo.Find <User>(u => string.Equals(u.UserName, user.UserName)).Single();
if (null == newUser)
{
throw new InvalidOperationException("User must exist at this point");
}
Repo.Add(userProfile);
newUser.UserProfile = userProfile;
Repo.SaveChanges();
Roles.AddUserToRole(newUser.UserName, userRole);
return(newUser);
}
//=================================================================
//1. Add a new user. The AppUserId is zero by default.
//2. Update an existing user. The AppUserId is derived from the database
// and is not changed either by the application user or anywhere within the code.
// However, if an invalid AppUserId is submitted the condition is tested.
//
public vmAppUser PostUser(vmAppUser vmAU)
{
AppUser newUser = new AppUser
{
AppUserId = vmAU.AppUserId,
UserName = vmAU.UserName,
PassWord = vmAU.PassWord,
LastName = vmAU.LastName,
FirstName = vmAU.FirstName,
City = vmAU.City,
State = vmAU.State,
PostalCode = vmAU.PostalCode,
Email = vmAU.Email,
IsMusician = vmAU.IsMusician,
ReceiveAdvertisements = vmAU.ReceiveAdvertisements
};
if (newUser.AppUserId == 0)
{
_repo.Add(newUser);
}
else
{
_repo.Update(newUser);
}
vmAppUser returnUser = new vmAppUser
{
AppUserId = newUser.AppUserId,
UserName = newUser.UserName,
PassWord = newUser.PassWord,
LastName = newUser.LastName,
FirstName = newUser.FirstName,
City = newUser.City,
State = newUser.State,
PostalCode = newUser.PostalCode,
Email = newUser.Email,
IsMusician = newUser.IsMusician,
ReceiveAdvertisements = newUser.ReceiveAdvertisements
};
return(returnUser);
}
