public ListResponse <PositionDTO> GetAllPositions()
{
using (var context = new AF_Context())
{
try
{
List <PositionDTO> tmp = new List <PositionDTO>();
foreach (Position pos in context.Positions.OrderBy(s => s.Section).ThenBy(o => o.Order))
{
var newPositionDto = new PositionDTO()
{
PositionId = pos.PositionId,
PositionTitle = pos.PositionTitle,
Section = pos.Section,
Order = pos.Order
};
tmp.Add(newPositionDto);
}
return(new ListResponse <PositionDTO>(tmp));
}
catch (Exception ex)
{
throw;
}
}
}
public PositionDTO EditPosition(PositionDTO positionDto)
{
if (positionDto == null)
{
return new PositionDTO
{
Successed = false,
ErrorMessage = "Position not be null"
}
}
;
var positionTask = Task.Factory.StartNew(() => this.database.Positions.Get(positionDto.Id));
var position = positionTask.Result;
if (this.ValidatePosition(positionDto, position))
{
position.Name = positionDto.Name;
position.MaxQuantity = positionDto.MaxQuantity;
this.database.Positions.Update(position);
this.EventChanges = new EditOperation(EventChanges);
this.EventChanges.AddOperation(position.Id);
Save();
positionDto.Successed = true;
return(positionDto);
}
return(new PositionDTO
{
Successed = false,
ErrorMessage = "validation error"
});
}
public void UpdatePosition(PositionDTO positionDto)
{
if (positionDto == null)
{
throw new ValidationException(Resource.Resource.PositionNullReference, "");
}
if (!db.Positions.IsExist(positionDto.Id))
{
throw new ValidationException(Resource.Resource.PositionNotFound, "");
}
validateService.Validate(positionDto);
positionDto = CalculateAllParams(positionDto);
var positionFromDb = db.Positions.Get(positionDto.Id);
var position = IMapper.Map <PositionDTO, Position>(positionDto);
position.Portfolio = positionFromDb.Portfolio;
db.Positions.Update(position);
Portfolio portfolio = db.Portfolios.GetAll()
.FirstOrDefault(x => x.Positions.Any(p => p.Id == positionDto.Id));
if (portfolio != null)
{
db.Portfolios.RecalculatePortfolioValue(portfolio.Id);
}
}
public async Task <IHttpActionResult> PostPosition([FromBody] PositionDTO positionDTO)
{
//if model state is not valid send bad request response
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Position position;
//try to get a position with same name
try { position = await _repository.Positions().FindSingleAsync(p => p.Name == positionDTO.Name); }
catch (InvalidOperationException) { throw; }
//if exists send bad request response
if (position != null)
{
return(new ConflictActionResult(Request, "There is already a position with Name:" + positionDTO.Name + " in " +
"the repository! We allow only unique position names."));
}
position = _factory.GeTModel(positionDTO);
//try to insert the position into the repository
try { int result = await _repository.Positions().InsertAsync(position); }
catch (Exception) { throw; }
//InsertAsync(position) created new id, so positionDTO must reflect that
positionDTO = _factory.GetDTO(position);
//send created at route response
return(Created <PositionDTO>(Request.RequestUri + "/id/" + positionDTO.Id.ToString(), positionDTO));
}
public Guid CreateCar(string registration)
{
Guid carId = Guid.NewGuid();
var startingPosition = new PositionDTO()
{
XPosition = 0,
YPosition = 0,
Unit = DistanceUnitDTO.Kilometers
};
var startingDistance = new DistanceDTO()
{
Unit = DistanceUnitDTO.Kilometers,
Value = 0
};
var carDto = new CarDTO()
{
CurrentDistance = startingDistance,
CurrentPosition = startingPosition,
Id = carId,
RegistrationNumber = registration,
Status = CarStatusDTO.Free,
TotalDistance = startingDistance
};
_carService.CreateCar(carDto);
return(carId);
}
// postion management
#region Positions
public ResultVM CreatePosition(PositionVM model)
{
Result.Success = false;
//format the position name
string toLower = CultureInfo.CurrentCulture.TextInfo.ToLower(model.Name);
string formattedName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(toLower);
// check if position is unique
var position = _db.Position.Where(x => x.Name == formattedName).FirstOrDefault();
if (position != null)
{
Result.ErrorMessage = "Position already exist.";
return(Result);
}
// mockup new position
var newPosition = new PositionDTO
{
Name = formattedName,
RequiredAge = model.RequiredAge,
Qualification = model.Qualification,
IsActive = true,
};
// add and save position
_db.Position.Add(newPosition);
_db.SaveChanges();
// return
Result.Success = true;
return(Result);
}
public SingleItemResponse <PositionDTO> AddPosition(PositionDTO newPosition)
{
var newPositionFull = new Position()
{
PositionTitle = newPosition.PositionTitle,
Section = newPosition.Section,
Order = newPosition.Order,
EditedBy = GetUserId(),
EditDate = DateTime.Now
};
using (var context = new AF_Context())
{
try
{
context.Positions.Add(newPositionFull);
context.SaveChanges();
int id = newPositionFull.PositionId;
return(GetPosition(id));
}
catch (Exception ex)
{
throw;
}
}
}
public IHttpActionResult Create([FromBody] PositionDTO position)
{
string accessType = "";
ThrowIfUserCannotAccess(accessType);
if (position == null)
{
throw new KairosException("Missing model parameter");
}
if (position.Position_PK != 0)
{
throw new KairosException("Post method is not allowed because the requested primary key is must be '0' (zero) .");
}
using (var positionCreateHandler = new PositionCreateHandler(Db, ActiveUser, new PositionValidator(), new PositionFactory(Db, ActiveUser), new PositionQuery(Db), AccessControl))
{
using (var transaction = new TransactionScope())
{
var saveResult = positionCreateHandler.Save(positionDTO: position, dateStamp: DateTime.UtcNow);
transaction.Complete();
if (saveResult.Success)
{
return(Ok(new SuccessResponse(saveResult.Model, saveResult.Message)));
}
return(Ok(new ErrorResponse(ServiceStatusCode.ValidationError, saveResult.ValidationResult, saveResult.Message)));
}
}
}
public async Task <JsonResult> AddPositionJSON(PositionViewModel position)
{
try
{
var positionDto = new PositionDTO
{
Id = position.Id,
Name = position.Name,
MaxQuantity = position.MaxQuantity
};
if (position.Id > 0)
{
await positionService.EditPositionTask(positionDto);
}
else
{
await positionService.AddPositionTask(positionDto);
}
return(Json(new { success = true, data = position }, JsonRequestBehavior.AllowGet));
}
catch (ValidationException ex)
{
ModelState.AddModelError(ex.Property, ex.Message);
return(Json(new { success = false, errorstring = ex.Message }, JsonRequestBehavior.AllowGet));
}
}
public static List <PositionDTO> GetPositions()
{
try
{
List <PositionDTO> positionList = new List <PositionDTO>();
var list = (from p in db.POSITIONs
join d in db.DEPARTMENTs on p.DepartmentID equals d.ID
select new
{
positionID = p.ID,
positionName = p.PositionName,
departmentName = d.DepartmentName,
departmentID = d.ID
}).OrderBy(x => x.positionID).ToList();
foreach (var item in list)
{
PositionDTO dto = new PositionDTO();
dto.ID = item.positionID;
dto.PositionName = item.positionName;
dto.DepartmentName = item.departmentName;
dto.DepartmentID = item.departmentID;
positionList.Add(dto);
}
return(positionList);
}catch (Exception ex)
{
throw ex;
}
}
public SingleItemResponse <PositionDTO> UpdatePosition(PositionDTO updateData)
{
var updateDataFull = new Position()
{
PositionId = updateData.PositionId,
PositionTitle = updateData.PositionTitle,
Section = updateData.Section,
Order = updateData.Order,
EditedBy = GetUserId(),
EditDate = DateTime.Now
};
using (var context = new AF_Context())
{
try
{
Position pos = context.Positions.First(p => p.PositionId == updateData.PositionId);
context.Entry(pos).CurrentValues.SetValues(updateDataFull);
context.SaveChanges();
int id = updateData.PositionId;
return(GetPosition(id));
}
catch (Exception ex)
{
throw;
}
}
}
public void Update(PositionDTO positionDTO)
{
Position position = Mapper.Map <Position>(positionDTO);
_unitOfWork.Positions.Update(position);
_unitOfWork.Save();
}
public void Validate(PositionDTO position)
{
if (position.OpenWeight < 1 || position.OpenWeight > 10000)
{
throw new ValidationException(Resource.Resource.PositionOpenWeightValidate, HelperService.GetMemberName((PositionDTO c) => c.OpenWeight));
}
}
PositionDTO IPositionsService.UpdatePosition(PositionDTO newPosition)
{
Position updatedPosition = _unitOfWork.Positions.Update(_mapper.Map <Position>(newPosition));
_unitOfWork.Save();
return(_mapper.Map <PositionDTO>(updatedPosition));
}
PositionDTO IPositionsService.AddPosition(PositionDTO newPosition)
{
Position addedPosition = _unitOfWork.Positions.Create(_mapper.Map <Position>(newPosition));
_unitOfWork.Save();
return(_mapper.Map <PositionDTO>(addedPosition));
}
public PositionViewModel Map(PositionDTO positionDto)
{
return(new PositionViewModel()
{
Latitude = $"{positionDto.Latitude:0.000000}",
Longitude = $"{positionDto.Longitude:0.000000}"
});
}
public void Update(PositionDTO positionDTO, DateTime dateStamp)
{
if (positionDTO == null)
{
throw new ArgumentNullException("Position model is null.");
}
tblM_Position position = positionFactory.CreateFromDbAndUpdateFromDTO(positionDTO, dateStamp);
}
public PositionEditWindow(PositionDTO position)
{
PEViewModel = new PositionEditViewModel {
OriginalPosition = position
};
InitializeComponent();
this.DataContext = PEViewModel.EditedPosition;
}
public PositionVM(PositionDTO row)
{
Id = row.Id;
Name = row.Name;
RequiredAge = row.RequiredAge;
Qualification = row.Qualification;
IsActive = row.IsActive;
}
public void UpdatePosition(PositionDTO positionDTO)
{
IMapper mapper = new MapperConfiguration(cfg => cfg.CreateMap <PositionDTO, Position>()).CreateMapper();
Position position = unitOfWork.Positions.Get(positionDTO.Id);
position = mapper.Map <PositionDTO, Position>(positionDTO);
unitOfWork.Positions.Update(position);
unitOfWork.Save();
}
public ActionResult <string> EditRegisterPosition([FromBody] PositionDTO position)
{
try
{
string result = IListStatusJob.EditRegisterPosition(position);
return(Ok(result));
}
catch (Exception e) { return(e.Message); }
}
public void EditPositionByEmptyNameTest()
{
PositionDTO pdto = new PositionDTO();
pdto.Name = "";
var result = positionserv.EditPosition(pdto);
Assert.AreEqual(result.ErrorMessage, "validation error");
}
public PositionDTO updatePosition(PositionDTO Position)
{
var selectedPosition = uow.GetRepository <Position>().Get(z => z.Id == Position.Id);
selectedPosition = MapperFactory.CurrentMapper.Map(Position, selectedPosition);
uow.GetRepository <Position>().Update(selectedPosition);
uow.SaveChanges();
return(MapperFactory.CurrentMapper.Map <PositionDTO>(selectedPosition));
}
public static PositionModel DTOToVM(PositionDTO position)
{
var config = new MapperConfiguration(cfg => {
cfg.CreateMap <PositionDTO, PositionModel>();
});
var mapper = config.CreateMapper();
return(mapper.Map <PositionDTO, PositionModel>(position));
}
public void Add(PositionDTO positionDTO)
{
Position position = Mapper.Map <Position>(positionDTO);
position.Id = Guid.NewGuid();
_unitOfWork.Positions.Create(position);
_unitOfWork.Save();
}
public tblM_Position Insert(PositionDTO positionDTO, DateTime dateStamp)
{
if (positionDTO == null)
{
throw new ArgumentNullException("Position model is null.");
}
tblM_Position position = positionFactory.CreateFromDTO(positionDTO, dateStamp);
return(Db.tblM_Position.Add(position));
}
private async void Position_MouseRightButtonUp(object sender, MouseButtonEventArgs e)
{
var tb = (TextBlock)sender;
PositionDTO p = (PositionDTO)tb.DataContext;
if (new PositionEditWindow(p).ShowDialog() == true)
{
await RefreshPositions();
}
}
public bool Insert(PositionDTO dto)
{
var position = _mapper.Map <PositionDTO, Position>(dto);
position.Id = new Guid();
_repository.Insert(position);
_unitOfWork.SaveChanges();
return(true);
}
public IActionResult Update([FromBody] PositionDTO dto)
{
var result = _positionService.Update(dto);
if (!result)
{
return(Ok(false));
}
return(Ok(true));
}
public IActionResult Delete([FromQuery] PositionDTO dto)
{
var result = _positionService.Delete(dto);
if (!result)
{
return(Ok(false));
}
return(Ok(true));
}
