Exemple #1
0
        /// <summary>
        /// Cancel an invitation.
        /// </summary>
        /// <param name="request">Who to uninvite.</param>
        /// <returns></returns>
        /// <returns>Lists of the outstanding and accepted invitations.</returns>
        public async Task <InvitationsIssued> PostUninviteAsync(InvitationRequest request)
        {
            UserInfo user = await GetUserInfoAsync();

            if (!MasterEmails.Contains(user.Email))
            {
                throw new HttpResponseException(HttpStatusCode.Forbidden);
            }
            return(await InvitationOperations.UninviteAsync(DbContext, request));
        }
Exemple #2
0
        public async Task <InvitationsIssued> GetAsync()
        {
            UserInfo user = await GetUserInfoAsync();

            if (!MasterEmails.Contains(user.Email))
            {
                throw new HttpResponseException(HttpStatusCode.Forbidden);
            }

            return(await InvitationOperations.GetCurrentInvitations(DbContext));
        }
Exemple #3
0
        public async Task <UserSettings> PostValidate()
        {
            UserInfo user = await GetUserInfoAsync();

            if (user == null)
            {
                Dictionary <string, string> claims = await GetApiTokenClaimsAsync();

                string email = claims[ClaimTypes.Email];
                if (!await UserOperations.CheckNewUserAllowed(DbContext, email))
                {
                    throw new HttpResponseException(HttpStatusCode.Forbidden);
                }

                // User must either be on the master list, or invited.
                if (!MasterEmails.Contains(email))
                {
                    Invitation inv = await DbContext.Invitations.SingleOrDefaultAsync(i => i.Email == email);

                    if (inv == null)
                    {
                        throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden)
                        {
                            Content = new StringContent("Not invited")
                        });
                    }
                }

                string msaKey  = claims[ClaimTypes.NameIdentifier];
                string msaName = claims[ClaimTypes.Name];
                user = new UserInfo
                {
                    UserInfoId = Guid.NewGuid().ToString("d"),
                    Email      = email,
                    MicrosoftAccountProviderKeyApi = msaKey,
                    Name = msaName,
                };

                DbContext.UserInfos.Add(user);

                await DbContext.SaveChangesAsync();
            }

            return(UserOperations.GetUserSettings(user));
        }
        // GET: Invitations
        public async Task <ActionResult> Index()
        {
            UserInfo user = await GetUserInfoAsync();

            if (!MasterEmails.Contains(user.Email))
            {
                return(new HttpStatusCodeResult(HttpStatusCode.Forbidden));
            }

            var current = await InvitationOperations.GetCurrentInvitations(DbContext);

            var vm = new InvitationsViewModel
            {
                OutstandingInvitations = current.Outstanding,
                AcceptedInvitations    = current.Accepted
            };

            return(View(await SetBasicVmInfo(vm)));
        }