Beispiel #1
0
        public async Task <IHttpActionResult> CreateWall(CreateWallViewModel newWall)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var wallDto = _mapper.Map <CreateWallViewModel, CreateWallDto>(newWall);

            SetOrganizationAndUser(wallDto);

            try
            {
                var wallId = await _wallService.CreateNewWallAsync(wallDto);

                var userAndOrg      = GetUserAndOrganization();
                var notificationDto = await _notificationService.CreateForWallAsync(userAndOrg, wallDto, wallId);

                await NotificationHub.SendNotificationToAllUsersAsync(_mapper.Map <NotificationViewModel>(notificationDto), GetUserAndOrganizationHub());

                return(Ok(new { Id = wallId }));
            }
            catch (ValidationException e)
            {
                return(BadRequestWithError(e));
            }
        }
Beispiel #2
0
        private async Task <Event> MapNewEvent(CreateEventDto newEventDto)
        {
            var newEvent = new Event
            {
                Created        = DateTime.UtcNow,
                CreatedBy      = newEventDto.UserId,
                OrganizationId = newEventDto.OrganizationId,
                OfficeIds      = JsonConvert.DeserializeObject <string[]>(newEventDto.Offices.Value),
                IsPinned       = newEventDto.IsPinned
            };

            var newWall = new CreateWallDto
            {
                Name          = newEventDto.Name,
                Logo          = newEventDto.ImageName,
                Access        = WallAccess.Private,
                Type          = WallType.Events,
                ModeratorsIds = new List <string> {
                    newEventDto.ResponsibleUserId
                },
                MembersIds = new List <string> {
                    newEventDto.ResponsibleUserId
                },
                UserId         = newEventDto.UserId,
                OrganizationId = newEventDto.OrganizationId
            };

            var wallId = await _wallService.CreateNewWallAsync(newWall);

            newEvent.WallId = wallId;
            UpdateEventInfo(newEventDto, newEvent);

            return(newEvent);
        }
        public async Task NewProjectAsync(NewProjectDto dto)
        {
            var owningUserExists = await _usersDbSet
                                   .AnyAsync(u => u.Id == dto.OwningUserId && u.OrganizationId == dto.OrganizationId);

            if (!owningUserExists)
            {
                throw new ValidationException(ErrorCodes.ContentDoesNotExist, "Incorrect user");
            }

            var members = await _usersDbSet
                          .Where(u => dto.MembersIds.Contains(u.Id))
                          .ToListAsync();

            var completeListOfAttributes = await ManageProjectAttributesAsync(dto.Attributes);

            var project = new Project
            {
                Name           = dto.Title,
                Desc           = dto.Description,
                OwnerId        = dto.OwningUserId,
                OrganizationId = dto.OrganizationId,
                Logo           = dto.Logo,
                Attributes     = completeListOfAttributes.ToList(),
                Members        = members
            };

            var wall = new CreateWallDto
            {
                Name           = dto.Title,
                UserId         = dto.OwningUserId,
                OrganizationId = dto.OrganizationId,
                Type           = WallType.Project,
                Description    = dto.Description,
                Logo           = dto.Logo,
                Access         = WallAccess.Public,
                MembersIds     = members.Select(m => m.Id).Concat(new List <string> {
                    dto.OwningUserId
                }),
                ModeratorsIds = new List <string> {
                    dto.OwningUserId
                }
            };

            _projectsDbSet.Add(project);
            await _wallService.CreateNewWallAsync(wall);

            await _uow.SaveChangesAsync(dto.UserId);
        }
Beispiel #4
0
        private async Task <int> CreateEventWallAsync([NotNull] Event @event)
        {
            var wallDto = new CreateWallDto
            {
                Access        = WallAccess.Private,
                Name          = @event.Name,
                ModeratorsIds = new List <string> {
                    @event.ResponsibleUserId
                },
                MembersIds = new List <string> {
                    @event.ResponsibleUserId
                },
                Type           = WallType.Events,
                Logo           = @event.ImageName,
                OrganizationId = @event.OrganizationId ?? _appSettings.DefaultOrganizationId,
                UserId         = @event.ResponsibleUserId,
                Description    = @event.Description
            };

            var wallId = await _wallService.CreateNewWallAsync(wallDto);

            return(wallId);
        }