Example #1
0
        public ActionResult FindEmployee(FormCollection formCollection)
        {
            // The input conversion is valid.
            if (ModelState.IsValid)
            {
                Models.Employees result = new Models.Employees();

                if (!string.IsNullOrEmpty(formCollection["employeeName"]) && !string.IsNullOrEmpty(formCollection["employeeEmail"]))
                {
                    // The employeeName and employeeEmail query fields were not empty so list find the items.
                    result = businessLogicLayer.FindEmployeeByNameAndEmail(formCollection["employeeName"], formCollection["employeeEmail"]);
                }
                else if (!string.IsNullOrEmpty(formCollection["employeeName"]) && string.IsNullOrEmpty(formCollection["employeeEmail"]))
                {
                    // The employeeEmail was empty, but the employeeName was not, so find the items based on the employeeName query field.
                    result = businessLogicLayer.FindEmployeeByName(formCollection["employeeName"]);
                }
                else if (string.IsNullOrEmpty(formCollection["employeeName"]) && !string.IsNullOrEmpty(formCollection["employeeEmail"]))
                {
                    // The employeeName was empty, but the employeeEmail was not, so find the items based on the employeeEmail query field.
                    result = businessLogicLayer.FindEmployeeByEmail(formCollection["employeeEmail"]);
                }
                else
                {
                    // The employeeName and employeeEmail query fields were empty so list all items.
                    result = businessLogicLayer.ListEmployees();
                }

                // Store the result in the ViewBag.
                ViewBag.Employees = result;
            }

            return(View());
        }
        /// <summary>
        /// Lists the Employees.
        /// </summary>
        /// <returns>The list of Employees or null.</returns>
        public Models.Employees ListEmployees()
        {
            try
            {
                // Open a connection to the database.
                SqlConnection sqlConnection = new SqlConnection(url);
                sqlConnection.Open();

                // List the items from the Employees table with the stored procedure.
                Models.Employees employees  = new Models.Employees();
                SqlCommand       sqlCommand = new SqlCommand("spListEmployees", sqlConnection);
                sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
                SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();

                // Store the items in an Employee list.
                while (sqlDataReader.Read())
                {
                    employees.Items.Add(new Models.Employee(sqlDataReader.GetInt32(0), sqlDataReader.GetString(1), sqlDataReader.GetString(2), sqlDataReader.GetBoolean(3)));
                }

                // Close the dataReader and the connection.
                sqlDataReader.Close();
                sqlConnection.Close();

                return(employees);
            }
            catch
            {
                return(null);
            }
        }
        /// <summary>
        /// Finds an Employee by name and email.
        /// </summary>
        /// <param name="name">The Employee name to find.</param>
        /// <param name="email">The Employee email to find.</param>
        /// <returns>The Employee list or null.</returns>
        public Models.Employees FindEmployeeByNameAndEmail(string name, string email)
        {
            try
            {
                // Open a connection to the database.
                SqlConnection sqlConnection = new SqlConnection(url);
                sqlConnection.Open();

                // Find the items in the Employees table with the stored procedure.
                Models.Employees employees  = new Models.Employees();
                SqlCommand       sqlCommand = new SqlCommand("spFindEmployeeByNameAndEmail", sqlConnection);
                sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
                sqlCommand.Parameters.AddWithValue("@name", name);
                sqlCommand.Parameters.AddWithValue("@email", email);
                SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();

                // Store the items in an Employee list.
                while (sqlDataReader.Read())
                {
                    employees.Items.Add(new Models.Employee(sqlDataReader.GetInt32(0), sqlDataReader.GetString(1), sqlDataReader.GetString(2), sqlDataReader.GetBoolean(3)));
                }

                // Close the dataReader and the connection.
                sqlDataReader.Close();
                sqlConnection.Close();

                return(employees);
            }
            catch
            {
                return(null);
            }
        }
        public async Task <ActionResult <Employees> > SaveEmployees([FromBody] Employees _VendorType)
        {
            string valorrespuesta = "";

            try
            {
                Employees  _listVendorType = new Employees();
                string     baseadress      = config.Value.urlbase;
                HttpClient _client         = new HttpClient();
                _client.DefaultRequestHeaders.Add("Authorization", "Bearer " + HttpContext.Session.GetString("token"));
                var result = await _client.GetAsync(baseadress + "api/Employees/GetEmployeesByIdentidad/" + _VendorType.Identidad);

                if (result.IsSuccessStatusCode)
                {
                    valorrespuesta  = await(result.Content.ReadAsStringAsync());
                    _listVendorType = JsonConvert.DeserializeObject <Employees>(valorrespuesta);
                    if (_listVendorType != null && _VendorType.IdEmpleado == 0)
                    {
                        if (_listVendorType.Identidad == _VendorType.Identidad)
                        {
                            return(await Task.Run(() => BadRequest($"Ya existe un Empleado registrado con esa Identidad.")));
                        }
                    }
                }
                result = await _client.GetAsync(baseadress + "api/Employees/GetEmployeesById/" + _VendorType.IdEmpleado);

                _VendorType.FechaModificacion   = DateTime.Now;
                _VendorType.Usuariomodificacion = HttpContext.Session.GetString("user");
                if (result.IsSuccessStatusCode)
                {
                    valorrespuesta  = await(result.Content.ReadAsStringAsync());
                    _listVendorType = JsonConvert.DeserializeObject <Employees>(valorrespuesta);
                }

                if (_listVendorType == null)
                {
                    _listVendorType = new Models.Employees();
                }

                if (_listVendorType.IdEmpleado == 0)
                {
                    _VendorType.FechaCreacion   = DateTime.Now;
                    _VendorType.Usuariocreacion = HttpContext.Session.GetString("user");
                    var insertresult = await Insert(_VendorType);
                }
                else
                {
                    var updateresult = await Update(_VendorType.IdEmpleado, _VendorType);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"Ocurrio un error: { ex.ToString() }");
                throw ex;
            }

            return(Json(_VendorType));
        }
        /// <summary>
        /// Finds an Relation by Employee.
        /// </summary>
        /// <param name="input">The Relation Employee to find.</param>
        /// <returns>The Relation list or null.</returns>
        public Models.Relations FindRelationByEmployee(string input)
        {
            try
            {
                // Open a connection to the database.
                SqlConnection sqlConnection = new SqlConnection(url);
                sqlConnection.Open();

                // Find the items in the Employees table with the stored procedure.
                Models.Employees employees   = new Models.Employees();
                SqlCommand       sqlCommand1 = new SqlCommand("spFindEmployeeByName", sqlConnection);
                sqlCommand1.CommandType = System.Data.CommandType.StoredProcedure;
                sqlCommand1.Parameters.AddWithValue("@name", input);
                SqlDataReader sqlDataReader1 = sqlCommand1.ExecuteReader();

                // Store the items in an Employee list.
                while (sqlDataReader1.Read())
                {
                    employees.Items.Add(new Models.Employee(sqlDataReader1.GetInt32(0), sqlDataReader1.GetString(1), sqlDataReader1.GetString(2), sqlDataReader1.GetBoolean(3)));
                }

                // Close the dataReader.
                sqlDataReader1.Close();

                // There is at least one item that was found.
                int input2 = 0;
                if (employees.Items.Count > 0)
                {
                    // Because the previous search was on an Id, there should only be one item found.
                    input2 = employees.Items[0].EmployeeId;
                }

                // Find the items in the Relations table with the stored procedure.
                Models.Relations relations  = new Models.Relations();
                SqlCommand       sqlCommand = new SqlCommand("spFindRelationByEmployee", sqlConnection);
                sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
                sqlCommand.Parameters.AddWithValue("@employee", input2);
                SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();

                // Store the items in an Relation list.
                while (sqlDataReader.Read())
                {
                    relations.Items.Add(new Models.Relation(sqlDataReader.GetInt32(0), sqlDataReader.GetInt32(1), sqlDataReader.GetInt32(2)));
                }

                // Close the dataReader and the connection.
                sqlDataReader.Close();
                sqlConnection.Close();

                return(relations);
            }
            catch
            {
                return(null);
            }
        }
 private void DeleteUser(Models.Employees employee)
 {
     if (employee != null)
     {
         Console.Write(String.Format("Are you sure you want to delete the user {0} {1}? (y/n)", employee.EmployeeFirstName, employee.EmployeeLastName));
         if (Console.ReadLine().ToUpper() == "Y")
         {
             employee.Delete();
         }
     }
 }
        private void lst_ItemSelected(object sender, SelectedItemChangedEventArgs e)
        {
            if (e.SelectedItem == null)
            {
                return;
            }

            Models.Employees emp = e.SelectedItem as Models.Employees;
            Navigation.PushAsync(new View.Employee.Details(emp));
            lst.SelectedItem = null;
        }
