private EmployeeViewModel InternalMap(Employee employee)
{
DivisionViewModel division = employee.Division == null ? null : InternalMap(employee.Division);
return(new EmployeeViewModel(_companyController, employee.Id, employee.Name, employee.SecondName,
employee.MiddleName, employee.Gender, employee.BirthDate, division));
}
public ActionResult Edit(string id, FormCollection fc)
{
PublicationViewModel p = Pubtracker2FrontEnd.ptHelper.EditPubVM(id);
p.vmPublication.PublicationId = fc["vmPublication.PublicationId"].ToString();
p.vmPublication.SortId = Convert.ToInt32(fc["vmPublication.SortId"].ToString());
p.vmPublication.Title = fc["vmPublication.Title"];
string typeValue = fc["Type"];
p.vmPublication.Series = fc["vmPublication.Series"].ToString();
string divisionValue = fc["Division"];
p.vmPublication.Remarks = fc["vmPublication.Remarks"].ToString();
string typeText = p.slType.ToList().Find(x => x.Value == typeValue).Text;
string divisionText = p.slDivision.ToList().Find(x => x.Value == divisionValue).Text;
TypeViewModel type = new TypeViewModel();
type.TypeId = typeValue;
type.TypeName = typeText;
p.vmPublication.Type = type;
DivisionViewModel division = new DivisionViewModel();
division.DivisionId = divisionValue;
division.DivisionName = divisionText;
p.vmPublication.Division = division;
if (Pubtracker2FrontEnd.ptHelper.Edit <ptPublication>(id, "publications", p.vmPublication))
{
return(RedirectToAction("Index"));
}
else
{
return(View(p));
}
}
public void UpdateDivision(DivisionViewModel divisionVm)
{
Division division = _mapper.Map(divisionVm);
_repository.UpdateDivision(division);
divisionVm.Id = division.Id;
}
public async Task Post_Failed_Internal_Server_Error()
{
DivisionViewModel VM = null;
var response = await this.Client.PostAsync(URI, new StringContent(JsonConvert.SerializeObject(VM).ToString(), Encoding.UTF8, "application/json"));
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
}
/// <summary>
/// Maps domain entity to presentation
/// </summary>
/// <param name="tournament"> Domain object </param>
/// <returns> View model object </returns>
public static TournamentViewModel Map(Tournament tournament)
{
var tournamentViewModel = new TournamentViewModel
{
IsArchived = tournament.IsArchived,
Id = tournament.Id,
Name = tournament.Name,
Description = tournament.Description,
Location = tournament.Location,
Season = tournament.Season,
RegulationsLink = tournament.RegulationsLink,
Scheme = tournament.Scheme,
GamesStart = tournament.GamesStart,
GamesEnd = tournament.GamesEnd,
ApplyingPeriodStart = tournament.ApplyingPeriodStart,
ApplyingPeriodEnd = tournament.ApplyingPeriodEnd,
TransferStart = tournament.TransferStart,
TransferEnd = tournament.TransferEnd,
IsTransferEnabled = tournament.TransferStart != null && tournament.TransferEnd != null
};
tournamentViewModel.Divisions = tournament.Divisions.Select(d => DivisionViewModel.Map(d)).ToList();
return(tournamentViewModel);
}
public void Succes_Instantiate_UnitViewModel()
{
string id = "id test";
string code = "code test";
string name = "name test";
DivisionViewModel divison = new DivisionViewModel();
divison.Id = "Id test";
divison.Code = "Code Test";
divison.Name = "Name test";
UnitViewModel uvm = new UnitViewModel();
uvm.Id = id;
uvm.Name = name;
uvm.Code = code;
uvm.Division = divison;
Assert.Equal(id, uvm.Id);
Assert.Equal(name, uvm.Name);
Assert.Equal(code, uvm.Code);
Assert.NotNull(uvm.Division);
}
public IActionResult ById(DivisionViewModel model)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError(string.Empty, WebConstants.InvalidDivisionDetails);
return(View(model));
}
var division = this.division.ById(model.Division.IdDivision);
var divisionExists = division != null;
if (!divisionExists)
{
ModelState.AddModelError(string.Empty, WebConstants.InvalidDivisionDetails);
return(View(model));
}
var successId = this.division.UpdateDivision(new DivisionModel
{
IdDivision = model.Division.IdDivision,
Division = model.Division.Division
});
TempData.AddSuccessMessage($"Division: {model.Division.Division} with ID: {successId} has been updated successfully.");
return(RedirectToAction(nameof(Index)));
}
public async Task <ActionResult> Edit(string comp_id, string div_id)
{
if (div_id != null && comp_id != null)
{
client.BaseAddress = baseurl;
DivisionViewModel model = new DivisionViewModel();
var postTask = await client.GetAsync("/api/Division/View/?comp_id=" + comp_id + "&div_id=" + div_id);
model = await postTask.Content.ReadAsAsync <DivisionViewModel>();
if (model != null)
{
model.departments = model.departments.OrderBy(x => x.name1).ToList();
model.sections = model.sections.OrderBy(x => x.dept_id).OrderBy(x => x.name1).ToList();
return(View("Edit", model));
}
else
{
DivisionIndexViewModel data = new DivisionIndexViewModel();
ViewBag.Error = "No Division Found !";
return(View("Index", data));
}
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
public void Succes_Instantiate_UnitViewModel()
{
string id = "id test";
string code = "code test";
string name = "name test";
DivisionViewModel divisonViewModel = new DivisionViewModel()
{
Id = "Id test",
Code = "Code Test",
Name = "Name test",
};
UnitViewModel unitViewModel = new UnitViewModel()
{
Id = id,
Name = name,
Code = code,
Division = divisonViewModel,
};
Assert.Equal(id, unitViewModel.Id);
Assert.Equal(name, unitViewModel.Name);
Assert.Equal(code, unitViewModel.Code);
Assert.NotNull(unitViewModel.Division);
}
public void Succes_Instantiate_NewUnitViewModel()
{
int id = 1;
string code = "code test";
string name = "name test";
DivisionViewModel divison = new DivisionViewModel()
{
Id = "Id test",
Code = "Code Test",
Name = "Name test",
};
NewUnitViewModel uvm = new NewUnitViewModel()
{
Id = 1,
Name = name,
Code = code,
Division = divison,
};
Assert.Equal(id, uvm.Id);
Assert.Equal(name, uvm.Name);
Assert.Equal(code, uvm.Code);
Assert.NotNull(uvm.Division);
}
public async Task Post()
{
DivisionViewModel VM = GenerateTestModel();
var response = await this.Client.PostAsync(URI, new StringContent(JsonConvert.SerializeObject(VM).ToString(), Encoding.UTF8, "application/json"));
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
}
public async Task <IActionResult> Index()
{
ViewData["Title"] = $"{_appSettings.Value.AppTitle}-{Subtitle.DivisionList}";
var noOfRowlst = _appSettings.Value.NoOfRowsOptions.Split(',').ToList();
var rowOption = _appSettings.Value.DefaultOptionRowSel;
List <SelectListItem> NoOfRowsSelItemLst = new List <SelectListItem>();
foreach (var x in noOfRowlst)
{
NoOfRowsSelItemLst.Add(new SelectListItem()
{
Value = x, Text = x, Selected = (x == rowOption)
});
}
var dataviewmodel = new DivisionViewModel()
{
Id = 0,
Districts = await _districtSerice.GetDistrictSelectList(),
DV_District = "",
DV_Division = "",
DV_Department = "",
NoOfRows = NoOfRowsSelItemLst
};
return(View(dataviewmodel));
}
public override ExternalTransferOrder GetNewData()
{
DivisionViewModel orderDivision = DivisionDataUtil.GetDivision(client);
DivisionViewModel deliveryDivision = DivisionDataUtil.GetDivision(client);
CurrencyViewModel currency = CurrencyDataUtil.GetCurrencyIDR(client);
return(new ExternalTransferOrder
{
OrderDivisionId = orderDivision._id,
OrderDivisionCode = orderDivision.code,
OrderDivisionName = orderDivision.name,
DeliveryDivisionId = deliveryDivision._id,
DeliveryDivisionCode = deliveryDivision.code,
DeliveryDivisionName = deliveryDivision.name,
OrderDate = DateTime.Now,
DeliveryDate = DateTime.Now,
CurrencyId = currency._id,
CurrencyDescription = currency.description,
CurrencyCode = currency.code,
CurrencySymbol = currency.symbol,
CurrencyRate = currency.rate,
ExternalTransferOrderItems = new List <ExternalTransferOrderItem> {
externalTransferOrderItemDataUtil.GetNewData()
}
});
}
public async Task <ActionResult> Create([Bind(Include = "Code,Name,Plant")] DivisionViewModel division)
{
if (ModelState.IsValid)
{
var Plant = await db.Plants.FindAsync(division.Plant);
if (Plant != null)
{
db.Divisions.Add(new Division
{
Code = division.Code,
Name = division.Name,
Plant = Plant
});
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("Plant", "Selected plant is not found.");
}
}
return(View(division));
}
private void Remove(TreeNode node)
{
int divisionId = Convert.ToInt32(node.Tag);
Division division = new DivisionViewModel(divisionId).Division;
divisionRepo.Remove(division);
}
public CompanyStructureViewModel returndivList()
{
CompanyStructureViewModel model = new CompanyStructureViewModel();
var listData = _CompanyStructureMethod.getAllDivisionList();
var listbiz = _CompanyStructureMethod.getAllBusinessList();
foreach (var item in listData)
{
var bizName = _CompanyStructureMethod.getBusinessListById(item.BusinessID);
if (bizName != null)
{
DivisionViewModel tableModel = new DivisionViewModel();
tableModel.Id = item.Id;
tableModel.Name = item.Name;
tableModel.BusinessName = bizName.Name;
tableModel.CreatedDate = item.CreatedDate;
tableModel.Archived = item.Archived;
model.divisionLists.Add(tableModel);
}
}
foreach (var item in listbiz)
{
BusinessViewModel tableModel = new BusinessViewModel();
tableModel.Id = item.Id;
tableModel.Name = item.Name;
tableModel.CreatedDate = item.CreatedDate;
tableModel.Archived = item.Archived;
model.businessLists.Add(tableModel);
}
return(model);
}
public void CrudTest()
{
var divisionViewModel =
new DivisionViewModel(CompanyController, "Division1", manager: null);
var employeeViewModel1 =
new EmployeeViewModel(CompanyController, "Employee1", "", "", EGender.Female, DateTime.Now, division: null);
var employeeViewModel2 =
new EmployeeViewModel(CompanyController, "Employee2", "", "", EGender.Female, DateTime.Now, division: null);
var orderViewModel1 =
new OrderViewModel(CompanyController, 1, "Product1", employee: null);
var orderViewModel2 =
new OrderViewModel(CompanyController, 2, "Product2", employee: null);
CompanyController.Add(divisionViewModel);
CompanyController.Add(employeeViewModel1);
CompanyController.Add(employeeViewModel2);
CompanyController.Add(orderViewModel1);
CompanyController.Add(orderViewModel2);
Assert.Contains(CompanyController.GetDivisions(), (d) => d.Name.Equals("Division1"));
Assert.Contains(CompanyController.GetEmployees(), (e) => e.Name.Equals("Employee1"));
Assert.Contains(CompanyController.GetEmployees(), (e) => e.Name.Equals("Employee2"));
Assert.Contains(CompanyController.GetOrders(), (d) => d.Number == 1);
Assert.Contains(CompanyController.GetOrders(), (d) => d.Number == 2);
divisionViewModel.Manager = employeeViewModel1;
employeeViewModel2.Division = divisionViewModel;
orderViewModel1.Employee = employeeViewModel2;
CompanyController.Update(divisionViewModel);
CompanyController.Update(employeeViewModel2);
CompanyController.Update(orderViewModel1);
Assert.Contains(CompanyController.GetDivisions(), (d) => d.Manager?.Id == employeeViewModel1.Id);
Assert.Contains(CompanyController.GetEmployees(), (e) => e.Division?.Id == divisionViewModel.Id);
Assert.Contains(CompanyController.GetOrders(), (o) => o.Employee?.Id == employeeViewModel2.Id);
Assert.NotEmpty(CompanyController.FindDivisions("on1"));
Assert.NotEmpty(CompanyController.FindEmployees("ee2"));
Assert.NotEmpty(CompanyController.FindOrders("uct1"));
CompanyController.Remove(orderViewModel2);
CompanyController.Remove(orderViewModel1);
CompanyController.Remove(employeeViewModel2);
CompanyController.Remove(employeeViewModel1);
CompanyController.Remove(divisionViewModel);
Assert.Empty(CompanyController.GetDivisions());
Assert.Empty(CompanyController.GetEmployees());
Assert.Empty(CompanyController.GetOrders());
}
public CompanyStructureViewModel returndfunList()
{
CompanyStructureViewModel model = new CompanyStructureViewModel();
var listfun = _CompanyStructureMethod.getAllFunctionsList();
var listData = _CompanyStructureMethod.getAllDivisionList();
var listbiz = _CompanyStructureMethod.getAllBusinessList();
foreach (var item in listfun)
{
var bizsName = _CompanyStructureMethod.getBusinessListById((int)item.BusinessID);
if (bizsName != null)
{
var divName = _CompanyStructureMethod.getDivisionById(item.DivisionID);
if (divName != null)
{
FunctionViewModel tablepool = new FunctionViewModel();
tablepool.Id = item.Id;
tablepool.Name = item.Name;
tablepool.DivisionName = divName.Name;
tablepool.BusinessName = bizsName.Name;
tablepool.CreatedDate = item.CreatedDate;
model.functionLists.Add(tablepool);
}
else
{
FunctionViewModel tablepool = new FunctionViewModel();
tablepool.Id = item.Id;
tablepool.Name = item.Name;
tablepool.DivisionName = "";
tablepool.BusinessName = bizsName.Name;
tablepool.CreatedDate = item.CreatedDate;
model.functionLists.Add(tablepool);
}
}
}
foreach (var item in listData)
{
DivisionViewModel tableModel = new DivisionViewModel();
tableModel.Id = item.Id;
tableModel.Name = item.Name;
tableModel.BusinessID = item.BusinessID;
tableModel.CreatedDate = item.CreatedDate;
tableModel.Archived = item.Archived;
model.divisionLists.Add(tableModel);
}
foreach (var item in listbiz)
{
BusinessViewModel tableModel = new BusinessViewModel();
tableModel.Id = item.Id;
tableModel.Name = item.Name;
tableModel.CreatedDate = item.CreatedDate;
tableModel.Archived = item.Archived;
model.businessLists.Add(tableModel);
}
return(model);
}
public Division MapToModel(DivisionViewModel divisionVM)
{
Division model = new Division();
PropertyCopier <DivisionViewModel, Division> .Copy(divisionVM, model);
return(model);
}
public DivisionViewModel MapToViewModel(Division division)
{
DivisionViewModel viewModel = new DivisionViewModel();
PropertyCopier <Division, DivisionViewModel> .Copy(division, viewModel);
return(viewModel);
}
public Division Map(DivisionViewModel division)
{
if (!_dependenciesChecker.CheckNoCycles(division))
{
throw new InvalidOperationException("Division hierarchy has cycles.");
}
return(InternalMap(division));
}
public ProjectDialog(DivisionViewModel collection)
{
this.InitializeComponent();
ProjectNumberCollection = new ProjectNumberViewModel();
PlantOrderCollection = new PlantOrderViewModel();
DivisionCollection = collection;
ProductionCollection = new ProductionViewCollection();
}
public async Task Update()
{
Lib.Models.Division division = await DataUtil.GetTestDataAsync();
DivisionViewModel VM = Service.MapToViewModel(division);
var response = await this.Client.PutAsync(string.Concat(URI, "/", VM.Id), new StringContent(JsonConvert.SerializeObject(VM).ToString(), Encoding.UTF8, "application/json"));
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
public async Task Delete()
{
Lib.Models.Division division = await DataUtil.GetTestDataAsync();
DivisionViewModel VM = Service.MapToViewModel(division);
var response = await this.Client.DeleteAsync(string.Concat(URI, "/", VM.Id));
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
}
public void Create(DivisionViewModel divisionViewModel)
{
var Division = new Division
{
DivisionName = divisionViewModel.DivisionName
};
unitOfWork.DivisionRepository.Insert(Division);
unitOfWork.Save();
}
public ActionResult DivisionDetail(int?id)
{
DivisionViewModel model = new DivisionViewModel();
if (id.HasValue)
{
model = new DivisionRepository().GetByID((int)id);
}
return(PartialView("_Division", model));
}
public IEnumerable <DivisionViewModel> FindDivisions(string name)
{
var divisionVms = new List <DivisionViewModel>();
foreach (var division in _repository.FindDivisions(name))
{
DivisionViewModel vm = _mapper.Map(division);
divisionVms.Add(vm);
}
return(divisionVms);
}
public ElementViewerPage()
{
this.InitializeComponent();
this.NavigationCacheMode = NavigationCacheMode.Enabled;
ElementCollection = new ElementViewModel();
DivisionCollection = new DivisionViewModel();
FilterCollection = new ElementFilterViewModel();
LoadingControl.IsLoading = true;
}
public List <DivisionViewModel> GetDivisions()
{
var divisionVms = new List <DivisionViewModel>();
foreach (var division in _repository.Divisions)
{
DivisionViewModel vm = _mapper.Map(division);
divisionVms.Add(vm);
}
return(divisionVms);
}
public JavaScriptResult Create(DivisionViewModel divisionvm)
{
try
{
_divisionService.Add(Mapper.Map <Division>(divisionvm));
return(JavaScript($"ShowResult('{"Data saved successfully."}','{"success"}','{"redirect"}','{"."}')"));
}
catch (Exception ex)
{
return(JavaScript($"ShowResult('{ex.Message}','failure')"));
}
}
public async Task<ActionResult> Edit(DivisionViewModel model)
{
if (ModelState.IsValid)
{
await this.divisionService.CreateOrUpdateAsync(model);
return this.RedirectToAction("Details", "Companias", new { id = model.CompaniaId });
}
// If we got this far, something failed, redisplay form
return this.View(model);
}
public async Task<ActionResult> UpdateDivision(DivisionViewModel model)
{
try
{
if (!ModelState.IsValid)
{
AddRedirectMessage(ModelState);
}
await _viewModelService.Execute(model);
AddRedirectMessage(ServerResponseStatus.SUCCESS, string.Format("Division '{0}' saved!", model.Name));
}
catch (Exception ex)
{
AddRedirectMessage(ex);
}
return RedirectToAction("divisions", "taxonomies", null);
}
private DivisionViewModel CreateDivisionViewModel(Division division)
{
var model = new DivisionViewModel();
model.Id = division.Id;
model.Name = division.Name;
model.StartingDate = division.StartingDate;
model.CanDelete = division.CanDelete();
if (division.Meets.Any()) {
model.Schedule = new ScheduleViewModel(division.Meets, division.StartingDate);
model.HasSchedule = true;
if (division.Meets.Where(m => m.Matches.Where(match => match.IsComplete).Any()).Any()) {
model.HasCompletedMatches = true;
}
}
model.Teams = division.Teams.Select(t => CreateTeamViewModel(t)).ToList();
if (model.Teams.Count() > 1) {
model.HasEnoughTeamsForSchedule = true;
}
else {
model.HasEnoughTeamsForSchedule = false;
}
return model;
}
public ActionResult Create(Guid id)
{
var model = new DivisionViewModel { CompaniaId = id, Habilitado = true };
return this.View(model);
}
