Esempio n. 1
0
        public async Task <IActionResult> Update([FromBody] VmGroup group)
        {
            var currentUser = await _currentUserService.GetCurrentUser(User);

            await _groupsService.Update(currentUser, group);

            return(NoContent());
        }
Esempio n. 2
0
        public async Task CreateGroupTest()
        {
            //Arrange
            var vmGroup = new VmGroup
            {
                Name = "New group"
            };

            //Act
            var result = await _service.Create(_currentUser, vmGroup);

            //Assert
            Assert.NotNull(result);
            Assert.AreEqual(vmGroup.Name, result.Name);
            Assert.AreEqual(0, (DateTime.Now.ToUniversalTime() - result.CreationDate).TotalSeconds, 10);
            Assert.AreNotEqual(0, result.Id);
        }
        private List <VmGroup> BuildMembershipsModel(IEnumerable <Group> allowedGroups, string[] memberships)
        {
            List <VmGroup> vmGroups = new List <VmGroup>();

            foreach (var grp in allowedGroups)
            {
                VmGroup group = new VmGroup
                {
                    Id = grp.Id,
                    StudentFriendlyName = grp.StudentFriendlyName,
                    DisplayName         = grp.DisplayName,
                    CategoryId          = grp.CategoryId
                };
                group.IsMember = memberships?.Any(memberOf => memberOf == grp.Id) ?? false;

                vmGroups.Add(group);
            }

            return(vmGroups);
        }
        // POST api/<controller>
        public async Task <ResponseMessageResult> Post(VmGroup group)
        {
            var subject = Claims.Single(c => c.Type == "sub").Value.ToString();

            try
            {
                if (group.IsMember)
                {
                    await _groupMgr.AddUserToGroup(subject, group.Id);
                }
                else
                {
                    await _groupMgr.RemoveUserFromGroup(subject, group.Id);
                }
            }
            catch (InvalidOperationException e)
            {
                return(NotFound(e.Message));
            }
            return(new ResponseMessageResult(new HttpResponseMessage(HttpStatusCode.Accepted)));
        }
Esempio n. 5
0
        public async Task <VmGroup> Create(ApplicationUser currentUser, VmGroup vmGroup)
        {
            if (vmGroup == null)
            {
                throw new HttpResponseException(BadRequest);
            }

            var group = _vmConverter.ToModel(vmGroup);

            group.CreationDate = DateTime.Now.ToUniversalTime();
            group.OwnerId      = currentUser.Id;
            group.MetadataList = vmGroup.MetadataList?
                                 .Select(x => new Metadata(x.Key, x.Value))
                                 .ToList();

            await _dataContext.Groups.AddAsync(group);

            await _dataContext.SaveChangesAsync();

            _entityStateQueue.EnqueueId(currentUser.Id, group.Id, nameof(Group), EntityOperation.Create);

            return(_vmConverter.ToViewModel(group));
        }
Esempio n. 6
0
        public async Task <ActionResult <VmGroup> > Create([FromBody] VmGroup group)
        {
            var currentUser = await _currentUserService.GetCurrentUser(User);

            return(Ok(await _groupsService.Create(currentUser, group)));
        }
Esempio n. 7
0
 public async Task Update(ApplicationUser user, VmGroup vmGroup)
 {
     await UpdateGroups(user, new[] { vmGroup });
 }