public ActionResult <WebhookSubscriptionReadDto> CreateSubscription(WebhookSubscriptionCreateDto webhookSubscription)
        {
            var subscription = _context.WebhookSubscriptions.FirstOrDefault(s => s.WebhookURI == webhookSubscription.WebhookURI);

            if (subscription == null)
            {
                subscription = _mapper.Map <WebhookSubscription>(webhookSubscription);

                subscription.Secret = Guid.NewGuid().ToString();
                // Read from config; hard code is not good practice.
                subscription.WebhookPublisher = "PanAus";
                try
                {
                    _context.WebhookSubscriptions.Add(subscription);
                    _context.SaveChanges();
                }
                catch (Exception ex)
                {
                    return(BadRequest(ex.Message));
                }

                var webhookSubscriptionReadDto = _mapper.Map <WebhookSubscriptionReadDto>(subscription);
                return(CreatedAtRoute(nameof(GetSubscriptionBySecret), new { secret = webhookSubscriptionReadDto.Secret }, webhookSubscriptionReadDto));
            }

            return(NoContent());
        }
Exemple #2
0
        public ActionResult <WebhookSubscriptionReadDto> CreateSubscription(WebhookSubscriptionCreateDto webhookSubscriptionCreateDto)
        {
            var subscription = _context.WebhookSubscriptions.FirstOrDefault(s => s.WebhookURI == webhookSubscriptionCreateDto.WebhookURI);

            if (subscription == null)
            {
                subscription = _mapper.Map <WebhookSubscription>(webhookSubscriptionCreateDto);

                subscription.Secret           = Guid.NewGuid().ToString();
                subscription.WebhhokPublisher = "BigFieldAirline";
                try
                {
                    _context.WebhookSubscriptions.Add(subscription);
                    _context.SaveChanges();
                }
                catch (Exception ex)
                {
                    return(BadRequest(ex.Message));
                }

                var webhookSubrscriptionReadDto = _mapper.Map <WebhookSubscription>(subscription);

                return(CreatedAtRoute(nameof(GetSubscriptionBySecret), new { secret = webhookSubrscriptionReadDto.Secret }, webhookSubrscriptionReadDto));
            }
            else
            {
                return(NoContent());
            }
        }
        public ActionResult <WebhookSubscriptionReadDto> CreateSubscription(WebhookSubscriptionCreateDto webhookToCreate)
        {
            var subscription = _context.WebhookSubscriptions.FirstOrDefault(s => s.WebhookUri == webhookToCreate.WebhookUri);

            if (subscription != null)
            {
                return(NoContent());
            }

            subscription = _mapper.Map <WebhookSubscription>(webhookToCreate);

            subscription.Secret           = Guid.NewGuid().ToString();
            subscription.WebhookPublisher = "PanAus";

            try
            {
                _context.WebhookSubscriptions.Add(subscription);
                _context.SaveChanges();
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }

            var subscriptionToReturn = _mapper.Map <WebhookSubscriptionReadDto>(subscription);

            return(CreatedAtRoute("GetSubscriptionById", new { id = subscriptionToReturn.Id }, subscriptionToReturn));
        }
Exemple #4
0
        public async Task <ActionResult <WebhookSubscriptionReadDto> > CreateSubscription(
            WebhookSubscriptionCreateDto webhookSubscriptionCreateDto)
        {
            var subscription =
                await _context.WebhookSubscriptions.FirstOrDefaultAsync(s =>
                                                                        s.WebhookURI == webhookSubscriptionCreateDto.WebhookURI);

            if (subscription is not null)
            {
                return(await Task.FromResult(NoContent()));
            }
            subscription                  = _mapper.Map <WebhookSubscription>(webhookSubscriptionCreateDto);
            subscription.Secret           = Guid.NewGuid().ToString();
            subscription.WebhookPublisher = "AmTech";
            try
            {
                await _context.AddAsync(subscription);

                await _context.SaveChangesAsync();

                var webhookSecret = new WebhookSecretMessageDto
                {
                    Publisher = subscription.WebhookPublisher,
                    Secret    = subscription.Secret
                };

                _messageBus.SendWebhookSecretMessage(webhookSecret);
            }
            catch (Exception ex)
            {
                return(await Task.FromResult(BadRequest(ex.Message)));
            }

            var response = _mapper.Map <WebhookSubscriptionReadDto>(subscription);

            return(CreatedAtRoute(
                       routeName: "GetSubscriptionBySecret",
                       routeValues: new { secret = response.Secret },
                       value: response));
        }
Exemple #5
0
        public async Task <ActionResult <WebhookSubscriptionReadDto> > CreateSubscription(WebhookSubscriptionCreateDto webSubscriptionCreateDto)
        {
            var subscription = await _context.WebhookSubscriptions
                               .FirstOrDefaultAsync(
                e => e.WebhookURI == webSubscriptionCreateDto.WebhookURI);

            if (subscription != null)
            {
                return(NoContent());
            }

            subscription                  = _mapper.Map <WebhookSubscription>(webSubscriptionCreateDto);
            subscription.Secret           = Guid.NewGuid().ToString();
            subscription.WebhookPublisher = "PanAm";

            try
            {
                await _context.WebhookSubscriptions.AddAsync(subscription);

                await _context.SaveChangesAsync();
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }

            return(CreatedAtRoute(nameof(GetSubscriptionBySecret),
                                  new { secret = subscription.Secret },
                                  _mapper.Map <WebhookSubscriptionReadDto>(subscription)));
        }