public async Task <IActionResult> RegisterAsync([FromBody] RegisterFlight command) { try { if (ModelState.IsValid) { // insert flight Flight flight = Mapper.Map <Flight>(command); _dbContext.Flights.Add(flight); await _dbContext.SaveChangesAsync(); // send event var e = Mapper.Map <FlightRegistered>(command); await _messagePublisher.PublishMessageAsync(e.MessageType, e, ""); //return result return(CreatedAtRoute("GetByFlightNumber", new { flightNumber = flight.FlightNumber }, flight)); } return(BadRequest()); } catch (DbUpdateException) { ModelState.AddModelError("", "Unable to save changes. " + "Try again, and if the problem persists " + "see your system administrator."); return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public async Task CreateTweet(string id, string tweetContent) { var tweet = new Entities.Tweet { TweetDateTime = DateTime.Now.ToString("d/MM/yyyy"), TimeStamp = DateTime.Now, Id = Guid.NewGuid().ToString(), UserId = id, TweetContent = tweetContent }; if (await CheckForProfanity(tweet)) { await _messagePublisher.PublishMessageAsync("NewProfanityTweetMessage", new { TweetDateTime = tweet.TweetDateTime, TimeStamp = tweet.TimeStamp, Id = tweet.Id, UserId = tweet.UserId, TweetContent = tweet.TweetContent }); } if (tweetContent.Contains("#")) { await _messagePublisher.PublishMessageAsync("NewTopicTweetMessage", new { Id = tweet.Id, TweetContent = tweet.TweetContent }); } await _messagePublisher.PublishMessageAsync("NewPostedTweetMessage", new { TweetDateTime = tweet.TweetDateTime, TimeStamp = tweet.TimeStamp, Id = tweet.Id, UserId = tweet.UserId, TweetContent = tweet.TweetContent }); _tweets.InsertOne(tweet); }
public async Task <bool> FollowUser(string followerId, string followingId) { if (followerId == followingId) { return(false); } if (FollowExists(followerId, followingId)) { return(false); } var follow = new Follow { Id = Guid.NewGuid().ToString(), Follower = followerId, Following = followingId }; await _messagePublisher.PublishMessageAsync("AddFollowerMessage", new { Id = follow.Id, FollowerId = follow.Follower, FollowingId = follow.Following }); await _followRepository.AddOneFollower(follow); return(true); }
public async Task <IActionResult> RegisterBaggageSetAsync([FromBody] RegisterBaggageSet command) { try { if (ModelState.IsValid) { // insert baggageset BaggageSet baggageSet = Mapper.Map <BaggageSet>(command); baggageSet.LoadedOnFlight = false; baggageSet.DeliveredToBaggageClaim = false; _dbContext.BaggageSets.Add(baggageSet); await _dbContext.SaveChangesAsync(); // send event var e = Mapper.Map <BaggageSetRegistered>(command); await _messagePublisher.PublishMessageAsync(e.MessageType, e, ""); // return result return(CreatedAtRoute("GetByScheduledFlightId", new { scheduledFlightId = baggageSet.ScheduledFlightId }, baggageSet)); } return(BadRequest()); } catch (DbUpdateException) { ModelState.AddModelError("", "Unable to save changes. " + "Try again, and if the problem persists " + "see your system administrator."); return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public async Task <bool> EditProfile(EditProfileMessage message) { var user = await GetUserById(message.Id); if (user == null) { return(false); } if (user.Email != message.Email) { if (_userService.VerifyUniqueEmail(message.Email)) { return(false); } await _messagePublisher.PublishMessageAsync("EmailChangedMessage", new { Id = user.Id, Email = message.Email }); } if (user.Nickname != message.Nickname) { await _messagePublisher.PublishMessageAsync("ProfileChangedMessage", new { Id = user.Id, Nickname = message.Nickname }); } user.Email = message.Email; user.Nickname = message.Nickname; _userContext.Update(user); await _userContext.SaveChangesAsync(); return(true); }
public async Task <bool> RegisterUser(RegisterMessage message) { var user = new User { Id = Guid.NewGuid().ToString(), Email = message.Email, Username = message.Username, Nickname = message.Username, Image = "default.png", Location = "", FollowersCount = 0, FollowingCount = 0, Verified = false }; _userContext.Add(user); _userContext.SaveChanges(); await _messagePublisher.PublishMessageAsync("NewUserMessage", new { Id = user.Id, Email = user.Email, Username = user.Username, Password = message.Password }); await _messagePublisher.PublishMessageAsync("NewProfileMessage", new { Id = user.Id, Username = user.Username, Nickname = user.Nickname, Image = user.Image }); return(true); }
public async Task <IActionResult> RegisterAsync([FromBody] RegisterVehicle command) { try { if (ModelState.IsValid) { // insert vehicle Vehicle vehicle = command.MapToVehicle(); _dbContext.Vehicles.Add(vehicle); await _dbContext.SaveChangesAsync(); // send event var e = Mappers.MapToVehicleRegistered(command); await _messagePublisher.PublishMessageAsync(e.MessageType, e, ""); //return result return(CreatedAtRoute("GetByLicenseNumber", new { licenseNumber = vehicle.LicenseNumber }, vehicle)); } return(BadRequest()); } catch (DbUpdateException) { ModelState.AddModelError("", "Unable to save changes. " + "Try again, and if the problem persists " + "see your system administrator."); return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public async Task <IActionResult> RegisterAsync([FromBody] RegisterCustomer command) { try { if (ModelState.IsValid) { // insert customer Customer customer = Mapper.Map <Customer>(command); _dbContext.Customers.Add(customer); await _dbContext.SaveChangesAsync(); // send event CustomerRegistered e = Mapper.Map <CustomerRegistered>(customer); await _messagePublisher.PublishMessageAsync(e.MessageType, e, ""); // return result return(CreatedAtRoute("GetByCustomerId", new { customerId = customer.CustomerId }, customer)); } return(BadRequest()); } catch (DbUpdateException) { ModelState.AddModelError("", "Unable to save changes. " + "Try again, and if the problem persists " + "see your system administrator."); return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public async Task <ShipService> CreateShipService(ShipService shipService) { var addedShipService = await _shipServiceService.AddAsync(shipService); await _messagePublisher.PublishMessageAsync(MessageTypes.ServiceCreated, shipService); return(addedShipService); }
public async Task <bool> HandleMessageAsync(string messageType, string message, IDictionary <string, object> userproperties) { try { var id = Encoding.UTF8.GetString((byte[])userproperties["Id"]); var ordertype = Encoding.UTF8.GetString((byte[])userproperties["OrderType"]); var sendingdate = Encoding.UTF8.GetString((byte[])userproperties["SendingDate"]); List <ValueDTO> values = new List <ValueDTO>(); values.Add(new ValueDTO() { Key = "Id", Value = id }); values.Add(new ValueDTO() { Key = "OrderType", Value = ordertype }); values.Add(new ValueDTO() { Key = "SendingDate", Value = sendingdate }); var valresponse = await _service.Validate("CardCompos", ".json", message); var streamid = Guid.NewGuid(); var filename = string.Format("{0}_{1}.json", id, messageType); if (await _service.AddToStorage(streamid, message, filename, "json", valresponse.Valid)) { Guid headerid = Guid.NewGuid(); var xx = await _service.AddHeader(headerid, "CardCompos"); var yy = await _service.AddFileExtension(headerid, streamid, filename, valresponse.Valid, string.Join("\n", valresponse.Messages), values); DeliveryCompleted e = await _service.CreateFowardingCommand(headerid); await _messagePublisher.PublishMessageAsync(messageType, e, "DataService", null); //await _messagePublisher.PublishMessageAsync(messageType, e, "", null); await _messagePublisher.PublishMessageAsync(messageType, e, "notification", null); } //scaler aanroepen //status terugkoppelen. } catch (Exception ex) { return(false); } return(true); }
public async Task <IActionResult> ApproveRequestToChef([FromBody] Request request) { if (request.RequestType == RequestType.Upgrade_To_Chef) { await _moderationService.ApproveRequest(request); await _messagePublisher.PublishMessageAsync("UserRoleUpdated", new { request.UserId, Role = 1 }); return(Ok()); } return(BadRequest()); }
private async Task ProcessTransferredFundEvent(TransferFundCommand request, Account sourceAccount, Account destinationAccount) { var transferredFundEvent = new TransferredFund { SourceAccount = sourceAccount.AccountNumber, DestinationAccount = destinationAccount.AccountNumber, Amount = request.Amount, Status = TransactionStatus.SUCCESS, Remarks = (string.IsNullOrEmpty(request.Remarks) ? "" : request.Remarks) }; await _messagePublisher.PublishMessageAsync(transferredFundEvent.MessageType, transferredFundEvent, ""); }
public async Task <IActionResult> PlanMaintenanceJobAsync(DateTime date, [FromBody] PlanMaintenanceJob command) { try { if (ModelState.IsValid) { // get planning WorkshopPlanning planning = await _planningRepo.GetWorkshopPlanningAsync(date); if (planning == null) { return(NotFound()); } // handle command try { IEnumerable <Event> events = planning.PlanMaintenanceJob(command); // persist await _planningRepo.SaveWorkshopPlanningAsync(planning, events); // publish event foreach (var e in events) { await _messagePublisher.PublishMessageAsync(e.MessageType, e, ""); } // return result return(CreatedAtRoute("GetByDate", new { date = planning.Date }, planning)); } catch (BusinessRuleViolationException ex) { return(StatusCode(StatusCodes.Status409Conflict, new BusinessRuleViolation { ErrorMessage = ex.Message })); } } return(BadRequest()); } catch (ConcurrencyException) { ModelState.AddModelError("ErrorMessage", "Unable to save changes. " + "Try again, and if the problem persists " + "see your system administrator."); return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public async Task <WorkshopPlanning> HandleCommandAsync(DateTime planningDate, FinishMaintenanceJob command) { // get planning var aggregateId = WorkshopPlanningId.Create(planningDate); var planning = await _planningRepo.GetByIdAsync(aggregateId); if (planning == null) { return(null); } // handle command planning.FinishMaintenanceJob(command); // persist IEnumerable <Event> events = planning.GetEvents(); await _planningRepo.SaveAsync( planning.Id, planning.OriginalVersion, planning.Version, events); // publish event foreach (var e in events) { await _messagePublisher.PublishMessageAsync(e.MessageType, e, ""); } // return result return(planning); }
public async Task <WorkshopPlanning> HandleCommandAsync(DateTime planningDate, FinishMaintenanceJob command) { // get planning WorkshopPlanning planning = await _planningRepo.GetWorkshopPlanningAsync(planningDate); if (planning == null) { return(null); } // handle command IEnumerable <Event> events = planning.FinishMaintenanceJob(command); // persist await _planningRepo.SaveWorkshopPlanningAsync(planning, events); // publish event foreach (var e in events) { await _messagePublisher.PublishMessageAsync(e.MessageType, e, ""); } // return result return(planning); }
public async Task <bool> UnApproveProfanityTweet(string tweetId) { var tweet = _tweets.Find(t => t.Id == tweetId).FirstOrDefault(); if (tweet == null) { return(false); } tweet.TweetStatus = Status.Unapproved; await _tweets.ReplaceOneAsync(t => t.Id == tweetId, tweet); await _messagePublisher.PublishMessageAsync("UnApproveTweetMessage", new { TweetId = tweetId }); return(true); }
public async Task <IActionResult> PlaceOrder(string orderId, [FromBody] PlaceOrder orderCommand) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var order = await _dbContext.Orders.FirstOrDefaultAsync(o => o.OrderId == orderId); if (order == null) { return(NotFound()); } order.AfterPayment = orderCommand.AfterPayment; if (order.AfterPayment) { order.AddStateChange(OrderState.AWAITINGAFTERPAYMENT); } else { order.AddStateChange(OrderState.PAYMENTINPROGRESS); } await _dbContext.SaveChangesAsync(); OrderPlaced e = Mapper.Map <OrderPlaced>(order); await _messagePublisher.PublishMessageAsync(e.MessageType, e, ""); return(AcceptedAtRoute("GetByOrderId", new { orderId = order.OrderId }, order)); }
private async Task <bool> SourceHasSufficientAmount(TransferFundCommand request) { var account = _unitOfWork.Account.GetFirstOrDefault(a => a.AccountNumber == request.SourceAccount); var inquireBalanceEvent = new InquireBalance { AccountId = account.AccountId, Balance = account.Balance, TransactionAmount = request.Amount, Status = (account.Balance >= request.Amount ? TransactionStatus.SUCCESS : TransactionStatus.INSUFFICIENT_FUNDS) }; await _messagePublisher.PublishMessageAsync(inquireBalanceEvent.MessageType, inquireBalanceEvent, ""); return(account.Balance >= request.Amount); }
public async Task <IActionResult> ResetPassword(string email) // This endpoint may not be used in production, instead sending email to admin for resetting password { var user = await _userManager.FindByEmailAsync(email); var restToken = await _userManager.GeneratePasswordResetTokenAsync(user); var resetLink = Url.Action("ResetPassword", "Account", new { token = restToken }, protocol: HttpContext.Request.Scheme); // Send email - Send message to message queue(notificaiton) - integration event var emailBody = ""; EmailNotificationEvent e = new EmailNotificationEvent(new Guid(), email, "Password Reset", emailBody); try { await _messagePublisher.PublishMessageAsync(e.MessageType, e, "notification"); Log.Information("Message {MessageType} with Id {MessageId} has been published successfully", e.MessageType, e.MessageId); } catch (Exception ex) { //throw ex; Log.Error(ex, "Error while publishing {MessageType} message with id {MessageId}.", e.MessageType, e.MessageId); } return(Ok(resetLink)); }
private async Task RealTimeJobs() { //initialiseren realtimejobs await _realtimeservice.InitAsync(); while (true) { var triggers = await _realtimeservice.Process(); //if (DateTime.Now.Subtract(_lastCheck).Days > 0) //{ foreach (var tr in triggers) { await _messagePublisher.PublishMessageAsync(tr.MessageType, tr, ""); } //} await Task.Delay(60000); } }
public async Task <WorkshopPlanning> HandleCommandAsync(DateTime planningDate, PlanMaintenanceJob command) { List <Event> events = new List <Event>(); // get or create workshop-planning WorkshopPlanning planning = await _planningRepo.GetWorkshopPlanningAsync(planningDate); if (planning == null) { events.AddRange(WorkshopPlanning.Create(planningDate, out planning)); } // handle command events.AddRange(planning.PlanMaintenanceJob(command)); // persist await _planningRepo.SaveWorkshopPlanningAsync( planning.Id, planning.OriginalVersion, planning.Version, events); // publish event foreach (var e in events) { await _messagePublisher.PublishMessageAsync(e.MessageType, e, ""); } // return result return(planning); }
public async Task <dynamic> Post([FromBody] UpdateStatus command) { try { if (ModelState.IsValid) { Status status = _mapper.Map <UpdateStatus, Status>(command); _dbContext.Add(status); int result = await _dbContext.SaveChangesAsync(); // send event StatusReceived message = Mapper.Map <StatusReceived>(command); await _messagePublisher.PublishMessageAsync(message.MessageType, message, "StatusReceived"); //return result return(result > 0 ? new { Saved = true, } : new { Saved = false, }); } return(BadRequest()); } catch (DbUpdateException) { ModelState.AddModelError("", "Unable to save changes. " + "Try again, and if the problem persists " + "see your system administrator."); return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public async Task <IActionResult> RegisterAsync([FromBody] RegisterVehicle command) { try { if (ModelState.IsValid) { // check invariants if (!Regex.IsMatch(command.LicenseNumber, NUMBER_PATTERN, RegexOptions.IgnoreCase)) { return(BadRequest($"The specified license-number '{command.LicenseNumber}' was not in the correct format.")); } // insert vehicle Vehicle vehicle = command.MapToVehicle(); _dbContext.Vehicles.Add(vehicle); await _dbContext.SaveChangesAsync(); // send event var e = VehicleRegistered.FromCommand(command); await _messagePublisher.PublishMessageAsync(e.MessageType, e, ""); //return result return(CreatedAtRoute("GetByLicenseNumber", new { licenseNumber = vehicle.LicenseNumber }, vehicle)); } return(BadRequest()); } catch (DbUpdateException) { ModelState.AddModelError("", "Unable to save changes. " + "Try again, and if the problem persists " + "see your system administrator."); return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public async Task <bool> HandleMessageAsync(string messageType, string message, IDictionary <string, object> userproperties) { try { switch (messageType) { case "Fulfilment": default: //hier aan de queue toevoegen JObject order = JObject.Parse(message); var id = userproperties.ContainsKey("Id") ? userproperties["Id"].ToString() : string.Empty; var sendingdate = userproperties.ContainsKey("SendingDate") ? userproperties["SendingDate"].ToString() : string.Empty; var dict = new Dictionary <string, object>() { { "Id", id }, { "OrderType", messageType }, { "SendingDate", sendingdate } }; await _messagePublisher.PublishMessageAsync(messageType, order, string.Empty, dict); break; } } catch (Exception ex) { return(false); } return(true); }
public async Task <WorkshopPlanning> HandleCommandAsync(DateTime planningDate, UpdateMaintenanceJob command) { // get or create workshop-planning WorkshopPlanning planning = await planningRepository.GetWorkshopPlanningAsync(planningDate); if (planning == null) { return(null); } // handle command planning.UpdateMaintenanceJob(command); // persist IEnumerable <Event> events = planning.GetEvents(); await planningRepository.SaveWorkshopPlanningAsync( planning.Id, planning.OriginalVersion, planning.Version, events); // publish event foreach (var e in events) { await messagePublisher.PublishMessageAsync(e.MessageType, e, ""); } // return result return(planning); }
private async Task <bool> HasValidAccount(WithdrawCommand request) { var account = _unitOfWork.Account.GetFirstOrDefault(a => a.AccountNumber == request.AccountNumber); var checkAccountValidityEvent = new CheckAccountValidity { AccountId = account.AccountId, TransactionType = TransactionTypes.WITHDRAWAL, Balance = account.Balance, Status = (account.IsValid ? AccountStatus.VALID : AccountStatus.ACCOUNT_DISABLED) }; await _messagePublisher.PublishMessageAsync(checkAccountValidityEvent.MessageType, checkAccountValidityEvent, ""); return(account.IsValid); }
public async Task <IActionResult> RegisterAsync([FromBody] RegisterInsurance command) { try { if (ModelState.IsValid) { // insert insurance Insurance insurance = Mapper.Map <Insurance>(command); _dbContext.Insurances.Add(insurance); await _dbContext.SaveChangesAsync(); // send event var e = Mapper.Map <InsuranceRegistered>(command); await _messagePublisher.PublishMessageAsync(e.MessageType, e, ""); //return result return(CreatedAtRoute("GetInsuranceById", new { insuranceId = insurance.InsuranceId }, insurance)); } return(BadRequest()); } catch (DbUpdateException ex) { ModelState.AddModelError("", "Unable to save changes. " + "Try again, and if the problem persists " + "see your system administrator."); return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public async Task <IActionResult> PostAsync(string orderId, [FromBody] string bank) { OrderPayed e = new OrderPayed(Guid.NewGuid(), orderId, bank); await _messagePublisher.PublishMessageAsync(MessageTypes.OrderPayed, e, ""); return(Ok()); }
public ApiResult GetRestList() { var stringList = _testService.getTestList(); _messagePublisher.PublishMessageAsync("StringList", new { List = stringList }); return(ApiResult.Success(stringList)); }
public async Task <IActionResult> PostAsync([FromBody] RegisterTransport command) { if (ModelState.IsValid) { // Insert Transport Transport transport = Mapper.Map <Transport>(command); _dbContext.Transports.Add(transport); await _dbContext.SaveChangesAsync(); // Send Event TransportRegistered e = Mapper.Map <TransportRegistered>(transport); await _messagePublisher.PublishMessageAsync(e.MessageType, e, ""); return(CreatedAtRoute("GetTransportById", new { transportId = transport.TransportId }, transport)); } return(BadRequest()); }