Example #8
0
 private void btnEdit_Clicked(object sender, EventArgs e)
 {
     Models.Employees emp = new Models.Employees
     {
         Id      = int.Parse(lblId.Text),
         Name    = lblName.Text,
         Phone   = lblPhone.Text,
         Email   = lblEmail.Text,
         Address = lblAddress.Text
     };
     Navigation.PushAsync(new View.Employee.Edit(emp));
 }
Example #9
0
 public ActionResult Index(Models.Employees emp)
 {
     if (string.IsNullOrEmpty(emp.Employee))
     {
         ModelState.AddModelError("Employee", new Exception());
     }
     if (ModelState.IsValid)
     {
         return(RedirectToAction("Message"));
     }
     return(View());
 }
Example #10
0
 private void btnAdd_Clicked(object sender, EventArgs e)
 {
     Models.Employees emp = new Models.Employees
     {
         Name    = txtName.Text,
         Phone   = txtPhone.Text,
         Email   = txtEmail.Text,
         Address = txtAddress.Text
     };
     context.Add(emp);
     DisplayAlert("added", "added employee successful", "ok");
     Navigation.PopAsync();
 }
Example #11
0
 private void btnSave_Clicked(object sender, EventArgs e)
 {
     Models.Employees emp = new Models.Employees
     {
         Id      = int.Parse(lblId.Text),
         Name    = txtName.Text,
         Phone   = txtPhone.Text,
         Email   = txtEmail.Text,
         Address = txtAddress.Text
     };
     context.Update(emp);
     DisplayAlert("updated", "employee updated successful", "ok");
     Navigation.PopAsync();
 }
