public async Task <IActionResult> PostEmployeeTerritories([FromBody] EmployeeTerritories employeeTerritories)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.EmployeeTerritories.Add(employeeTerritories);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (EmployeeTerritoriesExists(employeeTerritories.EmployeeId))
{
return(new StatusCodeResult(StatusCodes.Status409Conflict));
}
else
{
throw;
}
}
return(CreatedAtAction("GetEmployeeTerritories", new { id = employeeTerritories.EmployeeId }, employeeTerritories));
}
public async Task <IActionResult> Edit(int id, [Bind("EmployeeId,TerritoryId")] EmployeeTerritories employeeTerritories)
{
if (id != employeeTerritories.EmployeeId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(employeeTerritories);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeTerritoriesExists(employeeTerritories.EmployeeId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["EmployeeId"] = new SelectList(_context.Employees, "EmployeeId", "FirstName", employeeTerritories.EmployeeId);
ViewData["TerritoryId"] = new SelectList(_context.Territories, "TerritoryId", "TerritoryId", employeeTerritories.TerritoryId);
return(View(employeeTerritories));
}
public List <EmployeeTerritories> getAllEmployeeTerritories()
{
List <EmployeeTerritories> employeeTerritoriesList = new List <EmployeeTerritories>();
Connection conn = new Connection();
SqlConnection connection = conn.SqlConnection;
using (SqlCommand command = new SqlCommand("select * from EmployeeTerritories", connection))
{
try
{
connection.Open();
SqlDataReader dataReader = command.ExecuteReader();
while (dataReader.Read())
{
EmployeeTerritories employeeTerritories = new EmployeeTerritories();
employeeTerritories.EmployeeID = dataReader.GetInt32(0);
employeeTerritories.TerritoryID = dataReader.GetString(1);
employeeTerritoriesList.Add(employeeTerritories);
}
dataReader.Close();
}
catch (Exception exc)
{
logger.logError(DateTime.Now, "Error while trying to get all EmployeeTerritories.");
MessageBox.Show(exc.Message);
}
logger.logInfo(DateTime.Now, "GetAllEmployeeTerritories method has sucessfully invoked.");
return(employeeTerritoriesList);
}
}
public int addEmployeeTerritories(EmployeeTerritories employeeTerritories)
{
Connection conn = new Connection();
SqlConnection connection = conn.SqlConnection;
SqlCommand insertCommand = new SqlCommand();
insertCommand.Connection = connection;
insertCommand.CommandType = CommandType.StoredProcedure;
insertCommand.CommandText = "AddEmployeeTerritories";
insertCommand.Parameters.Add("@EmployeeID", SqlDbType.Int);
insertCommand.Parameters.Add("@TerritoryID", SqlDbType.NVarChar);
insertCommand.Parameters["@EmployeeID"].Value = employeeTerritories.EmployeeID;
insertCommand.Parameters["@TerritoryID"].Value = employeeTerritories.TerritoryID;
try
{
connection.Open();
insertCommand.ExecuteNonQuery();
logger.logInfo(DateTime.Now, "AddEmployeeTerritories method has sucessfully invoked.");
return(0);
}
catch (Exception ex)
{
logger.logError(DateTime.Now, "Error while trying to add new EmployeeTerritories.");
MessageBox.Show(ex.Message);
return(-1);
}
finally
{
connection.Close();
}
}
public async Task <IActionResult> PutEmployeeTerritories([FromRoute] int id, [FromBody] EmployeeTerritories employeeTerritories)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != employeeTerritories.EmployeeId)
{
return(BadRequest());
}
_context.Entry(employeeTerritories).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeTerritoriesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void addEmployeeTerritories()
{
EmployeeTerritories employeeTerritories = new EmployeeTerritories(1, "01581");
int res = repo.addEmployeeTerritories(employeeTerritories);
Assert.IsTrue(res == 0);
}
public EmployeeTerritoriesProxyStub EmployeeTerritories_GetByPrimaryKey(System.Int32 employeeID, System.String territoryID)
{
EmployeeTerritories obj = new EmployeeTerritories();
if (obj.LoadByPrimaryKey(employeeID, territoryID))
{
return(obj);
}
return(null);
}
private static void AssignTerritory(Employees employee, string territoryId)
{
using (var context = new NorthwindContext())
{
var empTerr = new EmployeeTerritories()
{
EmployeeId = employee.EmployeeId, TerritoryId = territoryId
};
context.EmployeeTerritories.Add(empTerr);
context.SaveChanges();
}
}
public void UpdateEmployeeTerritories(EmployeeTerritories employeeTerritories)
{
try
{
_context.EmployeeTerritories.Update(employeeTerritories);
_context.SaveChanges();
}
catch (Exception e)
{
throw new Exception();
}
}
public async Task <IActionResult> Create([Bind("EmployeeId,TerritoryId")] EmployeeTerritories employeeTerritories)
{
if (ModelState.IsValid)
{
_context.Add(employeeTerritories);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["EmployeeId"] = new SelectList(_context.Employees, "EmployeeId", "FirstName", employeeTerritories.EmployeeId);
ViewData["TerritoryId"] = new SelectList(_context.Territories, "TerritoryId", "TerritoryId", employeeTerritories.TerritoryId);
return(View(employeeTerritories));
}
public EmployeeTerritories EmployeeTerritories_SaveEntity(EmployeeTerritories entity)
{
if (entity != null)
{
entity.Save();
if (entity.RowState != esDataRowState.Deleted && entity.RowState != esDataRowState.Invalid)
{
return(entity);
}
}
return(null);
}
public EmployeeTerritoriesProxyStub EmployeeTerritories_QueryForEntity(string serializedQuery)
{
EmployeeTerritoriesQuery query = EmployeeTerritoriesQuery.SerializeHelper.FromXml(
serializedQuery, typeof(EmployeeTerritoriesQuery), AllKnownTypes) as EmployeeTerritoriesQuery;
EmployeeTerritories obj = new EmployeeTerritories();
if (obj.Load(query))
{
return(obj);
}
return(null);
}
public void UpdateEmployeeTerritories(inEmployeeTerritories inEmployeeTerritories)
{
try
{
EmployeeTerritories employeeTerritories = new EmployeeTerritories()
{
EmployeeId = inEmployeeTerritories.EmployeeId,
TerritoryId = inEmployeeTerritories.TerritoryId
};
iEmployeeTerritoriesDAO.UpdateEmployeeTerritories(employeeTerritories);
}
catch (Exception e)
{
throw new Exception();
}
}
public EmployeeTerritories getEmployeeTerritoriesById(int employeeID, string territoryID)
{
EmployeeTerritories employeeTerritories = new EmployeeTerritories();
Connection conn = new Connection();
SqlConnection connection = conn.SqlConnection;
SqlCommand selectCommand = new SqlCommand();
selectCommand.Connection = connection;
selectCommand.CommandType = CommandType.StoredProcedure;
selectCommand.CommandText = "GetEmployeeTerritoriesById";
selectCommand.Parameters.Add("@EmployeeID", SqlDbType.Int);
selectCommand.Parameters.Add("@TerritoryID", SqlDbType.NVarChar);
selectCommand.Parameters["@EmployeeID"].Value = employeeID;
selectCommand.Parameters["@TerritoryID"].Value = territoryID;
{
try
{
connection.Open();
SqlDataReader dataReader = selectCommand.ExecuteReader();
if (dataReader.HasRows)
{
dataReader.Read();
employeeTerritories.EmployeeID = dataReader.GetInt32(0);
employeeTerritories.TerritoryID = dataReader.GetString(1);
}
dataReader.Close();
}
catch (Exception exc)
{
logger.logError(DateTime.Now, "Error while trying to get EmployeeTerritories with EmployeeID = " + employeeID + " and TerritoryID = " + territoryID + ".");
MessageBox.Show(exc.Message);
}
finally
{
connection.Close();
}
logger.logInfo(DateTime.Now, "GetEmployeeTerritoriesById method has sucessfully invoked.");
return(employeeTerritories);
}
}
private Employee PopulateFromDataReader(SqlDataReader dr)
{
Employee employee = new Employee();
EmployeeTerritories et = new EmployeeTerritories();
employee.EmployeeId = (int)dr["EmployeeID"];
employee.LastName = dr["LastName"].ToString();
employee.FirstName = dr["FirstName"].ToString();
employee.EmpTerr = et;
// Convert from the Database into a string, then Parse it out as an int.
// Avoids problems with Visual Studio automatically assigning.
employee.EmpTerr.TerritoryId = int.Parse(dr["TerritoryID"].ToString());
employee.EmpTerr.EmployeeId = int.Parse(dr["EmployeeID"].ToString());
return(employee);
}
public async Task TestEager([Values(true, false)] bool enableFilter)
{
using (var ctx = CreateContext(enableFilter))
{
var query = ctx.Orders.Select(o => new
{
Employee = o.Employee,
EmployeeTerritories = o.Employee !.EmployeeTerritories.Select(et => new
{
EmployeeTerritory = et,
Territory = et.Territory
}),
OrderDetails = o.OrderDetails.Select(od => new
{
OrderDetail = od,
od.Product
})
});
public void AddEmployee()
{
using (var connection = new DataConnection("Northwind"))
{
var employee = new Employee()
{
FirstName = "Ivan", LastName = "Ivanov", Title = "Manager"
};
var insertedEmpId = (decimal)connection.InsertWithIdentity(employee);
var insertedEmployee = connection.GetTable <Employee>().Where(e => e.EmployeeID == (int)insertedEmpId).FirstOrDefault();
Assert.IsNotNull(insertedEmployee);
var empTer1 = new EmployeeTerritories()
{
EmployeeID = insertedEmployee.EmployeeID, TerritoryID = connection.GetTable <Territory>().OrderByDescending(t => t.TerritoryDescription).First().TerritoryID
};
var empTer2 = new EmployeeTerritories()
{
EmployeeID = insertedEmployee.EmployeeID, TerritoryID = connection.GetTable <Territory>().OrderBy(t => t.TerritoryDescription).First().TerritoryID
};
insertedEmployee.EmployeeTerritories = new List <EmployeeTerritories>();
insertedEmployee.EmployeeTerritories.Add(empTer1);
insertedEmployee.EmployeeTerritories.Add(empTer2);
foreach (var employeeTerritory in insertedEmployee.EmployeeTerritories)
{
var a = connection.InsertWithIdentity(employeeTerritory);
Assert.IsNotNull(a);
}
Console.WriteLine($"{insertedEmployee.EmployeeID} - {insertedEmployee.FirstName} {insertedEmployee.LastName}");
var result = from emp in connection.GetTable <Employee>().ToList()
join empTer in connection.GetTable <EmployeeTerritories>() on emp.EmployeeID equals empTer.EmployeeID
join ter in connection.GetTable <Territory>() on empTer.TerritoryID equals ter.TerritoryID
where emp.EmployeeID == (int)insertedEmpId
select new { Emp = emp, Ter = ter };
foreach (var emp in result)
{
Console.WriteLine("{0} {1} - {2}", emp.Emp.FirstName, emp.Emp.LastName, emp.Ter.TerritoryDescription);
}
}
}
public void DeleteEmployeeTerritories()
{
EmployeeTerritories empTer = new EmployeeTerritories()
{
EmployeeID = 1,
TerritoryID = "06897"
};
TransactionScope scope = new TransactionScope();
using (UnitOfWork uw = new UnitOfWork(connectionString, providerName))
{
uw.EmployeeTerritories.Delete(empTer);
EmployeeTerritories deletedEmpTer = uw.EmployeeTerritories.Find(empTer);
scope.Dispose();
Assert.IsNull(deletedEmpTer);
}
}
public void Linq2dbTest_AddNewEmployeeWithTerritories()
{
var employee = new Employee()
{
FirstName = "FirstName", LastName = "LastName"
};
int newEmployeeID = Convert.ToInt32(con.InsertWithIdentity(employee));
Assert.IsTrue(newEmployeeID > 0);
var emplTerr = from et in con.Territories
where new[] { "01581", "03049" }.Contains(et.Id)
select et
;
EmployeeTerritories[] employeeTerritories = new EmployeeTerritories[emplTerr.Count()];
int i = 0;
foreach (var et in emplTerr)
{
employeeTerritories[i] = new EmployeeTerritories()
{
EmployeeID = newEmployeeID, TerritoryID = et.Id
};
i++;
}
foreach (var et in employeeTerritories)
{
con.InsertWithIdentity(et);
}
var empReg1 = (from et in con.EmployeeTerritories
where et.EmployeeID == newEmployeeID
select new { EmployeeName = (et.Employee.FirstName + " " + et.Employee.LastName), TerritoryDescription = (et.Territory.Description), RegionDescription = (et.Territory.Region.Description) }
).Distinct();
Assert.IsTrue(empReg1.Count() > 0);
}
public static void Linq2dbConsole()
{
using (var con = new Northwind())
{
Console.WriteLine("--------------------------------------------");
Console.WriteLine("Список продуктов с категорией и поставщиком:");
var products = from p in con.Products
select new { p.Name, CategoryName = p.Category.Name, SupplierName = p.Supplier.Name };
Console.WriteLine("[продукт], [категория], [поставщик]");
foreach (var p in products)
{
Console.WriteLine(" - {0}, {1}, {2}", p.Name, p.CategoryName, p.SupplierName);
}
Console.WriteLine();
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine("Список сотрудников с указанием региона, за который они отвечают:");
var empReg = (from et in con.EmployeeTerritories
select new { EmployeeName = (et.Employee.FirstName + " " + et.Employee.LastName), RegionDescription = (et.Territory.Region.Description) }
).Distinct();
Console.WriteLine("[сотрудник], [регион]");
foreach (var er in empReg)
{
Console.WriteLine(" - {0}, {1}", er.EmployeeName, er.RegionDescription);
}
Console.WriteLine();
Console.WriteLine("-----------------------------------------------------------");
Console.WriteLine("Статистики по регионам: количества сотрудников по регионам:");
var regStat = from r in (from et in con.EmployeeTerritories
select new
{
RegionDescription = (et.Territory.Region.Description),
et.EmployeeID
}
).Distinct()
group r by r.RegionDescription into rGroup
select new
{
RegionDescription = rGroup.Key,
EmployeeCount = (from e in rGroup select e.EmployeeID).Count()
};
Console.WriteLine("[регион], [количество сотрудников]");
foreach (var rs in regStat)
{
Console.WriteLine(" - {0} , {1}", rs.RegionDescription, rs.EmployeeCount);
}
Console.WriteLine();
Console.WriteLine("-----------------------------------------------------------------------------");
Console.WriteLine("Список «сотрудник – с какими грузоперевозчиками работал» (на основе заказов):");
int employeeID = 4;
var empShip = from o in con.Orders
where o.EmployeeID == employeeID
group o by new
{
o.EmployeeID,
EmployeeName = (o.Employee.FirstName + " " + o.Employee.LastName)
} into oGr
select new
{
oGr.Key.EmployeeID,
oGr.Key.EmployeeName,
Ships = string.Join(", ", oGr.Select(e => e.ShipName))
};
Console.WriteLine("[Сотрудник] : [грузоперевозчик]");
foreach (var es in empShip)
{
Console.WriteLine(" - {0} : {1}", es.EmployeeName, es.Ships);
}
Console.WriteLine();
Console.WriteLine("---------------------------------------------------------------");
Console.WriteLine("Добавить нового сотрудника, и указать ему список территорий, за");
Console.WriteLine("которые он несет ответственность:");
var employee = new Employee()
{
FirstName = "FirstName", LastName = "LastName"
};
int newEmployeeID = Convert.ToInt32(con.InsertWithIdentity(employee));
Console.WriteLine("... добавлен новый сотрудник с Id = {0}", newEmployeeID);
var emplTerr = from et in con.Territories
where new[] { "01581", "03049" }.Contains(et.Id)
select et
;
EmployeeTerritories[] employeeTerritories = new EmployeeTerritories[emplTerr.Count()];
int i = 0;
foreach (var et in emplTerr)
{
employeeTerritories[i] = new EmployeeTerritories()
{
EmployeeID = newEmployeeID, TerritoryID = et.Id
};
i++;
}
foreach (var et in employeeTerritories)
{
con.InsertWithIdentity(et);
}
Console.WriteLine("... добавлены территории, за которые отвечает сотрудник:");
Console.WriteLine("[Сотрудник], [Территория], [Регион]");
var empReg1 = (from et in con.EmployeeTerritories
where et.EmployeeID == newEmployeeID
select new { EmployeeName = (et.Employee.FirstName + " " + et.Employee.LastName), TerritoryDescription = (et.Territory.Description), RegionDescription = (et.Territory.Region.Description) }
).Distinct();
foreach (var er in empReg1)
{
Console.WriteLine(" - {0}, {1}, {2}", er.EmployeeName, er.TerritoryDescription, er.RegionDescription);
}
Console.WriteLine();
Console.WriteLine("----------------------------------------------");
Console.WriteLine("Перенести продукты из одной категории в другую...");
var newProduct = new Product()
{
Name = "New product", SupplierID = 1, CategoryID = 1
};
int newProductId = Convert.ToInt32(con.InsertWithIdentity(newProduct));
Console.WriteLine("... создан новый продукт id = {0}", newProductId);
var product = con.Products.Single(t => t.Id == newProductId);
Console.WriteLine("... категория по продукту \"{0}\"", con.Categories.Single(t => t.Id == product.CategoryID).Name);
product.CategoryID = 2;
con.Update(product);
product = con.Products.Single(t => t.Id == newProductId);
Console.WriteLine("... категория по продукту изменена, теперь категория по продукту \"{0}\"", con.Categories.Single(t => t.Id == product.CategoryID).Name);
Console.WriteLine();
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine("Добавить список продуктов со своими поставщиками и категориями");
Console.WriteLine("(массовое занесение), при этом если поставщик или категория с");
Console.WriteLine("таким названием есть, то использовать их – иначе создать");
Console.WriteLine("новые. ");
string[] newSuplierNames = new string[] { "newSupplier1", "newSupplier2", "newSupplier3" };
string[] newCategoryNames = new string[] { "newCategory1", "newCategory2", "newCategory3" };
string[] newProductNames = new string[] { "newProduct1", "newProduct2", "newProduct3" };
for (int j = 0; j < newSuplierNames.Count(); j++)
{
int?findSupplierId = con.Suppliers.Where(s => s.Name == newSuplierNames[j]).Select(s => s.Id).Max();
int?newSupplierId = findSupplierId.Equals(null) ? Convert.ToInt32(con.InsertWithIdentity(new Supplier()
{
Name = newSuplierNames[j]
})) : findSupplierId;
int?findCategoryId = con.Categories.Where(c => c.Name == newCategoryNames[j]).Select(c => c.Id).Max();
int?newCategoryId = findCategoryId.Equals(null) ? Convert.ToInt32(con.InsertWithIdentity(new Category()
{
Name = newCategoryNames[j]
})) : findCategoryId;
newProductId = Convert.ToInt32(con.InsertWithIdentity(new Product()
{
Name = newProductNames[j], CategoryID = newCategoryId, SupplierID = newSupplierId
}));
Console.WriteLine("... создан новый продукт id = {0}", newProductId);
}
Console.WriteLine();
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine("Замена продукта на аналогичный: во всех еще неисполненных");
Console.WriteLine("заказах(считать таковыми заказы, у которых ShippedDate = NULL)");
Console.WriteLine("заменить один продукт на другой.");
int productIdReplaceable = con.Products.Select(c => c.Id).Min();
int productIdForReplace = con.Products.Select(c => c.Id).Max();
string minCustomerID = con.Customers.Select(c => c.Id).Min();
int minEmployeeID = con.Employees.Select(c => c.Id).Min();
int newOrderId = Convert.ToInt32(con.InsertWithIdentity(new Order()
{
CustomerID = minCustomerID, EmployeeID = minEmployeeID
}));
Console.WriteLine("... создан новый заказ id = {0}", newOrderId);
con.Insert(new OrderDetail()
{
OrderID = newOrderId, ProductID = productIdReplaceable, UnitPrice = 1, Quantity = 1, Discount = 0
});
var orders = con.Orders.Where(o => o.ShippedDate.Equals(null)).ToArray();
foreach (var o in orders)
{
try
{
var orderDet = con.OrderDetails.Single(od => od.OrderID == o.Id && od.ProductID == productIdReplaceable);
con.Delete(orderDet);
orderDet.ProductID = productIdForReplace;
con.Insert(orderDet);
Console.WriteLine("... произведена замена продукта с id = {0} на продукт с id = {1}, в заказе id = {2}", productIdReplaceable, productIdForReplace, o.Id);
}
catch (InvalidOperationException) { }
}
}
Console.ReadKey();
}
/// <summary>
/// Name:btnSubmit_Click
/// Description:Here in below code update row and also insert row
/// Author:Monal Shah
/// Created Date:2010/10/4
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void btnSubmit_Click(object sender, EventArgs e)
{
int intIdValue = SessionMethod.CurrentSession.EmployeeID;
try
{
if (intIdValue == 0)
{
objEmpTerritories.LName = TxtLname.Text;
objEmpTerritories.FName = TxtFname.Text;
objEmpTerritories.Title = TxtTitle.Text;
if (DdlSalutation.SelectedIndex != 0)
{
objEmpTerritories.Salutation = DdlSalutation.SelectedItem.Value;
}
else
{
objEmpTerritories.Salutation = null;
}
objEmpTerritories.BirthDate = TxtBdate.Text;
objEmpTerritories.HireDate = TxtHDate.Text;
objEmpTerritories.Address = TxtAddress.Text;
objEmpTerritories.City = TxtCity.Text;
objEmpTerritories.Region = TxtRegion.Text;
objEmpTerritories.PostalCode = TxtPostalCode.Text;
objEmpTerritories.Country = TxtCountry.Text;
objEmpTerritories.Homephone = TxtHomePhone.Text;
objEmpTerritories.Extension = TxtExtension.Text;
objEmpTerritories.Notes = TxtNotes.Text;
if (TxtReportsTo.Text != "")
{
objEmpTerritories.ReportsTo = Convert.ToInt32(TxtReportsTo.Text);
}
else
{
objEmpTerritories.ReportsTo = Convert.ToInt32(null);
}
objEmpTerritories.InsertEmployeeTerritories().ToString();
for (int i = 0; i < LstListBox.Items.Count; i++)// in LstListBox.Items)
{
if (LstListBox.Items[i].Selected)
{
sbInsertValueEmployee = new StringBuilder();
sbInsertValueEmployee.Append("Select ");
sbInsertValueEmployee.Append("TOP ");
sbInsertValueEmployee.Append("1");
sbInsertValueEmployee.Append(" EmployeeID ");
sbInsertValueEmployee.Append("From ");
sbInsertValueEmployee.Append("Employees");
sbInsertValueEmployee.Append(" Order By");
sbInsertValueEmployee.Append(" EmployeeID ");
sbInsertValueEmployee.Append("DESC ");
objCl.GetSqlStmt = sbInsertValueEmployee.ToString();
objDTable = objCl.DataTables();
//string strquery = sbInsertValueEmployee.ToString();
//SqlDataAdapter adp = new SqlDataAdapter(strquery, Commonlogic.GetConnectionString);
//adp.Fill(dt);
if (objDTable.Rows.Count > 0)
{
objEmpTerritories.EmpID = Convert.ToInt32(objDTable.Rows[0]["EmployeeID"]);
}
else
{
LblErrorMessage.Text = objConstant.NoTableRecordFound;// "Datatable Does Not Contain Any Row";
}
}
}
ListBoxValues(objEmpTerritories.EmpID);
Response.Redirect("EmployeeTerritoriesGrid.aspx", false);
}
else
{
objEmpTerritories.EmpID = intIdValue;
objEmpTerritories.LName = TxtLname.Text;
objEmpTerritories.FName = TxtFname.Text;
objEmpTerritories.Title = TxtTitle.Text;
objEmpTerritories.Salutation = DdlSalutation.SelectedItem.Value;
objEmpTerritories.HireDate = TxtHDate.Text;
objEmpTerritories.Address = TxtAddress.Text;
objEmpTerritories.City = TxtCity.Text;
objEmpTerritories.Region = TxtRegion.Text;
objEmpTerritories.PostalCode = TxtPostalCode.Text;
objEmpTerritories.Country = TxtCountry.Text;
objEmpTerritories.Homephone = TxtHomePhone.Text;
objEmpTerritories.Extension = TxtExtension.Text;
objEmpTerritories.Notes = TxtNotes.Text;
objEmpTerritories.ReportsTo = Convert.ToInt32(TxtReportsTo.Text);
sbDeleteValue = new StringBuilder();
sbDeleteValue.Append("DELETE ");
sbDeleteValue.Append("FROM ");
sbDeleteValue.Append("EmployeeTerritories ");
sbDeleteValue.Append("WHERE ");
sbDeleteValue.Append("EmployeeID");
sbDeleteValue.Append("=");
sbDeleteValue.Append("'");
sbDeleteValue.Append(intIdValue);
sbDeleteValue.Append("'");
objCl.GetSqlStmt = sbDeleteValue.ToString();//"Delete from EmployeeTerritories where EmployeeID='" + intIdValue + "'";
objCl.TransactionExecuteNonQuery();
ListBoxValues(intIdValue);
objEmpTerritories.UpdateEmployeeTerritories().ToString();
Response.Redirect("EmployeeTerritoriesGrid.aspx", false);
}
}
catch (Exception)
{
Response.Redirect("Error.aspx", false);
}
finally
{
objCl = null;
sbInsertValue = null;
sbInsertValueEmployee = null;
aryLstBoxValue = null;
objEmpTerritories = null;
}
}
partial void DeleteEmployeeTerritories(EmployeeTerritories instance);
partial void UpdateEmployeeTerritories(EmployeeTerritories instance);
partial void InsertEmployeeTerritories(EmployeeTerritories instance);
private void detach_EmployeeTerritories(EmployeeTerritories entity)
{
this.SendPropertyChanging();
entity.Territories = null;
}
private void attach_EmployeeTerritories(EmployeeTerritories entity)
{
this.SendPropertyChanging();
entity.Employees = this;
}
public void getEmployeeTerritoriesById()
{
EmployeeTerritories employeeTerritories = repo.getEmployeeTerritoriesById(1, "06897");
Assert.IsNotNull(employeeTerritories);
}
