public async Task <BasketLineDto> Handle(Request request, CancellationToken cancellationToken)
{
var basketLine = await _context.BasketLines
.Include(b => b.Basket)
.Where(b => b.Id == request.BasketLineId)
.FirstOrDefaultAsync();
basketLine.TicketAmount = request.Quantity;
var basketChangeEvent = new BasketChangeEvent
{
BasketChangeType = BasketChangeTypeEnum.Update,
EventId = basketLine.EventId,
InsertedAt = DateTime.Now,
UserId = basketLine.Basket.UserId
};
await _context.BasketChangeEvents.AddAsync(basketChangeEvent);
await _context.SaveChangesAsync();
return(new BasketLineDto
{
BasketLineId = basketLine.Id,
BasketId = basketLine.BasketId,
EventId = basketLine.EventId,
Price = basketLine.Price,
TicketAmount = basketLine.TicketAmount
});
}
public async Task <IActionResult> Delete(Guid basketId, Guid basketLineId)
{
//if (!await _mediator.Send(new BasketExistsQuery(basketId))) return NotFound();
var basket = await _mediator.Send(new GetBasketByIdQuery(basketId));
if (basket == null)
{
return(NotFound());
}
var basketLine = await _mediator.Send(new GetBasketLineByIdQuery(basketLineId));
if (basketLine == null)
{
return(NotFound());
}
await _mediator.Send(new RemoveBasketLineCommand(basketLine));
// Публикуем удаленные позиции.
var basketChangeEvent = new BasketChangeEvent
{
BasketChangeType = BasketChangeTypeEnum.Remove,
EventId = basketLine.EventId,
InsertedAt = DateTime.Now,
UserId = basket.UserId
};
await _mediator.Send(new AddBasketEventCommand(basketChangeEvent));
return(NoContent());
}
public async Task <IActionResult> Delete(Guid basketId, Guid basketLineId)
{
var basket = await basketRepository.GetBasketById(basketId);
if (basket == null)
{
return(NotFound());
}
var basketLineEntity = await basketLinesRepository.GetBasketLineById(basketLineId);
if (basketLineEntity == null)
{
return(NotFound());
}
basketLinesRepository.RemoveBasketLine(basketLineEntity);
basketLinesRepository.Save();
BasketChangeEvent basketChangeEvent = new BasketChangeEvent
{
BasketChangeType = Wall.Basket.Entity.BasketChangeTypeEnum.Remove,
EventId = basketLineEntity.EventId,
InsertedAt = DateTime.Now,
UserId = basket.UserId
};
await basketChangeEventRepository.AddBasketEvent(basketChangeEvent);
return(NoContent());
}
public async Task AddBasketChangeEvent(BasketChangeEvent basketChangeEvent)
{
await using (var marketingDbContext = new MarketingDbContext(dbContextOptions))
{
await marketingDbContext.BasketChangeEvents.AddAsync(basketChangeEvent);
await marketingDbContext.SaveChangesAsync();
}
}
public async Task <BasketLineDto> Handle(Request request, CancellationToken cancellationToken)
{
var existingBasketLine = await _context.BasketLines
.Include(bl => bl.Event)
.Where(b => b.BasketId == request.BasketId && b.EventId == request.BasketLineForCreation.EventId)
.FirstOrDefaultAsync();
if (existingBasketLine == null)
{
var basketLineForCreation = new BasketLine
{
EventId = request.BasketLineForCreation.EventId,
TicketAmount = request.BasketLineForCreation.TicketAmount,
Price = request.BasketLineForCreation.Price,
BasketId = request.BasketId
};
await _context.BasketLines.AddAsync(basketLineForCreation);
existingBasketLine = basketLineForCreation;
}
else
{
existingBasketLine.TicketAmount += request.BasketLineForCreation.TicketAmount;
}
await _context.SaveChangesAsync();
var basket = await _context.Baskets
.Include(sb => sb.BasketLines)
.Where(b => b.Id == request.BasketId)
.FirstOrDefaultAsync();
var basketChangeEvent = new BasketChangeEvent
{
BasketChangeType = BasketChangeTypeEnum.Add,
EventId = request.BasketLineForCreation.EventId,
InsertedAt = DateTime.Now,
UserId = basket.UserId
};
await _context.BasketChangeEvents.AddAsync(basketChangeEvent);
await _context.SaveChangesAsync();
return(new BasketLineDto
{
BasketLineId = existingBasketLine.Id,
BasketId = existingBasketLine.BasketId,
EventId = existingBasketLine.EventId,
Price = existingBasketLine.Price,
TicketAmount = existingBasketLine.TicketAmount
});
}
public static BasketChangeEventDto From(BasketChangeEvent entity)
{
return(new BasketChangeEventDto
{
Id = entity.Id,
EventId = entity.EventId,
InsertedAt = entity.InsertedAt,
UserId = entity.UserId,
BasketChangeType = entity.BasetChangeType,
});
}
public static BasketChangeEventForPublicationModel ToModel(this BasketChangeEvent source)
{
if (source == null)
{
return(null);
}
return(new BasketChangeEventForPublicationModel
{
Id = source.Id,
EventId = source.EventId,
InsertedAt = source.InsertedAt,
UserId = source.UserId,
BasketChangeTypeModel = (BasketChangeTypeModel)source.BasketChangeType
});
}
public async Task <ActionResult <BasketLine> > Post(Guid basketId, [FromBody] BasketLineForCreation basketLineForCreation)
{
var basket = await basketRepository.GetBasketById(basketId);
if (basket == null)
{
return(NotFound());
}
if (!await eventRepository.EventExists(basketLineForCreation.EventId))
{
var eventFromCatalog = await eventCatalogService.GetEvent(basketLineForCreation.EventId);
eventRepository.AddEvent(eventFromCatalog);
await eventRepository.SaveChanges();
}
var basketLineEntity = mapper.Map <Entities.BasketLine>(basketLineForCreation);
var processedBasketLine = await basketLinesRepository.AddOrUpdateBasketLine(basketId, basketLineEntity);
await basketLinesRepository.SaveChanges();
var basketLineToReturn = mapper.Map <BasketLine>(processedBasketLine);
//log also to the event repo
var basketChangeEvent = new BasketChangeEvent
{
BasketChangeType = BasketChangeTypeEnum.Add,
EventId = basketLineForCreation.EventId,
InsertedAt = DateTime.Now,
UserId = basket.UserId
};
await basketChangeEventRepository.AddBasketEvent(basketChangeEvent);
return(CreatedAtRoute(
"GetBasketLine",
new { basketId = basketLineEntity.BasketId, basketLineId = basketLineEntity.BasketLineId },
basketLineToReturn));
}
public async Task <ActionResult <BasketLineModel> > Post(Guid basketId,
[FromBody] BasketLineForCreationModel basketLineForCreation)
{
var basket = await _mediator.Send(new GetBasketByIdQuery(basketId));
if (basket == null)
{
return(NotFound());
}
if (!await _mediator.Send(new EventExistsQuery(basketLineForCreation.EventId)))
{
var eventFromCatalog = await _catalogService.GetEvent(basketLineForCreation.EventId);
await _mediator.Send(new AddEventCommand(eventFromCatalog.ToDomain()));
}
var basketLineEntity = basketLineForCreation.ToDomain();
var processedBasketLine =
await _mediator.Send(new AddOrUpdateBasketLineCommand(basketId, basketLineEntity));
var basketLineToReturn = processedBasketLine.ToModel();
var basketChangeEvent = new BasketChangeEvent
{
BasketChangeType = BasketChangeTypeEnum.Add,
EventId = basketLineForCreation.EventId,
InsertedAt = DateTime.Now,
UserId = basket.UserId
};
await _mediator.Send(new AddBasketEventCommand(basketChangeEvent));
return(CreatedAtRoute(
"GetBasketLine",
new { basketId = basketLineEntity.BasketId, basketLineId = basketLineEntity.BasketLineId },
basketLineToReturn));
}
public async Task <IActionResult> Delete(string basketId, string basketLineId)
{
var basket = await _dbContext.Baskets.FirstOrDefaultAsync(basket => basket.Id == basketId);
if (basket == null)
{
return(NotFound());
}
var basketLineEntity = await _dbContext
.BasketLines
.Include(line => line.Event)
.FirstOrDefaultAsync(line => line.Id == basketLineId)
;
if (basketLineEntity == null)
{
return(NotFound());
}
_dbContext.Remove(basketLineEntity);
await _dbContext.SaveChangesAsync();
// publish removal event
var basketChangeEvent = new BasketChangeEvent()
{
Id = basketLineEntity.Id,
EventId = basketLineEntity.EventId,
InsertedAt = DateTime.Now.ToDbDateTimeString(),
UserId = basket.UserId,
BasetChangeType = BasketChangeTypeEnum.Remove
};
await _dbContext.AddAsync(basketChangeEvent);
await _dbContext.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult <BasketLine> > CreateBasketLine(
string basketId,
[FromBody] BasketLineForCreation basketLineForCreation
)
{
// basket이 없어서 basketLine 이 없는 건지, 아니면, basket이 없는건지 구별.
var basket = await _dbContext.Baskets.FirstOrDefaultAsync(b => b.Id == basketId);
if (basket == null)
{
return(NotFound());
}
// BasketLine과 관련된 Event 데이터를 끌어와서 저장
//
// [마이크로서비스]
// - Events 가 서비스 2군데서 중복 저장하고 있다.
// - 의존성이 없다고 하지만, 결국, EventCatalogService에 의존적 (CQRS 적용이 필요?!)
var @event =
await _dbContext.Events.FirstOrDefaultAsync(@event => @event.Id == basketLineForCreation.EventId);
if (@event == null)
{
var eventFromCatalog = await _eventCatalogService.GetEvent(basketLineForCreation.EventId);
await _dbContext.Events.AddAsync(eventFromCatalog);
await _dbContext.SaveChangesAsync();
@event = eventFromCatalog;
}
var basketLineEntity = await _dbContext
.BasketLines
.Include(line => line.Event)
.Where(line => line.EventId == basketLineForCreation.EventId && line.BasketId == basketId)
.FirstOrDefaultAsync()
;
if (basketLineEntity == null)
{
basketLineEntity = BasketLineEntityMapper.From(basketId, basketLineForCreation);
basketLineEntity.Id = Guid.NewGuid().ToDbStringId();
basketLineEntity.Event = @event;
await _dbContext.BasketLines.AddAsync(basketLineEntity);
}
else
{
basketLineEntity.TicketAmount += basketLineForCreation.TicketAmount;
}
await _dbContext.SaveChangesAsync();
// event repo
var basketChangeEvent = new BasketChangeEvent()
{
Id = Guid.NewGuid().ToDbStringId(),
EventId = basketLineForCreation.EventId,
InsertedAt = DateTime.Now.ToDbDateTimeString(),
UserId = basket.UserId,
BasetChangeType = BasketChangeTypeEnum.Add
};
await _dbContext.BasketChangeEvents.AddAsync(basketChangeEvent);
await _dbContext.SaveChangesAsync();
var basketLineDto = BasketLineDtoMapper.From(basketLineEntity);
return(CreatedAtRoute(
"GetBasketLine",
new
{
basketId = basket.Id,
basketLineId = basketLineEntity.Id,
},
basketLineDto
));
}
public async Task AddBasketEvent(BasketChangeEvent basketChangeEvent)
{
await _basketDbContext.BasketChangeEvents.AddAsync(basketChangeEvent);
await _basketDbContext.SaveChangesAsync();
}