Example #12
0
        /// <summary>
        /// Lists the database tables.
        /// </summary>
        /// <returns>The Index view.</returns>
        public ActionResult Index()
        {
            // List the items from the tables.
            Models.Workplaces workplaces = businessLogicLayer.ListWorkplaces();
            Models.Employees  employees  = businessLogicLayer.ListEmployees();
            Models.Relations  relations  = businessLogicLayer.ListRelations();

            // Store the items in the ViewBag so the Index view can use them.
            ViewBag.Workplaces = workplaces;
            ViewBag.Employees  = employees;
            ViewBag.Relations  = relations;

            return(View());
        }
Example #13
0
        public async Task <IActionResult> OnGetAsync(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            Employees = await _context.Employees.FirstOrDefaultAsync(m => m.EmployeesID == id);

            if (Employees == null)
            {
                return(NotFound());
            }
            return(Page());
        }
Example #14
0
        private void btnDelete_Clicked(object sender, EventArgs e)
        {
            Models.Employees emp = new Models.Employees
            {
                Id      = int.Parse(lblId.Text),
                Name    = lblName.Text,
                Phone   = lblPhone.Text,
                Email   = lblEmail.Text,
                Address = lblAddress.Text
            };

            context.Delete(emp);
            DisplayAlert("deleted", "employee deleted successful", "ok");
            Navigation.PopAsync();
        }
Example #15
0
        /// <summary>
        /// Adds a Relation.
        /// </summary>
        /// <returns>The AddRelation view.</returns>
        // Load the view.
        public ActionResult AddRelation()
        {
            // List the Relations and store them in the ViewBag.
            Models.Relations relations = businessLogicLayer.ListRelations();
            ViewBag.Relations = relations;

            // List the Workplaces and store them in the ViewBag.
            Models.Workplaces workplaces = businessLogicLayer.ListWorkplaces();
            ViewBag.Workplaces = workplaces;

            // List the Employees and store them in the ViewBag.
            Models.Employees employees = businessLogicLayer.ListEmployees();
            ViewBag.Employees = employees;

            return(View());
        }
Example #16
0
        /// <summary>
        /// Edits a Relation.
        /// </summary>
        /// <param name="id">The relationId that was selected.</param>
        /// <returns>The EditRelation view.</returns>
        // Load the view.
        public ActionResult EditRelation(int id)
        {
            // Find the selected Relation and store it in the ViewBag.
            Models.Relation relation = businessLogicLayer.ListRelations().Items.Find(x => x.RelationId == id);
            ViewBag.Relation = relation;

            // List the Workplaces and store them in the ViewBag.
            Models.Workplaces workplaces = businessLogicLayer.ListWorkplaces();
            ViewBag.Workplaces = workplaces;

            // Lists the Employees and store them in the ViewBag.
            Models.Employees employees = businessLogicLayer.ListEmployees();
            ViewBag.Employees = employees;

            return(View());
        }
Example #17
0
        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"));
        }
Example #18
0
        public ActionResult Create(Models.Employees employee)
        {
            if (!ModelState.IsValid)
            {
                return(View(employee));
            }

            db.Employees.Add(employee);
            try
            {
                db.SaveChanges();
            }
            catch (Exception e)
            {
                return(View(employee));
            }
            return(RedirectToAction("Index"));
        }
