/// <summary>
///
/// </summary>
/// <param name="employee"></param>
/// <returns></returns>
public Int32 SaveEmployee(Entities.Employee employee)
{
var employeeId = 0;
if (employee.EmployeeId == null || employee.EmployeeId == 0)
{
employeeId = AddEmployee(employee);
}
else if (employee.ModifiedBy != null || employee.ModifiedBy > 0)
{
employeeId = UpdateEmployee(employee);
}
else if (employee.IsDeleted == true)
{
var result = DeleteEmployee(employee);
if (result)
{
employeeId = (int)employee.EmployeeId;
}
else
{
employeeId = 1;
}
}
return(employeeId);
}
internal bool Insert(Entities.TourGroup group, Entities.Employee employee)
{
bool res = false;
try
{
this.query.Parameters.Clear();
this.query.Parameters.Add(new SqlParameter("@GroupId", group.Id));
this.query.Parameters.Add(new SqlParameter("@EmployeeId", employee.User.Id));
int ret;
res = this.query.ExecuteInsertProc("TourGroupEmployeesAdd", out ret);
}
catch (Exception ex)
{
try
{
DomainModel.Application.Status.Update(
StatusController.Abstract.StatusTypes.Error,
"",
ex.Message);
}
catch { }
}
return(res);
}
public List <Entities.Employee> GetEmployeeIdAndNameByEmployeeName(string employeeName)
{
List <Entities.Employee> employees = new List <Entities.Employee>();
try
{
using (DbCommand dbCommand = database.GetStoredProcCommand(DBStoredProcedure.GetEmployeeIdAndNameByEmployeeName))
{
database.AddInParameter(dbCommand, "@employee_name", DbType.String, employeeName);
using (IDataReader reader = database.ExecuteReader(dbCommand))
{
var employee = new Entities.Employee()
{
EmployeeId = DRE.GetNullableInt32(reader, "@employee_id", null),
EmployeeCode = DRE.GetNullableString(reader, "@employee_code", null),
CompanyName = DRE.GetNullableString(reader, "@company_name", null),
FullName = DRE.GetNullableString(reader, "@full_name", null)
};
employees.Add(employee);
}
}
}
catch (Exception ex)
{
throw ex;
}
return(employees);
}
/// <summary>
///
/// </summary>
/// <param name="employee"></param>
/// <returns></returns>
private bool DeleteEmployee(Entities.Employee employee)
{
bool isDeleted = false;
try
{
using (DbCommand dbCommand = database.GetStoredProcCommand(DBStoredProcedure.DeleteEmployee))
{
database.AddInParameter(dbCommand, "@employee_id", DbType.Int32, employee.EmployeeId);
database.AddInParameter(dbCommand, "@deleted_by", DbType.Int32, employee.DeletedBy);
database.AddInParameter(dbCommand, "@deleted_by_ip", DbType.String, employee.DeletedByIP);
database.AddOutParameter(dbCommand, "@return_value", DbType.Int32, 0);
var result = database.ExecuteNonQuery(dbCommand);
if (database.GetParameterValue(dbCommand, "@return_value") != DBNull.Value)
{
isDeleted = Convert.ToBoolean(database.GetParameterValue(dbCommand, "@return_value"));
}
}
}
catch (Exception e)
{
throw e;
}
return(isDeleted);
}
/// <summary>
/// Creates a new Employee
/// </summary>
/// <param name="employee">Employee</param>
/// <returns>Operation result</returns>
public Result CreateEmployee(Entities.Employee employee)
{
Result response = new Result();
try
{
using (var context = new ConfigurelyContext())
{
Employee newEmployee = new Employee {
Name = employee.Name,
DepartmentID = employee.EmployeeDepartment.ID,
DateCreated = DateTime.Now,
EmployeeData = employee.EmployeeData.Select(x => new EmployeeData()
{
FieldID = x.Field.ID,
Value = x.Value
}).ToList()
};
context.Employee.Add(newEmployee);
context.SaveChanges();
response.isSuccess = true;
}
}
catch (Exception ex)
{
response.isSuccess = false;
response.Error = ex.Message;
}
return(new Result());
}
/// <summary>
/// Return a Employee by Id
/// </summary>
/// <param name="id">Employee Id</param>
/// <returns>Employee</returns>
public Entities.Employee GetEmployee(int id)
{
Entities.Employee responseEmployee = null;
try
{
using (var context = new ConfigurelyContext())
{
var query = context.Employee.Include(x => x.Department)
.Include(x => x.Department.Field)
.Include(x => x.Department.Field.Select(y => y.FieldType))
.Include(x => x.EmployeeData)
.Include(x => x.EmployeeData.Select(y => y.Field))
.Include(x => x.EmployeeData.Select(y => y.Field.FieldType))
.SingleOrDefault(x => x.ID == id);
if (query != null)
{
responseEmployee = GetResponseEmployee(query);
}
}
}
catch (Exception)
{
throw;
}
return(responseEmployee);
}
public bool Ekle(Entities.Employee model)
{
var result = false;
dbContext.Employee.Add(model);
dbContext.SaveChanges();
result = true;
return(result);
}
public async Task <Entities.Employee> AddEmployee(Entities.Employee employee)
{
//employee.Id = Guid.NewGuid();
await _sqlDbContext.Employees.AddAsync(employee);
await _sqlDbContext.SaveChangesAsync();
return(employee);
}
/// <summary>
/// Changes a Employee
/// </summary>
/// <param name="employee">Employee</param>
/// <returns>Operation result</returns>
public Result EditEmployee(Entities.Employee employee)
{
Result oResult = new Result();
try
{
using (var context = new ConfigurelyContext())
{
using (var dbContextTransaction = context.Database.BeginTransaction())
{
try
{
var dbEmployee = context.Employee.Include(x => x.Department)
.Include(x => x.EmployeeData)
.Include(x => x.EmployeeData.Select(y => y.Field))
.Include(x => x.EmployeeData.Select(y => y.Field.FieldType))
.SingleOrDefault(x => x.ID == employee.ID);
dbEmployee.Name = employee.Name;
if (dbEmployee.DepartmentID != employee.EmployeeDepartment.ID)
{
dbEmployee.DepartmentID = employee.EmployeeDepartment.ID;
}
dbEmployee.EmployeeData.Clear();
employee.EmployeeData.ForEach(x => dbEmployee.EmployeeData.Add(new EmployeeData()
{
FieldID = x.Field.ID,
Value = x.Value
}));
context.SaveChanges();
dbContextTransaction.Commit();
oResult.isSuccess = true;
}
catch (Exception)
{
dbContextTransaction.Rollback();
throw;
}
}
}
}
catch (Exception ex)
{
oResult.isSuccess = false;
oResult.Error = ex.Message;
}
return(oResult);
}
protected void MapTourEmployeesToObject(SqlDataReader reader, object userData)
{
Entities.User user = DomainModel.Membership.Users.GetById(
Utils.GetSafeInt32(reader, "EmployeeId"));
Entities.Employee emp = new Entities.Employee(user);
emp.IsDirty = false;
Entities.TourGroup group = (Entities.TourGroup)userData;
group.Employees.Add(emp);
}
private void BtnOk_Click(object sender, RoutedEventArgs e)
{
bool add = false;
StringBuilder error = new StringBuilder();
if (string.IsNullOrWhiteSpace(TBoxName.Text))
{
error.AppendLine("• Поле 'Имя' не заполнено!");
}
if (string.IsNullOrWhiteSpace(TBoxSurname.Text))
{
error.AppendLine("• Поле 'Фамилия' не заполнено!");
}
if (string.IsNullOrWhiteSpace(TBoxPatronymic.Text))
{
error.AppendLine("• Поле 'Отчество' не заполнено!");
}
if (CBoxRoom.SelectedItem == null)
{
error.AppendLine("• Кабинет не выбран!");
}
if (!MTBoxPhone.MaskCompleted)
{
error.AppendLine("• Поле 'Телефон' не заполнено или заполнено не полностью!");
}
if (CBoxPost.SelectedItem == null)
{
error.AppendLine("• Должность не выбрана!");
}
if (!error.ToString().Equals(""))
{
MessageBox.Show("Невозможно по следующим причинам!\n\n" + error.ToString(), "Ошибка!", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (_employee == null)
{
add = true;
}
_employee = new Entities.Employee()
{
Name = TBoxName.Text,
Surname = TBoxSurname.Text,
Patronymic = TBoxPatronymic.Text,
PhoneNumber = MTBoxPhone.Text,
Room = CBoxRoom.SelectedItem as Entities.Room,
Post = CBoxPost.SelectedItem as Entities.Post
};
if (add)
{
AppData.Context.Employees.Add(_employee);
}
AppData.Context.SaveChanges();
DialogResult = true;
}
public bool Güncelle(int id, Entities.Employee new_value)
{
var result = false;
var key = dbContext.Employee.First(x => x.id == id);
key.name_surname = new_value.name_surname;
key.departman_id = new_value.departman_id;
key.phone_number = new_value.phone_number;
dbContext.SaveChanges();
return(result);
}
private void OnEmployeeBindingSourceCurrentItemChanged(object sender, System.EventArgs e)
{
_currentEmployee = uxEmployeeBindingSource.Current as Entities.Employee;
if (_currentEmployee != null)
{
_currentEmployee.Validate();
}
//_Employee.Validate();
OnCurrentEntityChanged();
}
/// <summary>
/// Converts the Employee object from the BD to the Employee object that will be returned
/// </summary>
/// <param name="dbEmployee">DB Employee</param>
/// <returns>Response Employee</returns>
private Entities.Employee GetResponseEmployee(Employee dbEmployee)
{
Entities.Employee oEmployee = null;
oEmployee = new Entities.Employee
{
ID = dbEmployee.ID,
Name = dbEmployee.Name,
DateCreated = dbEmployee.DateCreated
};
oEmployee.EmployeeDepartment = new Entities.Department
{
ID = dbEmployee.Department.ID,
Name = dbEmployee.Department.Name
};
oEmployee.EmployeeDepartment.Fields = dbEmployee.Department.Field.Select(x => new Entities.Field
{
ID = x.ID,
Name = x.Name,
Type = new Entities.FieldType {
ID = x.FieldType.ID, Type = x.FieldType.Type
},
DefaultValue = x.DefaultValue,
Sort = x.Sort,
Value = x.Value
}).ToList();
oEmployee.EmployeeData = new List <Entities.EmployeeData>();
foreach (EmployeeData data in dbEmployee.EmployeeData)
{
oEmployee.EmployeeData.Add(new Entities.EmployeeData()
{
EmployeeID = data.EmployeeID,
Value = data.Value,
Field = new Entities.Field
{
ID = data.Field.ID,
Name = data.Field.Name,
Type = new Entities.FieldType {
ID = data.Field.FieldType.ID, Type = data.Field.FieldType.Type
},
DefaultValue = data.Field.DefaultValue,
Sort = data.Field.Sort,
Value = data.Field.Value
}
});
}
return(oEmployee);
}
public void OnMenuItemClicked(string itemName)
{
Entities.Employee emp = DomainModel.Employees.GetByName(itemName);
if (emp != null)
{
if (!this.group.Employees.Contains(emp))
{
if (DomainModel.TourGroupEmployees.Add(this.group, emp))
{
}
}
}
}
private void Page_Loaded(object sender, RoutedEventArgs e)
{
var employees = AppData.Context.Employees.Where(p => p.IdPost == 1).ToList();
var employee = new Entities.Employee
{
Surname = "All"
};
employees.Insert(0, employee);
CBFilter.ItemsSource = employees;
CBFilter.SelectedIndex = 0;
Update();
}
void etbButtons_DeleteButtonClick(object sender, System.EventArgs e)
{
Entities.Employee emp = (Entities.Employee)
this.fgvEmployees.SelectedItem;
if (emp != null)
{
if (DomainModel.TourGroupEmployees.Delete(this.group, emp))
{
group.Employees.Remove(emp);
}
}
}
public WindowAddEditEmploee(Entities.Employee employee)
{
InitializeComponent();
Update();
Title = "Изменение работника";
BtnOk.Content = "Изменить";
_employee = employee;
TBoxName.Text = employee.Name;
TBoxSurname.Text = employee.Surname;
TBoxPatronymic.Text = employee.Patronymic;
CBoxPost.SelectedItem = employee.Post;
CBoxRoom.SelectedItem = employee.Room;
MTBoxPhone.Text = employee.PhoneNumber;
}
public EmployeeLogic(int?empId)
{
_dependents = new List <Dependent>();
if (empId.HasValue)
{
using (var db = new PATDbContext())
{
_employee = db.Employees.FirstOrDefault(e => e.EmployeeId == empId);
_employee.Dependents = db.Dependents.Where(d => d.EmployeeId == empId).ToList();
}
}
else
{
_employee = new Employee();
}
}
//Find the first occurance of null object in the Array and assign the value of the new employee into the array...
public virtual void AddNewEmployee(Entities.Employee emp)
{
for (int i = 0; i < _data.Length; i++)
{
//For a reference type array, all elements will be null
if (_data[i] == null)
{
_data[i] = new Entities.Employee();
_data[i].EmpID = emp.EmpID;
_data[i].EmpName = emp.EmpName;
_data[i].EmpAddress = emp.EmpAddress;
return;//exit the function...
}
}
//Raise an exception to tell that no more employees could be added...
}
public virtual Entities.Employee[] GetAllEmployees()
{
//Currently U might have a mixed data of actual Employees and null. This function should remove all the null objects and create a new Copy of Array that contains valid Employees..
Entities.Employee[] tempList = new Entities.Employee[0];
foreach (Entities.Employee emp in _data)
{
if (emp != null)
{
var temp = tempList.Clone() as Entities.Employee[];//Creates a Copy of the Array.
tempList = new Entities.Employee[temp.Length + 1];
temp.CopyTo(tempList, 0);
tempList[tempList.Length - 1] = emp;
}
}
return(tempList);
}
private void ConvertFromEntitiesEmployee(Entities.Employee emp, ref Employee empDB)
{
empDB.Birthday = emp.Birthday;
empDB.Department = emp.Department;
empDB.Email = emp.Email;
empDB.EmployeeID = emp.EmployeeNumber;
empDB.JobMail = emp.JobEmail;
empDB.JobPhoneNumber = emp.JobPhoneNumber;
empDB.JobPosition = emp.JobPosition;
empDB.LastName = emp.LastName;
empDB.Name = emp.Name;
empDB.Password = emp.Password;
empDB.PhoneNumber = emp.PhoneNumber;
empDB.RFC = emp.Rfc;
empDB.SecondName = emp.SecondName;
}
internal static Employee MapToApiModel(Entities.Employee entity)
{
if (entity == null)
{
return(null);
}
return(new Employee
{
Id = entity.Id,
FirstName = entity.FirstName,
LastName = entity.LastName,
SSN = entity.SSN,
EmailAddress = entity.EmailAddress,
PhoneNumber = entity.PhoneNumber
});
}
/// <summary>
///
/// </summary>
/// <param name="employee"></param>
/// <returns></returns>
private Int32 UpdateEmployee(Entities.Employee employee)
{
var employeeId = 0;
try
{
using (DbCommand dbCommand = database.GetStoredProcCommand(DBStoredProcedure.UpdateEmployee))
{
database.AddInParameter(dbCommand, "@employee_id", DbType.Int32, employee.EmployeeId);
database.AddInParameter(dbCommand, "@employee_code", DbType.String, employee.EmployeeCode);
database.AddInParameter(dbCommand, "@title", DbType.String, employee.Title);
database.AddInParameter(dbCommand, "@first_name", DbType.String, employee.FirstName);
database.AddInParameter(dbCommand, "@middle_name", DbType.String, employee.MiddleName);
database.AddInParameter(dbCommand, "@last_name", DbType.String, employee.LastName);
database.AddInParameter(dbCommand, "@address", DbType.String, employee.Address);
database.AddInParameter(dbCommand, "@date_of_birth", DbType.String, employee.DateOfBirth);
database.AddInParameter(dbCommand, "@contact_no_1", DbType.String, employee.ContactNo1);
database.AddInParameter(dbCommand, "@contact_no_2", DbType.String, employee.ContactNo2);
database.AddInParameter(dbCommand, "@mobile_no_1", DbType.String, employee.MobileNo1);
database.AddInParameter(dbCommand, "@mobile_no_2", DbType.String, employee.MobileNo2);
database.AddInParameter(dbCommand, "@email_id", DbType.String, employee.EmailId);
database.AddInParameter(dbCommand, "@pan_no ", DbType.String, employee.PANNo);
database.AddInParameter(dbCommand, "@department", DbType.String, employee.Department);
database.AddInParameter(dbCommand, "@designation", DbType.String, employee.Designation);
database.AddInParameter(dbCommand, "@gender", DbType.String, employee.Gender);
database.AddInParameter(dbCommand, "@company_id", DbType.Int32, employee.CompanyId);
database.AddInParameter(dbCommand, "@modified_by", DbType.Int32, employee.ModifiedBy);
database.AddInParameter(dbCommand, "@modified_by_ip", DbType.String, employee.ModifiedByIP);
database.AddOutParameter(dbCommand, "@return_value", DbType.Int32, 0);
employeeId = database.ExecuteNonQuery(dbCommand);
if (database.GetParameterValue(dbCommand, "@return_value") != DBNull.Value)
{
employeeId = Convert.ToInt32(database.GetParameterValue(dbCommand, "@return_value"));
}
}
}
catch (Exception e)
{
throw e;
}
return(employeeId);
}
/// <summary>
/// <see cref="IEmployeeRepository.CreateEmployeeAsync(Entities.Employee)"/>
/// </summary>
/// <param name="employee"></param>
/// <returns></returns>
public async Task <int> CreateEmployeeAsync(Entities.Employee employee)
{
var employeeJson = JsonSerializer.Serialize(employee);
logger.LogInformation($"Going to create employee {employeeJson}");
var employeeId = await unitOfWork.Connection.QueryFirstOrDefaultAsync <Int32>
(
"[dbo].[spEmployeeCreate]",
employee,
transaction : unitOfWork.Transaction,
commandType : CommandType.StoredProcedure
);
logger.LogInformation($"Employee created successfully with employeeId {employeeId}");
return(employeeId);
}
private Employee ConvertFromEntitiesEmployee(Entities.Employee emp)
{
return(new Employee()
{
Birthday = emp.Birthday,
Department = emp.Department,
Email = emp.Email,
EmployeeID = emp.EmployeeNumber,
JobMail = emp.JobEmail,
JobPhoneNumber = emp.JobPhoneNumber,
JobPosition = emp.JobPosition,
LastName = emp.LastName,
Name = emp.Name,
Password = emp.Password,
PhoneNumber = emp.PhoneNumber,
RFC = emp.Rfc,
SecondName = emp.SecondName
});
}
/// <summary>
///
/// </summary>
/// <param name="employeeId"></param>
/// <returns></returns>
public Entities.Employee GetEmployeeDetailsById(Int32 employeeId)
{
var employee = new Entities.Employee();
using (DbCommand dbCommand = database.GetStoredProcCommand(DBStoredProcedure.GetEmployeeDetailsById)) {
database.AddInParameter(dbCommand, "@employee_id", DbType.Int32, employeeId);
using (IDataReader reader = database.ExecuteReader(dbCommand))
{
while (reader.Read())
{
var _employee = new Entities.Employee
{
EmployeeId = DRE.GetNullableInt32(reader, "employee_id", 0),
EmployeeCode = DRE.GetNullableString(reader, "employee_code", null),
Title = DRE.GetNullableString(reader, "title", null),
FirstName = DRE.GetNullableString(reader, "first_name", null),
MiddleName = DRE.GetNullableString(reader, "middle_name", null),
LastName = DRE.GetNullableString(reader, "last_name", null),
FullName = DRE.GetNullableString(reader, "full_name", null),
Gender = DRE.GetNullableString(reader, "gender", null),
Address = DRE.GetNullableString(reader, "address", null),
DateOfBirth = DRE.GetNullableString(reader, "date_of_birth", null),
ContactNo1 = DRE.GetNullableString(reader, "contact_no_1", null),
ContactNo2 = DRE.GetNullableString(reader, "contact_no_2", null),
MobileNo1 = DRE.GetNullableString(reader, "mobile_no_1", null),
MobileNo2 = DRE.GetNullableString(reader, "mobile_no_2", null),
EmailId = DRE.GetNullableString(reader, "email_id", null),
PANNo = DRE.GetNullableString(reader, "pan_no", null),
Department = DRE.GetNullableString(reader, "department", null),
Designation = DRE.GetNullableString(reader, "designation", null),
CompanyId = DRE.GetNullableInt32(reader, "company_id", null),
CompanyName = DRE.GetNullableString(reader, "company_name", null)
};
employee = _employee;
}
}
}
return(employee);
}
public static bool EditEmployee(Models.Employee employee)
{
try
{
Entities.Employee empObj = _db.Employees.FirstOrDefault(emp => emp.EmployeeId == employee.EmployeeId);
empObj.Email = employee.Email;
empObj.Name = employee.Name;
empObj.MobileNumber = employee.Mobile;
empObj.RoleId = _db.Roles.FirstOrDefault(role => role.RoleName.Equals(employee.Role)).RoleId;
_db.SaveChanges();
EditEmployeeProjTeamXref(employee);
return(true);
}
catch (Exception)
{
return(false);
}
}
public Entities.Employee InsertEmployee(Entities.Employee emp)
{
try
{
using (CPDSEntities context = new CPDSEntities())
{
Employee newEmp = ConvertFromEntitiesEmployee(emp);
context.Employee.Add(newEmp);
context.SaveChanges();
emp.EmployeeNumber = newEmp.EmployeeID;
}
return(emp);
}
catch (Exception ex)
{
throw;
}
}
public static int Salary(this Entities.Employee employee)
{
var httpWebRequest = (HttpWebRequest)WebRequest.Create("http://salary.local/api/empcode/" + employee.Inn);
httpWebRequest.ContentType = "application/json";
httpWebRequest.Method = "POST";
using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
{
string json = JsonConvert.SerializeObject(new { employee.BuhCode });
streamWriter.Write(json);
streamWriter.Flush();
streamWriter.Close();
}
var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
var reader = new System.IO.StreamReader(httpResponse.GetResponseStream(), true);
string responseText = reader.ReadToEnd();
httpResponse.Close();
return((int)Decimal.Parse(responseText));
}
