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);
}