Example #19
0
        public ActionResult Edit(Models.Employees employee)
        {
            if (!ModelState.IsValid)
            {
                return(View(employee));
            }

            var originalEmployee = (from e in db.Employees
                                    where e.Id == employee.Id
                                    select e).First();

            db.Entry(originalEmployee).CurrentValues.SetValues(employee);
            try
            {
                db.SaveChanges();
            }
            catch (Exception e)
            {
                return(View(employee));
            }
            return(RedirectToAction("Index"));
        }
        // GET: EditEmployee
        public ActionResult EditEmployee(Models.Employees e)
        {
            SqlConnection cn   = new SqlConnection("Data Source=(localdb)\\MSSQLLocalDB; Initial Catalog=MVCKuaforContext-20180723110834; Integrated Security=True; MultipleActiveResultSets=True; AttachDbFilename=|DataDirectory|MVCKuaforContext-20180723110834.mdf");
            string        _sql = "SELECT * FROM Employees WHERE employee_id = " + ((TempData["to-edit-id"] != null) ? TempData["to-edit-id"] : -1);

            Debug.WriteLine(_sql);
            cn.Open();
            SqlCommand    cmd = new SqlCommand(_sql, cn);
            SqlDataReader sdr = cmd.ExecuteReader();

            while (sdr.Read())
            {
                e.employee_id     = sdr.GetInt32(0);
                e.name            = sdr.GetString(1);
                e.surname         = sdr.GetString(2);
                e.username        = sdr.GetString(3);
                e.password        = sdr.GetString(4);
                e.email           = sdr.GetString(5);
                e.telephonenumber = sdr.GetInt64(6);
            }
            cn.Close();
            return(View(e));
        }
        /// <summary>
        /// Lists the Employees.
        /// </summary>
        /// <returns>The list of Employees or null.</returns>
        public Models.Employees ListEmployees()
        {
            try
            {
                // Open a connection to the database.
                SqlConnection sqlConnection = new SqlConnection(url);
                sqlConnection.Open();

                // List the items from the Employees table with the stored procedure.
                Models.Employees employees = new Models.Employees();
                SqlCommand sqlCommand = new SqlCommand("spListEmployees", sqlConnection);
                sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
                SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();

                // Store the items in an Employee list.
                while (sqlDataReader.Read())
                {
                    employees.Items.Add(new Models.Employee(sqlDataReader.GetInt32(0), sqlDataReader.GetString(1), sqlDataReader.GetString(2), sqlDataReader.GetBoolean(3)));
                }

                // Close the dataReader and the connection.
                sqlDataReader.Close();
                sqlConnection.Close();

                return employees;
            }
            catch
            {
                return null;
            }
        }
        /// <summary>
        /// Finds an Relation by Employee and Workplace.
        /// </summary>
        /// <param name="employee">The Relation Employee to find.</param>
        /// <param name="workplace">The Relation Workplace to find.</param>
        /// <returns>The Relation list or null.</returns>
        public Models.Relations FindRelationByEmployeeAndWorkplace(string employee, string workplace)
        {
            try
            {
                // Open a connection to the database.
                SqlConnection sqlConnection = new SqlConnection(url);
                sqlConnection.Open();

                // Find the items in the Employees table with the stored procedure.
                Models.Employees employees = new Models.Employees();
                SqlCommand sqlCommand1 = new SqlCommand("spFindEmployeeByName", sqlConnection);
                sqlCommand1.CommandType = System.Data.CommandType.StoredProcedure;
                sqlCommand1.Parameters.AddWithValue("@name", employee);
                SqlDataReader sqlDataReader1 = sqlCommand1.ExecuteReader();

                // Store the items in an Employee list.
                while (sqlDataReader1.Read())
                {
                    employees.Items.Add(new Models.Employee(sqlDataReader1.GetInt32(0), sqlDataReader1.GetString(1), sqlDataReader1.GetString(2), sqlDataReader1.GetBoolean(3)));
                }

                // Close the dataReader.
                sqlDataReader1.Close();

                // Find the items in the Workplaces table with the stored procedure.
                Models.Workplaces workplaces = new Models.Workplaces();
                SqlCommand sqlCommand2 = new SqlCommand("spFindWorkplaceByName", sqlConnection);
                sqlCommand2.CommandType = System.Data.CommandType.StoredProcedure;
                sqlCommand2.Parameters.AddWithValue("@name", workplace);
                SqlDataReader sqlDataReader2 = sqlCommand2.ExecuteReader();

                // Store the items in an Workplace list.
                while (sqlDataReader2.Read())
                {
                    workplaces.Items.Add(new Models.Workplace(sqlDataReader2.GetInt32(0), sqlDataReader2.GetString(1), sqlDataReader2.GetBoolean(2)));
                }

                // Close the dataReader.
                sqlDataReader2.Close();

                // There is at least one item that was found.
                int input2 = 0;
                int input3 = 0;
                if (employees.Items.Count > 0)
                {
                    // Because the previous search was on an Id, there should only be one item found.
                    input2 = employees.Items[0].EmployeeId;
                }
                if (workplaces.Items.Count > 0)
                {
                    // Because the previous search was on an Id, there should only be one item found.
                    input3 = workplaces.Items[0].WorkplaceId;
                }

                // Find the items in the Relations table with the stored procedure.
                Models.Relations relations = new Models.Relations();
                SqlCommand sqlCommand = new SqlCommand("spFindRelationByEmployeeAndWorkplace", sqlConnection);
                sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
                sqlCommand.Parameters.AddWithValue("@employee", input2);
                sqlCommand.Parameters.AddWithValue("@workplace", input3);
                SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();

                // Store the items in an Relation list.
                while (sqlDataReader.Read())
                {
                    relations.Items.Add(new Models.Relation(sqlDataReader.GetInt32(0), sqlDataReader.GetInt32(1), sqlDataReader.GetInt32(2)));
                }

                // Close the dataReader and the connection.
                sqlDataReader.Close();
                sqlConnection.Close();

                return relations;
            }
            catch
            {
                return null;
            }
        }
        /// <summary>
        /// Finds an Employee by name and email.
        /// </summary>
        /// <param name="name">The Employee name to find.</param>
        /// <param name="email">The Employee email to find.</param>
        /// <returns>The Employee list or null.</returns>
        public Models.Employees FindEmployeeByNameAndEmail(string name, string email)
        {
            try
            {
                // Open a connection to the database.
                SqlConnection sqlConnection = new SqlConnection(url);
                sqlConnection.Open();

                // Find the items in the Employees table with the stored procedure.
                Models.Employees employees = new Models.Employees();
                SqlCommand sqlCommand = new SqlCommand("spFindEmployeeByNameAndEmail", sqlConnection);
                sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
                sqlCommand.Parameters.AddWithValue("@name", name);
                sqlCommand.Parameters.AddWithValue("@email", email);
                SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();

                // Store the items in an Employee list.
                while (sqlDataReader.Read())
                {
                    employees.Items.Add(new Models.Employee(sqlDataReader.GetInt32(0), sqlDataReader.GetString(1), sqlDataReader.GetString(2), sqlDataReader.GetBoolean(3)));
                }

                // Close the dataReader and the connection.
                sqlDataReader.Close();
                sqlConnection.Close();

                return employees;
            }
            catch
            {
                return null;
            }
        }
        public ActionResult FindEmployee(FormCollection formCollection)
        {
            // The input conversion is valid.
            if (ModelState.IsValid)
            {
                Models.Employees result = new Models.Employees();

                if (!string.IsNullOrEmpty(formCollection["employeeName"]) && !string.IsNullOrEmpty(formCollection["employeeEmail"]))
                {
                    // The employeeName and employeeEmail query fields were not empty so list find the items.
                    result = businessLogicLayer.FindEmployeeByNameAndEmail(formCollection["employeeName"], formCollection["employeeEmail"]);
                }
                else if (!string.IsNullOrEmpty(formCollection["employeeName"]) && string.IsNullOrEmpty(formCollection["employeeEmail"]))
                {
                    // The employeeEmail was empty, but the employeeName was not, so find the items based on the employeeName query field.
                    result = businessLogicLayer.FindEmployeeByName(formCollection["employeeName"]);
                }
                else if (string.IsNullOrEmpty(formCollection["employeeName"]) && !string.IsNullOrEmpty(formCollection["employeeEmail"]))
                {
                    // The employeeName was empty, but the employeeEmail was not, so find the items based on the employeeEmail query field.
                    result = businessLogicLayer.FindEmployeeByEmail(formCollection["employeeEmail"]);
                }
                else
                {
                    // The employeeName and employeeEmail query fields were empty so list all items.
                    result = businessLogicLayer.ListEmployees();
                }

                // Store the result in the ViewBag.
                ViewBag.Employees = result;
            }

            return View();
        }
Example #25
0
 public Details(Models.Employees emp)
 {
     InitializeComponent();
     this.BindingContext = emp;
 }