public async Task <IActionResult> Edit(int id, [Bind("EmployeeId,TerritoryId")] EmployeeTerritory employeeTerritory)
{
if (id != employeeTerritory.EmployeeId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(employeeTerritory);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeTerritoryExists(employeeTerritory.EmployeeId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["EmployeeId"] = new SelectList(_context.Employees, "EmployeeId", "FirstName", employeeTerritory.EmployeeId);
ViewData["TerritoryId"] = new SelectList(_context.Territories, "TerritoryId", "TerritoryId", employeeTerritory.TerritoryId);
return(View(employeeTerritory));
}
public ServiceResponse <Employees> UpdateEmployee([FromBody] EmployeeTerritory model)
{
var response = new ServiceResponse <Employees>(HttpContext);
var updateEmployee = _employeesService.Update(model);
return(response);
}
private void CopyEmployeeTerritories(IOdb odb)
{
//Processing EmployeeTerritories
LogMessage("Reading EmployeeTerritories...", false);
var adapter1 = new EmployeeTerritoriesTableAdapter();
var table1 = adapter1.GetData();
LogMessage("processing " + table1.Count.ToString() + " rows", true);
foreach (var row in table1)
{
LogMessage("EmployeeTerritories: " + row.EmployeeID.ToString() + "/" + row.TerritoryID + " ...", false);
var et = new EmployeeTerritory();
LogMessage("linking members...", false);
et.Employee = NDbUtil.GetByNumericalID <Employee>(odb, Employee.PK, row.EmployeeID);
et.Territory = NDbUtil.GetByStringID <Territory>(odb, Territory.PK, row.TerritoryID);
odb.Store(et);
LogMessage("saved (" + et.Employee.EmployeeID.ToString() + "/" + et.Territory.TerritoryID + ")",
true);
}
odb.Commit();
long objectCount = NDbUtil.GetAllInstances <EmployeeTerritory>(odb).Count;
if (table1.Count == objectCount)
{
LogMessage(table1.Count + " objects saved", true);
}
else
{
LogMessage("Error: " + table1.Count + " rows retrieved but " + objectCount + " objects were saved", true);
}
LogMessage("Done with EmployeeTerritories" + Environment.NewLine, true);
}
public static EmployeeTerritoryEntity FromDto(this EmployeeTerritory dto)
{
OnBeforeDtoToEntity(dto);
var entity = new EmployeeTerritoryEntity();
// Map entity properties
entity.EmployeeId = dto.EmployeeId;
entity.TerritoryId = dto.TerritoryId;
// Map entity associations
// n:1 Employee association
if (dto.Employee != null)
{
entity.Employee = dto.Employee.FromDto();
}
// n:1 Territory association
if (dto.Territory != null)
{
entity.Territory = dto.Territory.FromDto();
}
OnAfterDtoToEntity(dto, entity);
return(entity);
}
public EmployeeTerritoryDto Create(EmployeeTerritory employeeTerritory)
{
return(new EmployeeTerritoryDto
{
EmployeeId = employeeTerritory.EmployeeId,
TerritoryId = employeeTerritory.TerritoryId
});
}
public EmployeeTerritory MapData(SqlDataReader reader)
{
EmployeeTerritory et = new EmployeeTerritory();
et.EmployeeID = Convert.ToInt32(reader["EmployeeID"]);
et.TerritoryID = reader["TerritoryID"].ToString();
return(et);
}
public void ShouldMapEmployeeTerritoryToEmployeeTerritoryDto()
{
var entity = new EmployeeTerritory();
var result = _mapper.Map <EmployeeTerritoryDto>(entity);
result.ShouldNotBeNull();
result.ShouldBeOfType <EmployeeTerritoryDto>();
}
protected async void GridDeleteButtonClick(UIMouseEventArgs args, EmployeeTerritory data)
{
var northwindDeleteEmployeeTerritoryResult = await Northwind.DeleteEmployeeTerritory(data.EmployeeID, $"{data.TerritoryID}");
if (northwindDeleteEmployeeTerritoryResult != null)
{
grid0.Reload();
}
}
public void Issue148_TestMode_Field_Should_Not_Be_Included_In_Query()
{
var value = from employees in Employee.All()
join employeeTerritories in EmployeeTerritory.All() on employees.EmployeeID equals employeeTerritories.EmployeeID
join territories in Territory.All() on employeeTerritories.TerritoryID equals territories.TerritoryID
select territories.Region;
Assert.DoesNotContain("TestMode", (value as Query <Region>).QueryText);
}
protected async void Load()
{
var northwindGetEmployeesResult = await Northwind.GetEmployees(null, null, null, null, null, null, null, null);
getEmployeesResult = northwindGetEmployeesResult.Data;
var northwindGetTerritoriesResult = await Northwind.GetTerritories(null, null, null, null, null, null, null, null);
getTerritoriesResult = northwindGetTerritoriesResult.Data;
employeeterritory = new EmployeeTerritory();
}
public async Task <IActionResult> Create([Bind("EmployeeId,TerritoryId")] EmployeeTerritory employeeTerritory)
{
if (ModelState.IsValid)
{
_context.Add(employeeTerritory);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["EmployeeId"] = new SelectList(_context.Employees, "EmployeeId", "FirstName", employeeTerritory.EmployeeId);
ViewData["TerritoryId"] = new SelectList(_context.Territories, "TerritoryId", "TerritoryId", employeeTerritory.TerritoryId);
return(View(employeeTerritory));
}
public async Task <EmployeeTerritory> CreateEmployeeTerritory(EmployeeTerritory employeeTerritory)
{
try
{
context.EmployeeTerritories.Add(employeeTerritory);
context.SaveChanges();
}
catch (Exception ex)
{
return(null);
}
return(employeeTerritory);
}
public ServiceResponse <DB.Entities.Employees> Update(EmployeeTerritory employeeTerritory)
{
//Geri dönülecek kayıt
var response = new ServiceResponse <DB.Entities.Employees>(null);
//Güncellenecek kayıt
DB.Entities.Employees employee = _employeesRepository.Table.FirstOrDefault(e => e.EmployeeId == employeeTerritory.EmployeeId);
//Değişen kayıt uyuşan kolonları ile Employees'e dönüştürülür.
DB.Entities.Employees updateModel = _mapper.Map <DB.Entities.Employees>(employeeTerritory);
//Benzer kolonları atanır. Benzemeyen kolonlar null'a çekilir. Ve o alanlar güncellenmez :)
_employeesRepository.UpdateMatchEntity(employee, updateModel);
response.Entity = employee;
return(response);
}
public virtual bool Equals(EmployeeTerritory other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(other.EmployeeId == EmployeeId && Equals(other.TerritoryId, TerritoryId) &&
Equals(other.Employee, Employee) && Equals(other.Territory, Territory));
}
public EmployeeTerritory GetByID(int id)
{
EmployeeTerritory cd = null;
db.Open();
string sql = "SELECT *FROM EmployeeTerritories WHERE EmployeeID='" + id + "'";
db.InitCommand(sql, CommandType.Text);
//db.AddInputParameter(DbType.String, "@Id", id);
SqlDataReader reader = db.ExecuteReader();
if (reader.Read())
{
cd = MapData(reader);
}
db.Close();
return(cd);
}
public IList <EmployeeTerritory> GetAll()
{
List <EmployeeTerritory> cdList = new List <EmployeeTerritory>();
db.Open();
string sql = "SELECT *FROM EmployeeTerritories";
db.InitCommand(sql, CommandType.Text);
SqlDataReader reader = db.ExecuteReader();
while (reader.Read())
{
EmployeeTerritory cd = cd = MapData(reader);
cdList.Add(cd);
}
db.Close();
return(cdList);
}
public void LinqToSqlInsert03()
{
Northwind db = CreateDB();
var ds = new DataLoadOptions();
ds.LoadWith <Employee>(p => p.EmployeeTerritories);
ds.LoadWith <EmployeeTerritory>(p => p.Territory);
db.LoadOptions = ds;
var q = from e in db.Employees where e.FirstName == "Nancy" select e;
if (db.Employees.Any(e => e.FirstName == "Test Kira" && e.LastName == "Test Smith"))
{
Assert.Ignore();
}
var newEmployee = new Employee {
FirstName = "Test Kira", LastName = "Test Smith"
};
var newTerritory = new Territory
{
TerritoryID = "12345",
TerritoryDescription = "Test Anytown",
Region = db.Regions.First()
};
var newEmployeeTerritory = new EmployeeTerritory {
Employee = newEmployee, Territory = newTerritory
};
db.Employees.InsertOnSubmit(newEmployee);
db.Territories.InsertOnSubmit(newTerritory);
db.EmployeeTerritories.InsertOnSubmit(newEmployeeTerritory);
db.SubmitChanges();
// cleanup
db.EmployeeTerritories.DeleteOnSubmit(newEmployeeTerritory);
db.Territories.DeleteOnSubmit(newTerritory);
db.Employees.DeleteOnSubmit(newEmployee);
db.SubmitChanges();
}
public static EmployeeTerritory ToDto(this EmployeeTerritoryEntity entity, Hashtable seenObjects, Hashtable parents)
{
OnBeforeEntityToDto(entity, seenObjects, parents);
var dto = new EmployeeTerritory();
if (entity != null)
{
if (seenObjects == null)
{
seenObjects = new Hashtable();
}
seenObjects[entity] = dto;
parents = new Hashtable(parents)
{
{ entity, null }
};
// Map dto properties
dto.EmployeeId = entity.EmployeeId;
dto.TerritoryId = entity.TerritoryId;
// Map dto associations
// n:1 Employee association
if (entity.Employee != null)
{
dto.Employee = entity.Employee.RelatedObject(seenObjects, parents);
}
// n:1 Territory association
if (entity.Territory != null)
{
dto.Territory = entity.Territory.RelatedObject(seenObjects, parents);
}
}
OnAfterEntityToDto(entity, seenObjects, parents, dto);
return(dto);
}
public void TestEqualityOnCompositeKey()
{
var t1 = new EmployeeTerritory();
t1.Employee = new Employee() { Id = 2 };
t1.Territory = new Territory() { Id = "asd" };
var t2 = new EmployeeTerritory();
t2.Employee = new Employee() { Id = 2 };
t2.Territory = new Territory() { Id = "asd" };
var t3 = new EmployeeTerritory();
t3.Employee = new Employee() { Id = 3 };
t3.Territory = new Territory() { Id = "asd" };
t2.Should().Be(t1);
t1.Should().Be(t2);
t3.Should().Not.Be(t1);
t1.Should().Not.Be(t3);
t3.Should().Not.Be(t2);
t2.Should().Not.Be(t3);
}
// Добавить нового сотрудника, и указать ему список территорий, за которые он несет ответственность.
static void InsertEmployeeWithTerritory()
{
using (var db = new NorthwindDB())
{
var employee = Employee;
var territory = Territory;
var employeeTerritories = new EmployeeTerritory
{
Employee = employee,
Territory = territory
};
employee.EmployeeID = db.InsertWithInt32Identity(employee);
territory.TerritoryID = "11111";
employeeTerritories.EmployeeID = employee.EmployeeID;
employeeTerritories.TerritoryID = territory.TerritoryID;
db.InsertOrReplace(territory);
db.Insert(employeeTerritories);
}
}
public void TestHashCodeOnCompositeKey()
{
var t1 = new EmployeeTerritory();
t1.Employee = new Employee() { Id = 2 };
t1.Territory = new Territory() { Id = "asd" };
var t2 = new EmployeeTerritory();
t2.Employee = new Employee() { Id = 2 };
t2.Territory = new Territory() { Id = "asd" };
var t3 = new EmployeeTerritory();
t3.Employee = new Employee() { Id = 3 };
t3.Territory = new Territory() { Id = "asd" };
t2.GetHashCode().Should().Be(t1.GetHashCode());
t1.GetHashCode().Should().Be(t2.GetHashCode());
t3.GetHashCode().Should().Not.Be(t1.GetHashCode());
t1.GetHashCode().Should().Not.Be(t3.GetHashCode());
t3.GetHashCode().Should().Not.Be(t2.GetHashCode());
t2.GetHashCode().Should().Not.Be(t3.GetHashCode());
}
public static EmployeeTerritory[] RelatedArray(this EntityCollection <EmployeeTerritoryEntity> entities, Hashtable seenObjects, Hashtable parents)
{
if (null == entities)
{
return(null);
}
var arr = new EmployeeTerritory[entities.Count];
var i = 0;
foreach (var entity in entities)
{
if (parents.Contains(entity))
{
// - avoid all cyclic references and return null
// - another option is to 'continue' and just disregard this one entity; however,
// if this is a collection this would lead the client app to believe that other
// items are part of the collection and not the parent item, which is misleading and false
// - it is therefore better to just return null, indicating nothing is being retrieved
// for the property all-together
return(null);
}
}
foreach (var entity in entities)
{
if (seenObjects.Contains(entity))
{
arr[i++] = seenObjects[entity] as EmployeeTerritory;
}
else
{
arr[i++] = entity.ToDto(seenObjects, parents);
}
}
return(arr);
}
/// <summary>
/// There are no comments for EmployeeTerritories in the schema.
/// </summary>
public void AddToEmployeeTerritories(EmployeeTerritory employeeTerritory)
{
base.AddObject("EmployeeTerritories", employeeTerritory);
}
public void LinqToSqlInsert03()
{
Northwind db = CreateDB();
var ds = new System.Data.Linq.DataLoadOptions();
ds.LoadWith<Employee>(p => p.EmployeeTerritories);
ds.LoadWith<EmployeeTerritory>(p => p.Territory);
db.LoadOptions = ds;
var q = from e in db.Employees where e.FirstName == "Nancy" select e;
if (db.Employees.Any(e => e.FirstName == "Kira" && e.LastName == "Smith"))
Assert.Ignore();
var newEmployee = new Employee { FirstName = "Kira", LastName = "Smith" };
var newTerritory = new Territory
{
TerritoryID = "12345",
TerritoryDescription = "Anytown",
Region = db.Regions.First()
};
var newEmployeeTerritory = new EmployeeTerritory { Employee = newEmployee, Territory = newTerritory };
db.Employees.InsertOnSubmit(newEmployee);
db.Territories.InsertOnSubmit(newTerritory);
db.EmployeeTerritories.InsertOnSubmit(newEmployeeTerritory);
db.SubmitChanges();
}
public void TestToStringOnCompositeKey()
{
var t1 = new EmployeeTerritory();
t1.Employee = new Employee() { Id = 2 };
t1.Territory = new Territory() { Id = "asd" };
var t2 = new EmployeeTerritory();
t2.Employee = new Employee() { Id = 2 };
t2.Territory = new Territory() { Id = "asd" };
var t3 = new EmployeeTerritory();
t3.Employee = new Employee() { Id = 3 };
t3.Territory = new Territory() { Id = "asd" };
t1.ToString().Should().Be("(Employee=(Id=2) | Territory=(Id=asd))");
t2.ToString().Should().Be("(Employee=(Id=2) | Territory=(Id=asd))");
t3.ToString().Should().Be("(Employee=(Id=3) | Territory=(Id=asd))");
}
/// <summary>
/// Create a new EmployeeTerritory object.
/// </summary>
/// <param name="employeeTerritoryID">Initial value of EmployeeTerritoryID.</param>
public static EmployeeTerritory CreateEmployeeTerritory(string employeeTerritoryID)
{
EmployeeTerritory employeeTerritory = new EmployeeTerritory();
employeeTerritory.EmployeeTerritoryID = employeeTerritoryID;
return employeeTerritory;
}
static partial void OnBeforeDtoToEntity(EmployeeTerritory dto);
static partial void OnAfterDtoToEntity(EmployeeTerritory dto, EmployeeTerritoryEntity entity);
public void DeleteEmployeeTerritory(EmployeeTerritory employeeTerritory)
{
this.DataContext.EmployeeTerritories.Attach(employeeTerritory);
this.DataContext.EmployeeTerritories.DeleteOnSubmit(employeeTerritory);
}
public async Task UpdateAsync(EmployeeTerritory entity)
{
var cancelToken = new CancellationTokenSource();
await _employeeTerritoryDal.UpdateAsync(entity, cancelToken.Token);
}
public void InsertEmployeeTerritory(EmployeeTerritory employeeTerritory)
{
this.DataContext.EmployeeTerritories.InsertOnSubmit(employeeTerritory);
}
protected async void Grid0RowSelect(EmployeeTerritory args)
{
var result = await DialogService.OpenAsync <EditEmployeeTerritory>("Edit Employee Territory", new Dictionary <string, object>() { { "EmployeeID", $"{args.EmployeeID}" }, { "TerritoryID", $"{args.TerritoryID}" } });
await Invoke(() => { StateHasChanged(); });
}
private void detach_EmployeeTerritories(EmployeeTerritory entity)
{
this.SendPropertyChanging();
entity.Territory = null;
}
partial void DeleteEmployeeTerritory(EmployeeTerritory instance);
public void Update(int EmployeeID,string TerritoryID)
{
EmployeeTerritory item = new EmployeeTerritory();
item.MarkOld();
item.IsLoaded = true;
item.EmployeeID = EmployeeID;
item.TerritoryID = TerritoryID;
item.Save(UserName);
}
public void UpdateEmployeeTerritory(EmployeeTerritory currentEmployeeTerritory)
{
this.DataContext.EmployeeTerritories.Attach(currentEmployeeTerritory, this.ChangeSet.GetOriginal(currentEmployeeTerritory));
}
protected async void Form0Submit(EmployeeTerritory args)
{
var northwindUpdateEmployeeTerritoryResult = await Northwind.UpdateEmployeeTerritory(int.Parse(EmployeeID), $"{TerritoryID}", employeeterritory);
UriHelper.NavigateTo("EmployeeTerritories");
}
private void attach_EmployeeTerritories(EmployeeTerritory entity)
{
this.SendPropertyChanging();
entity.Employee = this;
}
static partial void OnAfterEntityToDto(EmployeeTerritoryEntity entity, Hashtable seenObjects, Hashtable parents, EmployeeTerritory dto);
partial void InsertEmployeeTerritory(EmployeeTerritory instance);
partial void UpdateEmployeeTerritory(EmployeeTerritory instance);
protected async void Form0Submit(EmployeeTerritory args)
{
var northwindCreateEmployeeTerritoryResult = await Northwind.CreateEmployeeTerritory(employeeterritory);
UriHelper.NavigateTo("EmployeeTerritories");
}
public void Insert(int EmployeeID,string TerritoryID)
{
EmployeeTerritory item = new EmployeeTerritory();
item.EmployeeID = EmployeeID;
item.TerritoryID = TerritoryID;
item.Save(UserName);
}
