public async Task <DirectionDto> GetDirectionByIdAsync(Guid id)
{
DirectionDto direction = DirectionConverter.Convert(await _directionRepo.GetByIdAsync(id));
direction.Administration = AdministrationConverter.Convert(await _adminRepo.GetByDirectionIdAsync(id));
direction.Courses = CourseConverter.Convert(await _courseRepo.GetByDirectionIdAsync(id));
return(direction);
}
public int addDirection(DirectionDto dto)
{
Direction d = new Direction();
d.name = dto.name;
_unitOfWork.DirectionRepository.Add(d);
_unitOfWork.SaveChanges();
return(d.Id);
}
public DirectionDto getDirectionById(int id)
{
DirectionDto dto = new DirectionDto();
var x = _unitOfWork.DirectionRepository.FindById(id);
dto.Id = x.Id;
dto.name = x.name;
return(dto);
}
public static Direction Convert(DirectionDto item)
{
return(new Direction
{
Id = item.Id,
Description = item.Description,
Name = item.Name,
Img = item.Img,
LoadImg = item.LoadImg
});
}
public bool EditDirection(int id, DirectionDto dto)
{
var d = _unitOfWork.DirectionRepository.FindById(id);
if (d == null)
{
return(false);
}
d.name = dto.name;
_unitOfWork.DirectionRepository.Update(d);
_unitOfWork.SaveChanges();
return(true);
}
public List <DirectionDto> getAllDirections()
{
List <DirectionDto> res = new List <DirectionDto>();
DirectionDto dto = new DirectionDto();
foreach (var item in _unitOfWork.DirectionRepository.GetAll())
{
dto.Id = item.Id;
dto.name = item.name;
res.Add(dto);
dto = new DirectionDto();
}
return(res);
}
public async Task <bool> Update(DirectionDto directionDto)
{
DataAccess.Models.Direction value = Mapper.Map <DataAccess.Models.Direction>(directionDto);
try
{
db.Entry(value).State = EntityState.Modified;
await db.SaveChangesAsync();
return(true);
}
catch { return(false); }
}
public async Task <ActionResult <DirectionDto> > Post([FromBody] DirectionDto item)
{
try
{
if (item == null)
{
return(BadRequest());
}
return(Ok(await _supervisor.CreateDirectionAsync(item)));
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
private async Task SendRequest(DirectionDto directionDto)
{
var request = new RestRequest("api/direction");
request.Method = Method.POST;
request.AddParameter("application/json", JsonSerializer.Serialize(directionDto), ParameterType.RequestBody);
this.logger.Info($"Отправляем POST запрос {request.Resource} {JsonSerializer.Serialize(directionDto)}");
var response = await _restClient.ExecutePostTaskAsync(request);
if (!response.IsSuccessful)
{
GameException = $"Не удалось получить ответ на POST запрос {request.Resource}";
this.logger.Error($"Не удалось получить ответ на POST запрос {request.Resource}");
}
}
public async Task <ActionResult> Delete(DirectionDto value)
{
try
{
if (ModelState.IsValid)
{
await db.Delete(value);
return(RedirectToAction("Index"));
}
}
catch
{
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
return(View("index"));
}
public async Task <ActionResult <List <AdministrationDto> > > GetByDirection(Guid id)
{
try
{
DirectionDto direction = await _supervisor.GetDirectionByIdAsync(id);
if (direction == null)
{
return(NotFound());
}
return(Ok(await _supervisor.GetAdministrationByDirectionIdAsync(id)));
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
private DirectionDto ParseJason(string jsonResult)
{
var dto = new DirectionDto();
try
{
dto.Parsed = JObject.Parse(jsonResult);
JavaScriptSerializer parser = new JavaScriptSerializer();
var responseData = parser.Deserialize <RootObject>(dto.Parsed.ToString());
dto.Routes = responseData;
return(dto);
}
catch (Exception ex)
{
dto.Error = ex.Message;
return(dto);
}
}
public IActionResult PostDirection([FromBody] DirectionDto newDirection)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
this.logger.LogInformation($"Поступил запрос {JsonSerializer.Serialize(newDirection)}");
this.gameService.Game.UpdateDirection(newDirection.Direction);
return(Ok());
}
catch (Exception ex)
{
this.logger.LogError(ex, "Ошибка при обработке запроса");
return(StatusCode(500, "Ошибка при обработке запроса"));
}
}
public Trade(long id,
string userName,
string currencyPair,
decimal spotRate,
DateTimeOffset tradeDate,
DateTimeOffset valueDate,
DirectionDto direction,
decimal notional,
string dealtCurrency)
{
RaiseEvent(new TradeCreatedEvent(id,
userName,
currencyPair,
spotRate,
tradeDate,
valueDate,
direction.ToString(),
notional,
dealtCurrency));
}
public Trade(long id,
string userName,
string currencyPair,
decimal spotRate,
DateTime tradeDate,
DateTime valueDate,
DirectionDto direction,
int notional,
string dealtCurrency)
{
RaiseEvent(new TradeCreatedEvent(id,
userName,
currencyPair,
spotRate,
DateUtils.ToSerializationFormat(tradeDate),
DateUtils.ToSerializationFormat(valueDate),
direction.ToString(),
notional,
dealtCurrency));
}
public async Task <bool> Delete(DirectionDto directionDto)
{
try
{
DataAccess.Models.Direction value = Mapper.Map <DataAccess.Models.Direction>(directionDto);
value.DeletedDateTime = DateTime.Now;
value.IsDeleted = true;
db.Entry(value).State = EntityState.Modified;
await db.SaveChangesAsync();
return(true);
}
catch
{
return(false);
}
}
public async Task <ActionResult <DirectionDto> > Put([FromBody] DirectionDto item)
{
try
{
if (item == null || item.Id == null)
{
return(BadRequest());
}
if (await _supervisor.UpdateDirectionAsync(item))
{
return(Ok(item));
}
else
{
return(NotFound());
}
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
public Trade(
long tradeId,
string traderName,
string currencyPair,
decimal notional,
string dealtCurrency,
DirectionDto direction,
decimal spotRate,
DateTimeOffset tradeDate,
DateTimeOffset valueDate,
TradeStatusDto status)
{
TradeId = tradeId;
TraderName = traderName;
CurrencyPair = currencyPair;
Notional = notional;
DealtCurrency = dealtCurrency;
Direction = direction;
SpotRate = spotRate;
TradeDate = tradeDate;
ValueDate = valueDate;
Status = status;
}
public Trade(
long tradeId,
string traderName,
string currencyPair,
decimal notional,
string dealtCurrency,
DirectionDto direction,
decimal spotRate,
DateTime tradeDate,
DateTime valueDate,
TradeStatusDto status)
{
TradeId = tradeId;
TraderName = traderName;
CurrencyPair = currencyPair;
Notional = notional;
DealtCurrency = dealtCurrency;
Direction = direction;
SpotRate = spotRate;
TradeDate = tradeDate;
ValueDate = valueDate;
Status = status;
}
public ActionResult EditDirection(int id, DirectionDto dto)
{
var x = _IAuctionService.EditDirection(id, dto);
return(RedirectToAction("AddDirection"));
}
public ActionResult AddDirection(DirectionDto dto)
{
_IAuctionService.addDirection(dto);
return(RedirectToAction("AddDirection"));
}
public async Task <DirectionDto> CreateDirectionAsync(DirectionDto item)
{
return(DirectionConverter.Convert(await _directionRepo.CreateAsync(DirectionConverter.Convert(item))));
}
public async Task <bool> UpdateDirectionAsync(DirectionDto item)
{
return(await _directionRepo.UpdateAsync(DirectionConverter.Convert(item)));
}
public DirectionDto Get(int id)
{
DirectionDto value = Mapper.Map <DirectionDto>(db.Directions.Find(id));
return(value);
}
