public Exception UpdateEmployee(int id, employees employee)
{
Employee_Data obj = new Employee_Data(_connection);
Exception ex = obj.UpdateEmployee(id, employee);
return(ex);
}
public Exception SaveEmployee(employees employee)
{
Employee_Data obj = new Employee_Data(_connection);
Exception ex = obj.SaveEmployee(employee);
return(ex);
}
public override global::System.Data.DataSet Clone()
{
employees cln = ((employees)(base.Clone()));
cln.InitVars();
cln.SchemaSerializationMode = this.SchemaSerializationMode;
return(cln);
}
public ActionResult DeleteConfirmed(int id)
{
employees employees = db.employees.Find(id);
db.employees.Remove(employees);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void DeleteEmployee(int id)
{
using (GTI_Context db = new GTI_Context(_connection)) {
employees b = db.Employees.First(i => i.Id == id);
db.Employees.Remove(b);
db.SaveChanges();
}
}
public void InsertRelationsReadAfterTransaction()
{
var emp_no = 999797;
var employee = helpers.GetEmployee(emp_no);
foreach (var s in employee.salaries)
{
fixture.employeesDb.Delete(s);
}
salaries salary = null;
employees employeeDb = null;
var table = fixture.employeesDb.Provider.Metadata
.Tables.Single(x => x.DbName == "salaries");
var cache = fixture.employeesDb.Provider.State.Cache.TableCaches.Single(x => x.Table == table);
using var transaction = fixture.employeesDb.Transaction();
Assert.False(cache.IsTransactionInCache(transaction));
Assert.Empty(cache.GetTransactionRows(transaction));
employeeDb = transaction.Query().employees.Single(x => x.emp_no == emp_no);
Assert.Empty(employeeDb.salaries);
var newSalary = new salaries
{
emp_no = employeeDb.emp_no.Value,
salary = 50000,
from_date = helpers.RandomDate(DateTime.Now.AddYears(-60), DateTime.Now.AddYears(-20)),
to_date = helpers.RandomDate(DateTime.Now.AddYears(-60), DateTime.Now.AddYears(-20))
};
//Assert.Empty(employeeDb.salaries);
salary = transaction.Insert(newSalary);
Assert.True(cache.IsTransactionInCache(transaction));
Assert.Single(cache.GetTransactionRows(transaction));
//Assert.Single(employeeDb.salaries);
transaction.Commit();
Assert.Equal(DatabaseTransactionStatus.Committed, transaction.Status);
Assert.False(cache.IsTransactionInCache(transaction));
Assert.Empty(cache.GetTransactionRows(transaction));
Assert.Equal(salary, salary.employees.salaries.First());
Assert.Equal(salary, employeeDb.salaries.First().employees.salaries.First());
Assert.Equal(employeeDb, employeeDb.salaries.First().employees);
Assert.Equal(employeeDb, salary.employees.salaries.First().employees);
Assert.False(cache.IsTransactionInCache(transaction));
Assert.Empty(cache.GetTransactionRows(transaction));
Assert.Single(employee.salaries);
fixture.employeesDb.Delete(employee.salaries.First());
Assert.Empty(employee.salaries);
}
public IActionResult Update(employees employee)
{
if (!ModelState.IsValid)
{
return(View(employee));
}
_repository.Update(employee);
return(RedirectToAction("List"));
}
public void Sua_Click(object sender, CommandEventArgs e)
{
if (e.CommandName == "sua")
{
int m = Convert.ToInt16(e.CommandArgument);
employees s = data.layra1nv(m);
Session["nv"] = s;
Response.Redirect("SuaNV.aspx");
}
}
public ActionResult delete(employees emp)
{
if (ModelState.IsValid)
{
employeeviewmodel ob = new employeeviewmodel();
ob.delete_loginmethod(emp);
return(RedirectToAction("Index"));
}
return(View());
} //method end............
public ActionResult Edit([Bind(Include = "employeeid,departmentId,emp_Name,emp_Address,emp_Phone")] employees employees)
{
if (ModelState.IsValid)
{
db.Entry(employees).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.departmentId = new SelectList(db.departments, "departmentid", "dpt_Description", employees.departmentId);
return(View(employees));
}
public ActionResult Active(long id)
{
//create new BS.clients, because when find one by id I can't update the entity
employees _newEmployees = new employees();
data.employee employee = _newEmployees.GetOneById(id);
employee.isActive = true;
_employees.Update(employee);
return(RedirectToAction("InActives"));
}
public static global::System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(global::System.Xml.Schema.XmlSchemaSet xs)
{
employees ds = new employees();
global::System.Xml.Schema.XmlSchemaComplexType type = new global::System.Xml.Schema.XmlSchemaComplexType();
global::System.Xml.Schema.XmlSchemaSequence sequence = new global::System.Xml.Schema.XmlSchemaSequence();
global::System.Xml.Schema.XmlSchemaAny any = new global::System.Xml.Schema.XmlSchemaAny();
any.Namespace = ds.Namespace;
sequence.Items.Add(any);
type.Particle = sequence;
global::System.Xml.Schema.XmlSchema dsSchema = ds.GetSchemaSerializable();
if (xs.Contains(dsSchema.TargetNamespace))
{
global::System.IO.MemoryStream s1 = new global::System.IO.MemoryStream();
global::System.IO.MemoryStream s2 = new global::System.IO.MemoryStream();
try {
global::System.Xml.Schema.XmlSchema schema = null;
dsSchema.Write(s1);
for (global::System.Collections.IEnumerator schemas = xs.Schemas(dsSchema.TargetNamespace).GetEnumerator(); schemas.MoveNext();)
{
schema = ((global::System.Xml.Schema.XmlSchema)(schemas.Current));
s2.SetLength(0);
schema.Write(s2);
if ((s1.Length == s2.Length))
{
s1.Position = 0;
s2.Position = 0;
for (; ((s1.Position != s1.Length) &&
(s1.ReadByte() == s2.ReadByte()));)
{
;
}
if ((s1.Position == s1.Length))
{
return(type);
}
}
}
}
finally {
if ((s1 != null))
{
s1.Close();
}
if ((s2 != null))
{
s2.Close();
}
}
}
xs.Add(dsSchema);
return(type);
}
public ActionResult UpdateEmp(employees emp)
{
if (Session["UserBL"] != null && ((UserBL)Session["UserBL"]).CheckActionCounter(0))
{
EmployeeBL.UpdateEmp(emp);
return(RedirectToAction("EmployeeMenu"));
}
else
{
Session.Clear();
return(RedirectToAction("Index", "LogIn"));
}
}
// PUT api/values/5
public HttpResponseMessage Put(int id, [FromBody] employees employee)
{
try {
Employee_bll employeeRepository = new Employee_bll(_connection);
Exception ex = employeeRepository.UpdateEmployee(id, employee);
var message = Request.CreateResponse(HttpStatusCode.OK, employee);
message.Headers.Location = new Uri(Request.RequestUri + employee.Id.ToString());
return(message);
} catch {
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Employee with id " + id.ToString() + " not found!"));
}
}
// POST api/values
public HttpResponseMessage Post([FromBody] employees employee)
{
try {
Employee_bll employeeRepository = new Employee_bll(_connection);
Exception ex = employeeRepository.SaveEmployee(employee);
var message = Request.CreateResponse(HttpStatusCode.Created, employee);
message.Headers.Location = new Uri(Request.RequestUri + employee.Id.ToString());
return(message);
} catch (Exception ex) {
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public async Task <IActionResult> Create([Bind("employeeID,status,payType,hourlyRate,overtimeRate,ApplicationUserID,roleID")] employees employees)
{
if (ModelState.IsValid)
{
_context.Add(employees);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ApplicationUserID"] = new SelectList(_context.Users, "Id", "Id", employees.ApplicationUserID);
ViewData["roleID"] = new SelectList(_context.roles, "roleID", "roleID", employees.roleID);
return(View(employees));
}
// GET: employees/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
employees employees = db.employees.Find(id);
if (employees == null)
{
return(HttpNotFound());
}
return(View(employees));
}
private void frmEmployeesInfo_Load(object sender, EventArgs e)
{
using (smartclocksrldbEntities db = new smartclocksrldbEntities())
{
employees employee = db.employees.Find(this.employeeID);
if (employee != null)
{
populateData(employee);
}
var lstemployees = from d in db.employees select d;
lblPersonalCount.Text = lstemployees.Where(p => p.idPosition == employee.idPosition).Count().ToString();
}
}
public ActionResult Post([FromBody] employees empleados)
{
try
{
_context.Add(empleados);
_context.SaveChanges();
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
employees = await _context.employees.FirstOrDefaultAsync(m => m.EID == id);
if (employees == null)
{
return(NotFound());
}
return(Page());
}
// GET: employees/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
employees employees = db.employees.Find(id);
if (employees == null)
{
return(HttpNotFound());
}
ViewBag.departmentId = new SelectList(db.departments, "departmentid", "dpt_Description", employees.departmentId);
return(View(employees));
}
public void Themnv(employees s)
{
con.Open();
string strSql = " insert into employees values (@phone,@password,@email,@address,@department_id,@avatar)";
SqlCommand cmd = new SqlCommand(strSql, con);
cmd.Parameters.AddWithValue("phone", s.phone);
cmd.Parameters.AddWithValue("password", s.password);
cmd.Parameters.AddWithValue("email", s.email);
cmd.Parameters.AddWithValue("address", s.address);
cmd.Parameters.AddWithValue("department_id", s.department_id);
cmd.Parameters.AddWithValue("avatar", s.avatar);
cmd.ExecuteNonQuery();
con.Close();
}
public Exception UpdateEmployee(int id, employees employee)
{
using (GTI_Context db = new GTI_Context(_connection)) {
employees b = db.Employees.First(i => i.Id == id);
b.FirstName = employee.FirstName;
b.LastName = employee.LastName;
b.Gender = employee.Gender;
b.Salary = employee.Salary;
try {
db.SaveChanges();
} catch (Exception ex) {
return(ex);
}
return(null);
}
}
public Exception SaveEmployee(employees employee)
{
using (GTI_Context db = new GTI_Context(_connection)) {
try {
db.Database.ExecuteSqlCommand("INSERT INTO employees(id,firstname,lastname,gender,salary) VALUES(@id,@firstname,@lastname,@gender,@salary)",
new SqlParameter("@id", employee.Id),
new SqlParameter("@firstname", employee.FirstName),
new SqlParameter("@lastname", employee.LastName),
new SqlParameter("@gender", employee.Gender),
new SqlParameter("@salary", employee.Salary));
} catch (Exception ex) {
return(ex);
}
return(null);
}
}
} //method end...........
public employees getallemployeesbyid(int id)
{
employees emp = new employees();
SqlConnection con = new SqlConnection(cs);
SqlCommand cmd = new SqlCommand("select * from employees where empid=" + id, con);
con.Open();
SqlDataReader rdr = cmd.ExecuteReader();
rdr.Read();
emp.emp_id = int.Parse(rdr["empid"].ToString());
emp.emp_name = rdr["emp_name"].ToString();
emp.emp_email = rdr["emp_email"].ToString();
return(emp);
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
employees = await _context.employees.FindAsync(id);
if (employees != null)
{
_context.employees.Remove(employees);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
private bool registerEmployee(employees e)
{
try
{
using (smartclocksrldbEntities db = new smartclocksrldbEntities())
{
if (!this.Cache.Contains(e.id))
{
checkin oCheckin = new checkin
{
employeeID = e.id,
checkDate = DateTime.Now.Date,
checkHour = DateTime.Now.ToString("HH:mm:ss"),
observations = null
};
db.checkin.Add(oCheckin);
db.SaveChanges();
lblStatus.Text = "Check In";
lblStatus.ForeColor = Color.LightGreen;
this.Cache.Add(e.id);
return(true);
}
else
{
checkout oCheckout = new checkout
{
employeeID = e.id,
checkDate = DateTime.Now.Date,
checkHour = DateTime.Now.ToString("HH:mm:ss"),
observations = null
};
db.checkout.Add(oCheckout);
db.SaveChanges();
lblStatus.Text = "Check Out";
lblStatus.ForeColor = Color.LightGreen;
this.Cache.Remove(e.id);
return(true);
}
}
}
catch (Exception ex)
{
MessageBox.Show("Error " + ex.Message);
return(false);
}
}
public void Capnhatnv(employees s)
{
con.Open();
string strSql = " update employees set phone=@phone,password=@password,email=@email,address=@address,department_id=@department_id,avatar=@avatar where employee_id=@employee_id";
SqlCommand cmd = new SqlCommand(strSql, con);
cmd.Parameters.AddWithValue("phone", s.phone);
cmd.Parameters.AddWithValue("password", s.password);
cmd.Parameters.AddWithValue("email", s.email);
cmd.Parameters.AddWithValue("address", s.address);
cmd.Parameters.AddWithValue("department_id", s.department_id);
cmd.Parameters.AddWithValue("avatar", s.avatar);
cmd.Parameters.AddWithValue("employee_id", s.employee_id);
cmd.ExecuteNonQuery();
con.Close();
}
private async void Agregar(object sender, EventArgs e)
{
employees compa = new employees()
{
name = nombre.Text,
salary = Int32.Parse(salario.Text)
};
var json = JsonConvert.SerializeObject(compa);
var content = new StringContent(json, Encoding.UTF8, "application/json");
HttpClient client = new HttpClient();
var result = await client.PostAsync("http://ec2-18-231-108-168.sa-east-1.compute.amazonaws.com/", content);
if (result.StatusCode == HttpStatusCode.Created)
{
await DisplayAlert("Guardado!", "El empleado a sido guardado con exito", "Aceptar");
}
}
public IHttpActionResult Create(employees employee)
{
dynamic Response = new ExpandoObject();
try
{
if (!ModelState.IsValid)
{
Response.Status = Helpers.ResponseStatus.ERROR;
Response.Message = Helpers.ErrorMessage.BAD_REQUEST;
return(Content(HttpStatusCode.BadRequest, Response));
}
var employeeDTO = Mapper.Map <employees, EmployeeDTO>(employee);
employee.password = SecurePasswordHasher.Hash(employee.password);
context.employees.Add(employee);
context.SaveChanges();
Response.Status = Helpers.ResponseStatus.OK;
Response.Employees = employeeDTO;
return(Ok(Response));
}
catch (Exception)
{
Response.Status = Helpers.ResponseStatus.ERROR;
Response.Message = Helpers.ErrorMessage.INTERNAL_SERVER_ERROR;
return(Content(HttpStatusCode.InternalServerError, Response));
}
/*try
* {
* employee.password = SecurePasswordHasher.Hash(employee.password);
* context.employees.Add(employee);
* context.SaveChanges();
* }
* catch (Exception)
* {
* throw new HttpResponseException(HttpStatusCode.BadRequest);
* }
* return Ok(employee);*/
}
