public ServiceResponse <SubscribeDto> Insert(int userId, SubscribeDto modelDto) { var response = new ServiceResponse <SubscribeDto>(); try { if (modelDto != null && modelDto.UserId == userId) { var item = _repository.TableNoTracking.FirstOrDefault(x => x.CourseId == modelDto.CourseId && x.UserId == modelDto.UserId); if (item == null) { var model = new Subscribe(); model.UserId = modelDto.UserId; model.CourseId = modelDto.CourseId; model.Id = modelDto.Id; model.DateAdded = DateTime.Now; _repository.Insert(model); response.IsSuccessful = true; } } } catch (Exception) { response.ExceptionMessage = ErrorCodes.BilinmeyenHata.Text; response.IsSuccessful = false; } return(response); }
public async Task<IHttpActionResult> Subscribe(SubscribeDto model) { if(!ModelState.IsValid) return BadRequest(ModelState); var moderatorSubs = await _reddit.GetSubRedditsAsync(SubRedditKind.Moderator); var currentSubs = await _subReddits.GetAllAsync(); if (!moderatorSubs.Contains(model.Name, StringComparer.InvariantCultureIgnoreCase)) { return Conflict("Moderator trait is required."); } if (currentSubs.Any(s => s.Name.Equals(model.Name, StringComparison.InvariantCultureIgnoreCase))) { return Conflict("That Sub Reddit is already linked."); } if (!await _subReddits.AddAsync(model.Name)) { return Conflict("Error linking Sub Reddit."); } return Ok(); }
public ServiceResponse <SubscribeDto> Update(int id, int userId, SubscribeDto modelDto) { var response = new ServiceResponse <SubscribeDto>(); try { if (modelDto.UserId == userId && modelDto.Id == id) { var model = new Subscribe(); model.UserId = modelDto.UserId; model.CourseId = modelDto.CourseId; model.Id = modelDto.Id; model.LastModified = DateTime.Now; _repository.Update(model); response.IsSuccessful = true; } } catch (Exception) { response.ExceptionMessage = ErrorCodes.BilinmeyenHata.Text; response.IsSuccessful = false; } return(response); }
private void consume(SubscribeDto newSubscription) { mainChannel.ExchangeDeclare(newSubscription.ExchangeName, ExchangeType.Topic, true, false, null); mainChannel.QueueDeclare(newSubscription.QueueName, true, false, true); mainChannel.QueueBind(newSubscription.QueueName, newSubscription.ExchangeName, newSubscription.RouteKey); queueNames.Add(newSubscription.QueueName); var consumer = new EventingBasicConsumer(mainChannel); consumer.Received += async(sender, args) => { //logger.LogInformation("received"); var responseObject = JsonSerializer.Deserialize(args.Body.Span, typeof(object)); await hubContext.Clients.Client(newSubscription.ConnectionId).SendAsync(newSubscription.QueueName, responseObject); mainChannel.BasicAck(args.DeliveryTag, false); }; mainChannel.BasicConsume(newSubscription.QueueName, false, consumer); logger.LogInformation($"Connection [{newSubscription.ConnectionId}] - Subscribing to queue '{newSubscription.QueueName}' on route '{newSubscription.RouteKey}'"); }
public async Task <bool> Subscribe(SubscribeDto user) { using (var context = new BlogContext(_options)) { var subscriber = await context.Subscribers.FindAsync(user.Email); if (null != subscriber) { subscriber.Status = SubscriptionStatusTypeEnum.Active; await context.SaveChangesAsync(); return(true); } var newSubscriber = new Subscriber { Name = user.Username, Email = user.Email, Status = SubscriptionStatusTypeEnum.Active, IsTester = false, SubscriptionStart = DateTime.UtcNow }; await context.Subscribers.AddAsync(newSubscriber); await context.SaveChangesAsync(); return(true); } }
public async Task <IHttpActionResult> Subscribe(SubscribeDto model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var moderatorSubs = await _reddit.GetSubRedditsAsync(SubRedditKind.Moderator); var currentSubs = await _subReddits.GetAllAsync(); if (!moderatorSubs.Contains(model.Name, StringComparer.InvariantCultureIgnoreCase)) { return(Conflict("Moderator trait is required.")); } if (currentSubs.Any(s => s.Name.Equals(model.Name, StringComparison.InvariantCultureIgnoreCase))) { return(Conflict("That Sub Reddit is already linked.")); } if (!await _subReddits.AddAsync(model.Name)) { return(Conflict("Error linking Sub Reddit.")); } return(Ok()); }
public IActionResult UnSubscribe([FromBody] SubscribeDto subscription) { var request = new UnsubscribeRequest() { CommunityId = subscription.CommunityTag, PhoneNumber = subscription.PhoneNumber }; _unsubscribe.Handle(request); return(Ok()); }
public async Task <IActionResult> PostSubscription(string appId, string id, [FromBody] SubscribeDto request) { var user = await userStore.GetAsync(appId, id, HttpContext.RequestAborted); if (user == null) { return(NotFound()); } var update = request.ToUpdate(id); await subscriptionStore.SubscribeAsync(appId, update, HttpContext.RequestAborted); return(NoContent()); }
public async Task <bool> Unsubscribe(SubscribeDto subscribeDto) { using (var context = new BlogContext(_options)) { var user = await context.Subscribers.FindAsync(subscribeDto.Email); if (null == user) { return(false); } user.Status = SubscriptionStatusTypeEnum.Inactive; await context.SaveChangesAsync(); return(true); } }
public async Task <IActionResult> SubscribeCommand([FromBody] SubscribeDto value, [FromHeader] Guid userId) { _logger.LogInformation("Subscribe for user:{0}, bookid:{1} ", userId, value.BookId); var book = await _client.GetRequest(new BookDto(), $"{_options.Value.CatalogueUrl}{_options.Value.BookQueryPath}{value.BookId}"); if (book == null) { throw new InvalidDataException("book provided does not exist"); } var command = new SubscribeCommand { BookId = value.BookId, BookName = book.Name, UserId = userId }; await _mediator.DispatchAsync(command); _logger.LogInformation("Subscribed for user:{0}, bookid:{1} ", userId, value.BookId); return(Ok()); }
protected void DoSubscribe(string eventName, Func <ISocketEventRequest, RequestResult> eventCallback, Action <ISocketEventResponse> subscribeReadyCallback) { this.Socket.On(eventName, (msg) => { var dto = JsonConvert.DeserializeObject <SocketEventRequestDto>(msg.Json.Args[0].ToString()); var request = Mapper.Map <SocketEventRequestDto, SocketEventRequest>(dto); var result = eventCallback(request); // Simulate a ack callback because SocketIO4Net doesn't provide one by default. var msgText = JsonConvert.SerializeObject(new object[] { new SocketEventResponseDto() { RequestId = request.RequestId, Status = result.ToString().ToUpper() } }); var ack = new AckMessage() { AckId = msg.AckId, MessageText = msgText }; this.Socket.Send(ack); }); var subscribeDto = new SubscribeDto() { Event = eventName, SenderId = this.ClientId }; this.Socket.Emit(SUBSCRIBE, subscribeDto, string.Empty, (data) => { var json = data as JsonEncodedEventMessage; var result = JsonConvert.DeserializeObject <SocketEventResponseDto>(json.Args[0]); var response = Mapper.Map <SocketEventResponseDto, SocketEventResponse>(result); if (subscribeReadyCallback != null) { subscribeReadyCallback(response); } }); }
public async Task <ActionResult <SubscriptionResult> > Subscribe(SubscribeDto subscribeDto) { var action = subscribeDto.Action; var checkIfSubscriberExistQuery = new CheckIfUserSubscribedQuery { SubscriberEmail = subscribeDto.Email }; var isSubscriber = await _queryProcessor.Process <CheckIfUserSubscribedQuery, bool>(checkIfSubscriberExistQuery); if (isSubscriber && action == SubscribeDataActionTypeEnum.Subscribe) { return(Ok(SubscriptionResult.AlreadySubscribed)); } if (!isSubscriber && action == SubscribeDataActionTypeEnum.Unsubscribe) { return(Ok(SubscriptionResult.NotInDatabase)); } var command = new ProcessSubscriptionCommand() { SubscriptionData = subscribeDto }; await _commandDispatcher.Execute(command); if (action == SubscribeDataActionTypeEnum.Subscribe) { return(Ok(SubscriptionResult.Subscribed)); } if (action == SubscribeDataActionTypeEnum.Unsubscribe) { return(Ok(SubscriptionResult.Unsubscribed)); } return(BadRequest()); }
public async Task HandleSubscribeTenant(SubscribeDto input) { var relation = await _tenantEducatorRepository.GetAll() .FirstOrDefaultAsync(x => x.EducatorId == input.EducatorId && x.TenantId == input.TenantId); relation.IsAccepted = input.IsAccepted; await _tenantEducatorRepository.UpdateAsync(relation); var educator = await _educatorRepository.GetByIdAsync(input.EducatorId); if (input.IsAccepted) { await _notificationAppService.CreateNotify(new CreateNotificationDto { OwnerId = input.TenantId, OwnerType = EntityType.Tenant, SenderId = input.TenantId, SenderType = EntityType.Educator, Content = educator.Profession + " " + educator.Name + " " + educator.Surname + " " + "Eğitmen Ekleme Talebinizi Kabul Etti.", NotifyContentType = NotifyContentType.SubscribeResponse }); } }
public async Task <ServiceResponse <SubscribeDto> > Put(int id, int userId, SubscribeDto model) { return(_repository.Update(id, userId, model)); }
public async Task <ServiceResponse <SubscribeDto> > Post(int userId, SubscribeDto model) { return(_repository.Insert(userId, model)); }
public static async Task Main(string[] args) { var client = NotifoClientBuilder.Create() .SetApiKey(ApiKey) .SetApiUrl("https://*****:*****@squidex.io", Id = userId }; await client.Users.PostUsersAsync(AppId, new UpsertUsersDto { Requests = new List <UpsertUserDto> { request }, }); } Console.WriteLine("Generated Users..."); } if (args?.Contains("--subscriptions") == true) { Console.WriteLine("Generating Subscriptions..."); foreach (var userId in users) { var request = new SubscribeDto { TopicPrefix = TopicPrefix }; await client.Users.PostSubscriptionAsync(AppId, userId, request); } Console.WriteLine("Generated Subscriptions..."); } if (args?.Contains("--no-events") != true) { Console.WriteLine("Generating Events..."); for (var i = 0; i < 1; i++) { var request = new PublishRequestDto { Topic = Topic }; var formatting = new NotificationFormattingDto { Body = new LocalizedText { ["en"] = "Hello Body {{var}}", ["de"] = "Hallo Body {{var}}" }, Subject = new LocalizedText { ["en"] = "Hello Title {{var}}", ["de"] = "Hallo Title {{var}}" }, }; request.Properties = new EventProperties { ["var"] = "123" }; request.Preformatted = formatting; await client.Events.PostEventsAsync(AppId, new PublishManyRequestDto { Requests = new List <PublishRequestDto> { request } }); } Console.WriteLine("Generated Events..."); } }
public async Task HandleSubscribeTenant(SubscribeDto input) { await _educatorAppService.HandleSubscribeTenant(input); }