public IResult Add(ChannelDto channelDto) { var userExist = _userService.GetById(channelDto.UserId); if (userExist == null) { return(new ErrorResult("Invalid user")); } var channel = new Channel { Name = channelDto.Name, Verified = false, UserId = channelDto.UserId }; if (!_channelDal.Add(channel)) { return(new ErrorResult("Channel cannot created!")); } channel.Slug = channel.Id.ToString(); _channelDal.Update(channel); return(new SuccessResult("Channel created.")); }
public async Task <IEnumerable <ChannelDto> > GetChannels(bool isFastRun, CancellationToken cancellationToken) { var channelsList = new List <ChannelDto>(); using (Browser browser = await _browserFactory.Create()) { using Page page = await browser.NewPageAsync(); await Login(page); IEnumerable <string> channelUrls = await GetChannelUrls(page); if (isFastRun) { channelUrls = channelUrls.Take(1); } foreach (string url in channelUrls.TakeWhile(url => !cancellationToken.IsCancellationRequested)) { ChannelDto channel = await GetChannelDetails(page, url); channelsList.Add(channel); } } return(channelsList); }
public bool Handle(NewChannelRequest request, IOutputPort <NewChannelResponse> outputPort) { if (_userRepository.FindById(request.UserId) == null) { outputPort.Handle(new NewChannelResponse(new[] { new Error(404, "user not found") })); return(false); } if (_channelRepository.FindByUserId(request.UserId) != null) { outputPort.Handle(new NewChannelResponse(new[] { new Error(422, "user already have channel") })); return(false); } if (_channelRepository.FindByName(request.Name) != null) { outputPort.Handle(new NewChannelResponse(new[] { new Error(422, "channel name is busy") })); return(false); } var channelInfo = new ChannelDto() { UserId = request.UserId, RegistrationDate = request.RegistrationDate, Description = request.Description, Name = request.Name, }; ChannelDto createdChannel = _channelRepository.Create(channelInfo); outputPort.Handle(new NewChannelResponse(createdChannel)); return(true); }
public ChannelBuilder(AsUserBuilder builder, ChannelDto channel) { _builder = builder; _channel = channel; _group = _builder._builder._group; _groupsModuleFacade = _builder._facade; }
public async Task <long> CreateAsync(ChannelDto channel, CancellationToken cancellation = default) { var entity = Mapper.Map <ChannelDto, Channel>(channel); var result = await _channelStorage.CreateAsync(entity, cancellation); return(result.Id); }
public async Task <List <ChannelDto> > CreateOrUpdateUserChannelsAsync(List <ChannelDto> channels) { using (MessengerDbContext context = contextFactory.Create()) { var channelsCondition = PredicateBuilder.New <Channel>(); channelsCondition = channels.Aggregate(channelsCondition, (current, value) => current.Or(opt => opt.ChannelId == value.ChannelId).Expand()); List <Channel> existingChannels = await context.Channels .Include(opt => opt.ChannelUsers) .Where(channelsCondition) .ToListAsync() .ConfigureAwait(false); for (int i = 0; i < existingChannels.Count; i++) { ChannelDto editedChannel = channels.FirstOrDefault(opt => opt.ChannelId == existingChannels[i].ChannelId); existingChannels[i] = ChannelConverter.GetChannel(existingChannels[i], editedChannel); if (!editedChannel.ChannelUsers.IsNullOrEmpty()) { existingChannels[i].ChannelUsers = ChannelConverter.GetChannelUsers(editedChannel.ChannelUsers).ToList(); } } context.UpdateRange(existingChannels); List <ChannelDto> nonExistingChannels = channels.Where(channelDto => !existingChannels.Any(channel => channelDto.ChannelId == channel.ChannelId))?.ToList(); List <Channel> newChannels = ChannelConverter.GetChannels(nonExistingChannels); await context.AddRangeAsync(newChannels).ConfigureAwait(false); await context.SaveChangesAsync().ConfigureAwait(false); return(ChannelConverter.GetChannelsDto(newChannels.Concat(existingChannels))); } }
/// <summary> /// 检查通道信息 /// </summary> /// <param name="brandChannelDto"></param> /// <param name="channelDto"></param> /// <param name="retMsg"></param> /// <returns></returns> public bool CheckChannel(long id, out ChannelDto channelDto, out string retMsg) { var val = _pushChannelService; retMsg = ""; channelDto = CourseCacheLogic <string, ChannelDto> .Get("Channel_" + id, () => { PushChannelDomainModel pushChannel = _pushChannelService.GetChannelByIdAsync(id).Result; return(_mapper.Map <ChannelDto>(pushChannel)); }); if (channelDto == null) { retMsg = string.Format("ChannelId:{0},未匹配到Push_Channel", id); return(false); } //通道是否有效 if (!channelDto.IsActive) { retMsg = string.Format("ChannelId:{0},通道{1}状态无效", channelDto.Id, channelDto.ChannelName); return(false); } return(true); }
public void BindChannelInfo(ChannelDto channelDto, ChannelChangeEventHandler onChangeChannelInfoHandler) { _onChangeChannelInfoHandler = onChangeChannelInfoHandler; _lastLineId = channelDto.Id; ShowDto(channelDto); }
private async Task SaveIfDoesNotExist(ChannelDto channelDto) { if (!_channelApplicationService.Exists(channelDto)) { await _channelApplicationService.Create(channelDto); } }
public IActionResult Add([FromBody] ChannelDto channelDto) { var result = _channelService.Add(channelDto); return(result.Success ? Ok(result.Message) : BadRequest(result.Message)); }
public async Task <ActionResult <ChannelWithIdDto> > Add([FromBody] ChannelDto channelDto) { var channel = _mapper.Map <Channel>(channelDto); var addedChannel = await _channelRepository.AddAsync(channel); return(Ok(_mapper.Map <ChannelWithIdDto>(addedChannel))); }
public void given_channel_created() { ChannelDto dto = CreateChannelDto(FOO_CHANNEL_NAME_CREATED); _channelsToReplicate = new List <ChannelDto>(_channelsToReplicate) { dto }; }
public Channel(ChannelDto channel) { this.id = channel.id; this.name = channel.name; this.adminId = channel.adminId; this.guid = channel.guid; this.isPrivate = channel.isPrivate; this.usersId = channel.usersId.Split("|".ToCharArray(), System.StringSplitOptions.RemoveEmptyEntries).Select(userId => int.Parse(userId)); }
public bool Handle(SearchRequest request, IOutputPort <SearchResponse> outputPort) { IEnumerable <VideoDto> videos = _videoRepository.FindByName(request.SearchQuery); ChannelDto channel = _channelRepository.FindByName(request.SearchQuery); outputPort.Handle(new SearchResponse(videos, channel)); return(true); }
public ChannelDto Create(ChannelDto channelInfo) { var channel = _mapper.Map <Channel>(channelInfo); _database.Channels.Add(channel); _database.SaveChanges(); return(_mapper.Map <ChannelDto>(channel)); }
public async Task LeaveChannel(ChannelDto channelDto) { channelDto.Id = Context.ConnectionId; ChannelHandler.ChannelDictionary.Remove(channelDto.Id); await Groups.RemoveFromGroupAsync(Context.ConnectionId, channelDto.ChannelName); await Clients.OthersInGroup(channelDto.Id).UserLeftChannel(channelDto); await Clients.Others.UsersInGroup(ChannelHandler.NumberOfUsersInChannel(channelDto.ChannelName)); }
private ReplicateResult Replicate(ChannelDto channelDto) { var newChannel = new Channel(channelDto, _entityFactory); LookUpCourses(ref newChannel); _db.Channels.Add(newChannel); return(ReplicateResult.BuildChannelCreated(newChannel.Name)); }
public async Task JoinChannel(ChannelDto channelDto) { channelDto.Id = Context.ConnectionId; ChannelHandler.ChannelDictionary.Add(channelDto.Id, channelDto.ChannelName); await Groups.AddToGroupAsync(Context.ConnectionId, channelDto.ChannelName); await Clients.OthersInGroup(channelDto.ChannelName).UserJoinedChannel(channelDto); await Clients.Others.UsersInGroup(ChannelHandler.NumberOfUsersInChannel(channelDto.ChannelName)); }
public ChannelDto Insert(ChannelDto channel) { var res = SimpleCrud.Current.Insert(channel); if (res != 1) { return(null); } return(SimpleCrud.Current.Get <ChannelDto>(new { name = channel.name, guid = channel.guid }) as ChannelDto); }
public async Task Handle_QuestionWithoutAnswers_ShouldSendMessageWithOneAttachment() { // Arrange var questionId = Guid.NewGuid(); var actionParams = new AnswerSlackActionParams { User = new ItemInfo { Id = "userId", Name = "userName" }, ButtonParams = new AnswerActionButtonParams { QuestionId = questionId.ToString() } }; var question = new Question { Id = questionId, Text = "blabla" }; var channel = new ChannelDto { Id = "channelId" }; string actualChannelId = null; List <AttachmentDto> actualAttachments = null; _questionServiceMock.Setup(m => m.GetQuestionAsync(It.IsAny <string>())) .ReturnsAsync(question); _slackClientMock.Setup(m => m.OpenDirectMessageChannelAsync(It.IsAny <string>())) .ReturnsAsync(channel); _slackClientMock.Setup(m => m.SendMessageAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <IList <AttachmentDto> >())) .Returns(Task.CompletedTask) .Callback((string channelId, string message, List <AttachmentDto> attachments) => { actualChannelId = channelId; actualAttachments = attachments; }); // Act await _handler.Handle(actionParams); // Assert Assert.Equal(actualChannelId, channel.Id); Assert.Single(actualAttachments); _questionServiceMock.Verify(m => m.GetQuestionAsync(It.Is <string>(q => q == questionId.ToString())), Times.Once); _questionServiceMock.VerifyNoOtherCalls(); _slackClientMock.Verify( m => m.OpenDirectMessageChannelAsync(It.Is <string>(id => id == actionParams.User.Id)), Times.Once); _slackClientMock.Verify( m => m.SendMessageAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <IList <AttachmentDto> >()), Times.Once); _slackClientMock.VerifyNoOtherCalls(); }
public ChannelBuilder CreateChannel(string channelName) { var channel = new ChannelDto(Guid.NewGuid()); _builder.AddChannel(channel); _builder.AddBuildAction( async() => await _facade.SendAsync(new CreateChannelCommand(_userIdContext, _group.GroupId, channel.ChannelId, channelName)) ); return(new ChannelBuilder(this, channel)); }
public async Task <bool> UpdateAsync(ChannelDto channel, CancellationToken cancellation = default) { var entity = await _channelStorage.FindByIdAsync(channel.Id, cancellation); if (entity == null) { return(false); } Mapper.Map(channel, entity); return(await _channelStorage.UpdateAsync(entity) > 0); }
public void CreateChannel(ChannelDto channel) { ValidateDto(channel); //TODO в одной тиме не должно быть двух каналов с одинаковым названием Execute.NonQuery(uow => { //ValidateDbEntity(channel.MapToDbEntity(), uow, DomainModelValidation.ValidationType.OnCreate); uow.Repository <IChannelRepository>().Create(channel.MapToDbEntity()); }); }
public async Task <ChannelDto> GetAsync(Guid id) { Channel channel = await _channelRepository.Select .IncludeMany(r => r.Tags, r => r.Where(u => u.Status == true)) .Where(a => a.Id == id) .WhereCascade(r => r.IsDeleted == false).ToOneAsync(); ChannelDto channelDto = _mapper.Map <ChannelDto>(channel); channelDto.ThumbnailDisplay = _currentUser.GetFileUrl(channelDto.Thumbnail); return(channelDto); }
public static Channel GetChannel(Channel editable, ChannelDto edited) { editable.ChannelName = edited.ChannelName ?? editable.ChannelName; editable.About = edited.About ?? editable.About; editable.Photo = edited.Photo ?? editable.Photo; editable.Deleted = edited.Deleted; editable.CreationTime = edited.CreationTime; editable.NodesId = edited.NodesId; editable.Tag = edited.Tag; editable.ChannelUsers = !edited.ChannelUsers.IsNullOrEmpty() ? GetChannelUsers(edited.ChannelUsers) : editable.ChannelUsers; return(editable); }
public bool Merge(ChannelDto channel, EntityFactory entityFactory) { var changed = false; if (Url != channel.Url) { Url = channel.Url; changed = true; } ChannelCourse[] missingCourses = FindMissingCourses(channel, entityFactory); ChannelCourse[] extraCourses = FindExtraCourses(channel).ToArray(); (ChannelCourse c, CourseDto dto)[] existingCourses = FindExistingCourses(channel).ToArray();
public Channel(ChannelDto channelDto, EntityFactory entityFactory) { Name = channelDto.Name; Url = channelDto.Url; ChannelCourses = channelDto.Courses .Select(courseDto => { Course course = entityFactory.CreateCourse(courseDto); return(entityFactory.CreateChannelCourse(channel: this, course)); }) .ToList(); }
private ReplicateResult Replicate(ChannelDto channelDto, Channel channelDb) { bool channelModified = channelDb.Merge(channelDto, _entityFactory); if (channelModified) { LookUpCourses(ref channelDb); } return(channelModified ? ReplicateResult.BuildChannelUpdated(channelDb.Name) : ReplicateResult.BuildChannelUnchanged(channelDb.Name)); }
public async Task <PartialViewResult> CreateOrEditModal(int?id) { ChannelDto dto; if (id.HasValue) { dto = await _channelAppService.Get(new EntityDto(id.Value)); } else { dto = new ChannelDto(); } return(PartialView("_CreateOrEditModal", dto)); }
public async Task HandleAsync() { bool hasException = true; List <ChannelUserVm> channelUsers = null; while (hasException) { try { channelUsers = await createChannelsService.CreateOrEditChannelUsersAsync(notice.ChannelUsers, notice.RequestorId).ConfigureAwait(false); hasException = false; } catch (UserNotFoundException) { List <long> usersId = notice.ChannelUsers.Select(opt => opt.UserId).Append(notice.RequestorId).ToList(); List <UserVm> users = await nodeRequestSender.GetUsersInfoAsync(usersId, null, current).ConfigureAwait(false); await crossNodeService.CreateNewUsersAsync(users).ConfigureAwait(false); hasException = true; } catch (ConversationNotFoundException) { ChannelDto channel = await nodeRequestSender.GetChannelInformationAsync(notice.ChannelId, current).ConfigureAwait(false); await createChannelsService.CreateOrUpdateUserChannelsAsync(new List <ChannelDto> { channel }).ConfigureAwait(false); hasException = true; } catch (Exception ex) { Logger.WriteLog(ex); hasException = false; } } BlockSegmentVm segment = await BlockSegmentsService.Instance.CreateChannelUsersSegmentAsync( channelUsers, current.Node.Id, notice.ChannelId, NodeData.Instance.NodeKeys.SignPrivateKey, NodeData.Instance.NodeKeys.SymmetricKey, NodeData.Instance.NodeKeys.Password, NodeData.Instance.NodeKeys.KeyId).ConfigureAwait(false); BlockGenerationHelper.Instance.AddSegment(segment); }