public void OnCreate(CreateAuction message)
{
AuctionId = message.AuctionId;
Title = message.Title;
OpenBid = message.OpeningBid;
Console.WriteLine(Title + " Auction Created with opening bid of $" + message.OpeningBid + " for Auction " + message.AuctionId);
Console.WriteLine("Current State " + CurrentState.Name);
}
public ActionResult Create()
{
var parameters = db.Parameters.First();
var model = new CreateAuction {
Duration = parameters.D, CurrencyName = parameters.C
};
return(View(model));
}
public Auction(CreateAuction auction, string imagePath, ApplicationUser user)
{
Name = auction.Name;
ImagePath = imagePath;
Duration = auction.Duration;
StartPrice = auction.StartPrice;
CurrentPrice = 0;
CreationTime = DateTime.Now;
State = AuctionState.READY;
Creator = user;
}
public async Task <IActionResult> Create(CreateAuction model)
{
if (ModelState.IsValid)
{
DateTime current = DateTime.UtcNow;
string id = _signInManager.UserManager.GetUserId(User);
bool boolRes = true;
if (model.Artworkidchosen > 0)
{
if (_unitOfWork.Artworks.IsAvailableToBeSold(model.Artworkidchosen))
{
var newAuction = _unitOfWork.Auctions.Add(id, model.Artworkidchosen, model.StartingPrice, current);
await _unitOfWork.Save();
int auctionId = newAuction.AuctionId;
var createdAuction = this._unitOfWork.Auctions.GetAuction(auctionId);
var data = new
{
AuctionId = auctionId,
ArtWorkName = createdAuction.ArtWork.Name,
Author = createdAuction.ArtWork.Author.FirstName + " " + createdAuction.ArtWork.Author.LastName,
StartingPrice = createdAuction.StartingPrice,
Caption = createdAuction.ArtWork.Caption,
PostedOn = createdAuction.DateTime,
User = createdAuction.User.FirstName + " " + createdAuction.User.LastName,
ReadMoreLink = Url.Action("AuctionDetails", "Auction", new { auct = auctionId })
};
await this.hubContext.Clients.Group("Authenticated Users").SendAsync("AddAuctionAuthenticated", data);
await this.hubContext.Clients.Group("Unauthenticated Users").SendAsync("AddAuctionUnAuthenticated", data);
}
else
{
boolRes = false;
}
}
else
{
boolRes = false;
}
if (boolRes)
{
return(RedirectToAction(nameof(ResultOperation), new { op = "succeded" }));
}
else
{
return(RedirectToAction(nameof(ResultOperation), new { op = "failed" }));
}
}
else
{
return(View());
}
}
public async Task <string> PostAuction([FromBody] CreateAuction auction)
{
if (auction == null || !ModelState.IsValid)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
var auctionId = await ModifyAuctionsFacade.AddAuctionAsync(auction);
if (auctionId == 0)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
return($"Created auction with id: {auctionId}.");
}
public static CommandResult Handle(State state, CreateAuction createAuction)
{
switch (state)
{
case EmptyState _:
var auctionCreated = AuctionCreated.Create(createAuction.Auction);
return(CommandResultSuccess.Create(new List <EventPayload> {
auctionCreated
}));
default:
return(CommandResultFailure.Create("Auction already created"));
}
}
public CreateAuction ConvertFromAuctionSetUpToCreateAuction(AuctionSetUpModel aSU, string userName)
{
CreateAuction cA = new CreateAuction
{
UserName = userName,
StartPrice = aSU.StartPrice,
BuyOutPrice = aSU.BuyOutPrice,
BidInterval = aSU.BidInterval,
Description = aSU.Description,
EndDate = aSU.EndDate,
Category = aSU.SelectedCategory
};
return(cA);
}
public AuctionData ConvertFromCreateAuctionToAuctionData(CreateAuction createAuction)
{
AuctionData aD = new AuctionData
{
UserName = createAuction.UserName,
StartPrice = createAuction.StartPrice,
BuyOutPrice = createAuction.BuyOutPrice,
BidInterval = createAuction.BidInterval,
Description = createAuction.Description,
EndDate = createAuction.EndDate,
Category = createAuction.Category,
};
return(aD);
}
public bool InsertAuction(CreateAuction createAuction)
{
IAuctionService aSClient = new AuctionServiceClient("BasicHttpBinding_IAuctionService");
ConvertDataModel converter = new ConvertDataModel();
bool confirmed = false;
int id = aSClient.InsertAuction(converter.ConvertFromCreateAuctionToAuctionData(createAuction));
if (id != -1)
{
confirmed = true;
}
return(confirmed);
}
public ActionResult Create(CreateAuction auction)
{
if (ModelState.IsValid && auction.StartPrice > 0)
{
var currencyName = db.Parameters.First().C;
var currencyValue = db.Currencies.Where(c => c.Name == currencyName).First().Value;
auction.StartPrice /= currencyValue;
string imagePath;
string format;
if (auction.UploadedPhoto == null)
{
imagePath = "~/Images/default-image";
format = ".jpeg";
}
else
{
imagePath = string.Concat("~/Images/", FileNameGenerator.generate());
try {
WebImage img = new WebImage(auction.UploadedPhoto.InputStream);
img.Resize(256, 256, true, true);
format = "." + img.ImageFormat;
var path = Server.MapPath(imagePath);
img.Save(path);
} catch (ArgumentException)
{
ViewBag.ErrorMessage = "Image format not valid";
return(View(auction));
}
}
var userId = User.Identity.GetUserId();
var user = db.Users.Find(userId);
Auction auctionModel = new Auction(auction, string.Concat(imagePath.Substring(1), format), user);
db.Auctions.Add(auctionModel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
if (auction.StartPrice <= 0)
{
ViewBag.ErrorMessage = "Start price must be greater than 0!";
}
return(View(auction));
}
public async Task <int> AddAuctionAsync(CreateAuction auction)
{
if (auction == null)
{
return(0);
}
using (var uow = UnitOfWorkProvider.Create())
{
if (await userService.GetAsync(auction.UserId, false) == null)
{
return(0);
}
var res = auctionService.Create(auctionService.MapToBase(auction));
await uow.Commit();
return(res.Id);
}
}
public ActionResult Create([FromBody] CreateAuctionDto dto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var aggregateId = Guid.NewGuid();
var auction = AuctionDetails.Create(DateTime.UtcNow.AddMinutes(1), dto.StartingPrice, dto.Description);
var createAuction = CreateAuction.Create(auction);
var command = Command.Create(aggregateId, createAuction);
var result = _commandHandler.HandleCommand(command);
switch (result)
{
case CommandResultSuccess _:
return(Ok());
default:
return(Conflict());
}
}
public void AuctionSaga_Created_When_CreateAuction_Received_And_Transitioned_To_OpenState()
{
_context.CorrelationId = NewId.NextGuid();
_context.AuctionId = NewId.NextGuid();
PipelineViewer.Trace(_context.LocalBus.InboundPipeline);
PipelineViewer.Trace(_context.LocalBus.OutboundPipeline);
var message = new CreateAuction()
{
CorrelationId = _context.CorrelationId,
AuctionId = _context.AuctionId
};
_context.LocalBus.Publish(message);
var saga = _context.Repository.ShouldContainSaga(_context.CorrelationId);
saga.ShouldBeInState(AuctionSaga.Open);
}
public bool CreateAuction(CreateAuction createAuction /**IEnumerable<AuctionPicture> aP,**/)
{
AuctionService aS = new AuctionService();
return(aS.InsertAuction(createAuction));
}
