private ManagerDTO ProcessManager(string managerLine)
{
using (var unitOfWork = _factory.GetInstance())
{
var customerInfo = ParseLine(managerLine, '_');
var lastName = customerInfo[0];
Expression <Func <ManagerDTO, bool> > managerSearchCriteria = x => x.LastName == lastName;
var manager = unitOfWork.GetManagers(managerSearchCriteria).FirstOrDefault();
if (manager == null)
{
manager = new ManagerDTO {
LastName = lastName
};
lock (_lockers[manager.GetType()])
{
if (unitOfWork.GetManagers(managerSearchCriteria).FirstOrDefault() == null)
{
unitOfWork.AddManager(manager);
unitOfWork.Save();
}
}
}
return(unitOfWork.GetManagers(managerSearchCriteria).FirstOrDefault());
}
}
public void RegisterManager(ManagerDTO managerDTO)
{
var manager = MappingDTO.MapManager(managerDTO);
_dataBase.Managers.Register(manager);
_dataBase.Save();
}
public async Task <ManagerDTO> AddAsync(ManagerDTO manager)
{
Locker.EnterWriteLock();
try
{
if (await Managers.TryAddUniqueManagerAsync(manager).ConfigureAwait(false))
{
await Managers.SaveAsync().ConfigureAwait(false);
return(await GetAsync(await Managers.GetIdAsync(manager.Surname)
.ConfigureAwait(false)).ConfigureAwait(false));
}
else
{
throw new ArgumentException("Manager already exists!");
}
}
finally
{
if (Locker.IsWriteLockHeld)
{
Locker.ExitWriteLock();
}
}
}
static void Main()
{
Mapper.Initialize(cfg =>
{
cfg.CreateMap <Employee, EmployeeDTO>();
cfg.CreateMap <Employee, ManagerDTO>();
});
var employee = new Employee()
{
FirstName = "Pesho",
LastName = "Petrov",
Salary = 4000,
Manager = new Employee()
{
FirstName = "ManagerName",
LastName = "ManagerLastName"
}
};
employee.Manager.ManagerOf.Add(new Employee()
{
FirstName = "Emp1",
LastName = "EmpLastName1",
Salary = 5431
});
ManagerDTO manager = Mapper.Map <ManagerDTO>(employee.Manager);
Console.WriteLine($"{manager.FirstName} {manager.LastName} | Employees: {manager.ManagerOf.Count}");
}
public ManagerDTO GetPoolObject(string objectName)
{
ManagerDTO dto = new ManagerDTO();
dto.gObject = poolSystem.GetPooledObject(objectName);
return(dto);
}
public string Execute(string[] parameters)
{
StringBuilder sb = new StringBuilder();
int managerId = int.Parse(parameters[0]);
Emoloyee manager = this.context
.Emoloyees
.Include(e => e.ManagedEmployees)
.FirstOrDefault(x => x.Id == managerId);
ManagerDTO managerDto = this.mapper.CreateMappedObject <ManagerDTO>(manager);
if (manager == null)
{
throw new ArgumentNullException($"Manager with id {managerId} does not exist.");
}
sb.AppendLine($"{managerDto.FirstName} {managerDto.LastName} | Employees: {managerDto.ManagedEmployees.Count}");
foreach (var empl in managerDto.ManagedEmployees)
{
sb.AppendLine($" - {empl.FirstName} {empl.LastName} - ${empl.Salary:f2}");
}
return(sb.ToString());
}
public bool delete(ManagerDTO pt)
{
string query = string.Empty;
query += "DELETE FROM Manager WHERE [iDM] = @iDM";;
using (SqlConnection con = new SqlConnection(ConnectionString))
{
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = con;
cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandText = query;
cmd.Parameters.AddWithValue("@iDM", pt.IDM);
try
{
con.Open();
cmd.ExecuteNonQuery();
con.Close();
con.Dispose();
}
catch (Exception ex)
{
con.Close();
Console.WriteLine(ex);
throw;
}
}
}
return(true);
}
public ManagerDTO getSFX()
{
ManagerDTO dto = new ManagerDTO();
dto.script = sfxManager;
return(dto);
}
public override string Execute(ShopDbContext context, List <string> arguments)
{
int managerId = int.Parse(arguments[0]);
Employee manager = context.Employees
.Include(e => e.ManagedEmployees)
.FirstOrDefault(e => e.ManagerId == managerId);
if (manager == null)
{
return($"There is no manager with Id:{managerId} in the database!");
}
ManagerDTO managerDto = Mapper.Map <ManagerDTO>(manager);
StringBuilder sb = new StringBuilder();
sb.AppendLine($"{managerDto.FirstName} {managerDto.LastName} | Employees: {managerDto.ManagedEmployeesCount}");
foreach (var employee in managerDto.ManagedEmployees)
{
sb.AppendLine($" - {employee.FirstName} {employee.LastName} - ${employee.Salary}");
}
return(sb.ToString().Trim());
}
public bool edit(ManagerDTO mng)
{
string query = string.Empty;
query += "UPDATE Manager SET [nAME] = @nAME, [phoneNUMBER] = @phoneNUMBER, [eMAIL] = @eMAIL WHERE [iDC] = @iDC";
using (SqlConnection con = new SqlConnection(ConnectionString))
{
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = con;
cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandText = query;
cmd.Parameters.AddWithValue("@iDM", mng.IDM);
cmd.Parameters.AddWithValue("@iDU", mng.IDU);
cmd.Parameters.AddWithValue("@nAME", mng.NAME);
cmd.Parameters.AddWithValue("@phoneNUMBER", mng.PhoneNUMBER);
cmd.Parameters.AddWithValue("@eMAIL", mng.EMAIL);
try
{
con.Open();
cmd.ExecuteNonQuery();
con.Close();
con.Dispose();
}
catch (Exception ex)
{
con.Close();
Console.WriteLine(ex);
throw;
}
}
}
return(true);
}
public void Update(ManagerDTO managerDTO)
{
var manager = mapper.Map <ManagerDTO, Manager>(managerDTO);
Database.Managers.Update(manager);
Database.Save();
}
public async Task <ManagerDTO> PostManager([FromBody] ManagerDTO managerDTO)
{
ManagerDTO mgr = null;
try
{
mgr = await mRepository.SaveManager(managerDTO);
}
catch (Exception ex)
{
throw new ApiException(ex.Message);
}
if (!string.IsNullOrEmpty(managerDTO.PhotoData))
{
// Create photo file
var photoPath = Path.Combine(host.WebRootPath, "photo");
if (!Directory.Exists(photoPath))
{
Directory.CreateDirectory(photoPath);
}
var fileName = "Mgr" + mgr.ManagerId.ToString() + ".jpg"; //put "Mgr" as constant in config file
var filePath = Path.Combine(photoPath, fileName);
using (FileStream fs = new FileStream(filePath, FileMode.Create))
{
using (BinaryWriter bw = new BinaryWriter(fs))
{
byte[] data = Convert.FromBase64String(managerDTO.PhotoData);
bw.Write(data);
bw.Close();
}
}
}
return(mgr);
}
public void AddManager(ManagerDTO item)
{
var entity = Mapper.Map <Manager>(item);
_managers.Add(entity);
Save();
}
public void UpdateManager(ManagerDTO managerDTO)
{
var manager = _repositories.Managers.GetAll().FirstOrDefault(m => (m.Id == managerDTO.Id));
manager.SecondName = managerDTO.SecondName;
_repositories.Managers.Update(manager);
_repositories.Save();
}
/// <summary>
/// Merges the specified item
/// </summary>
/// <param name="item">The item with the manager info</param>
/// <param name="culture">The culture.</param>
public void Merge(ManagerDTO item, CultureInfo culture)
{
Contract.Requires(item != null);
base.Merge(item, culture);
Nationality[culture] = item.Nationality;
}
/// <summary>
/// Merges the specified item
/// </summary>
/// <param name="item">The item with the manager info</param>
/// <param name="culture">The culture.</param>
public void Merge(ManagerDTO item, CultureInfo culture)
{
Guard.Argument(item, nameof(item)).NotNull();
base.Merge(item, culture);
Nationality[culture] = item.Nationality;
}
public void UpdateManager(ManagerDTO item)
{
var entity = Mapper.Map <Manager>(item);
_managers.Update(entity);
Save();
}
public ManagerDTO ManagerInfo(int emoloyeeId)
{
var employee = context.Employees.Find(emoloyeeId);
ManagerDTO manager = Mapper.Map <ManagerDTO>(employee);
return(manager);
}
public void RemoveManager(ManagerDTO item)
{
var entity = Mapper.Map <Manager>(item);
_managers.Remove(entity);
Save();
}
public string Execute(params string[] args)
{
int employeeId = int.Parse(args[0]);
ManagerDTO managerDTO = this.managerController.GetManagerInfo(employeeId);
return(managerDTO.ToString());
}
public static Manager ToManager(ManagerDTO model)
{
return(model == null ? null : new Manager
{
Id = model.Id,
Name = model.Name,
SoldProducts = model.SoldProducts?.Select(e => ToSoldProduct(e))
});
}
public ActionResult AddManager(HttpPostedFileBase file, ManagerDTO c)
{
string realpath = Server.MapPath("/images") + "//" + file.FileName;
file.SaveAs(realpath);
_db.managers.Add(c.managerData);
_db.SaveChanges();
return(RedirectToAction("Index", "Manager"));
}
public override ManagerDTO returnPlayer()
{
ManagerDTO dto = new ManagerDTO();
dto.gObject = glController.transform.gameObject;
dto.script = glController;
dto.target = glController.transform;
return(dto);
}
public ActionResult Index()
{
var ManData = new ManagerDTO()
{
managerList = _db.managers.ToList()
};
//var results = (from row in _db.customers select row).ToList();
return(View(ManData));
}
private void MakeUniqueManager(ManagerService managerService, ManagerDTO managerDTO)
{
if (managerDTO != null)
{
var tmp = managerService.Find(x => x.SecondName == managerDTO.SecondName);
if (tmp.Count() == 0)
{
managerService.MakeManager(managerDTO);
}
}
}
public void MakeManager(ManagerDTO managerDTO)
{
if (managerDTO != null)
{
var config = new MapperConfiguration(cfg => cfg.CreateMap <ManagerDTO, Manager>());
IMapper mapper = config.CreateMapper();
_managerRepository.Create(mapper.Map <ManagerDTO, Manager>(managerDTO));
_managerRepository.Save();
}
}
public void AddManager(ManagerDTO manager)
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <ManagerDTO, Manager>();
});
IMapper mapper = config.CreateMapper();
Database.Managers.Create(mapper.Map <ManagerDTO, Manager>(manager));
Database.Save();
}
public List <ManagerDTO> search(string Keyword)
{
string query = string.Empty;
query += "SELECT [iDM], [iDU], [nAME], [phoneNUMBER], [eMAIL]";
query += "FROM [Manager]";
query += " WHERE ([nAME] LIKE CONCAT('%',@Keyword,'%'))";
query += " OR ([iDM] LIKE CONCAT('%',@Keyword,'%'))";
query += " OR ([iDU] LIKE CONCAT('%',@Keyword,'%'))";
query += " OR ([phoneNUMBER] LIKE CONCAT('%',@Keyword,'%'))";
query += " OR ([eMAIL] LIKE CONCAT('%',@Keyword,'%'))";
List <ManagerDTO> lsTimKiem = new List <ManagerDTO>();
using (SqlConnection con = new SqlConnection(ConnectionString))
{
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = con;
cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandText = query;
cmd.Parameters.AddWithValue("@Keyword", Keyword);
try
{
con.Open();
SqlDataReader reader = null;
reader = cmd.ExecuteReader();
if (reader.HasRows == true)
{
while (reader.Read())
{
ManagerDTO mng = new ManagerDTO();
mng.IDM = reader["iDM"].ToString();
mng.IDU = reader["iDU"].ToString();
mng.NAME = reader["nAME"].ToString();
mng.PhoneNUMBER = reader["phoneNUMBER"].ToString();
mng.EMAIL = reader["eMAIL"].ToString();
lsTimKiem.Add(mng);
}
}
con.Close();
con.Dispose();
}
catch (Exception ex)
{
con.Close();
Console.WriteLine(ex);
throw;
}
}
}
return(lsTimKiem);
}
internal static void Handle(DbContext dbContext, OnManagerCreatedEventArgs args)
{
var managerDTO = new ManagerDTO
{
Id = ((Shared.Identity)args.Manager.Id).Id,
Name = args.Manager.Name
};
dbContext.Managers.Add(managerDTO);
dbContext.SaveChanges();
}
public async Task <ManagerDTO> UpdateAsync(ManagerDTO manager)
{
if (await Managers.DoesManagerExistAsync(manager).ConfigureAwait(false))
{
throw new ArgumentException("Manager already exist!");
}
var result = Managers.Update(manager);
await Managers.SaveAsync().ConfigureAwait(false);
return(result);
}
public void AddToManagers(ManagerDTO managerDTO)
{
base.AddObject("Managers", managerDTO);
}
public static ManagerDTO CreateManagerDTO(global::System.Guid ID)
{
ManagerDTO managerDTO = new ManagerDTO();
managerDTO.Id = ID;
return managerDTO;
}
