Esempio n. 1
0
        public void InsertOccupantTest()
        {
            string newUserId     = StringGenerator.RandomString(28);
            string O4DisplayName = StringGenerator.RandomString(100);
            OccupantInsertRequest occupantToInsert = new OccupantInsertRequest
            {
                InviteAccepted      = false,
                UserId              = newUserId,
                DisplayName         = O4DisplayName,
                EnteredBy           = firebaseFixture.H2UserId,
                InvitedByOccupantId = 2,
            };

            RestClient  client  = GetClient();
            RestRequest request = apiCall <OccupantInsertRequest>(firebaseFixture.H2Token, sutEndpoint, sutHttpMethod, occupantToInsert);
            IRestResponse <OccupantResponse> response = client.Execute <OccupantResponse>(request);

            string expectedContent = serialize(new OccupantResponse
            {
                OccupantId  = response.Data != null ? response.Data.OccupantId : 0,
                UserId      = newUserId,
                DisplayName = O4DisplayName,
            });

            response.StatusCode.ShouldBeEquivalentTo(HttpStatusCode.OK);
            response.Data.OccupantId.Should().BePositive();
            response.Content.ShouldBeEquivalentTo(expectedContent);
        }
Esempio n. 2
0
 public async Task <OccupantResponse> InsertOccupant(OccupantInsertRequest occupant)
 {
     return(await asyncConnection(occupant.EnteredBy, occupant.InvitedByOccupantId, async db =>
     {
         return await InsertOccupantQuery(db, occupant);
     }));
 }
Esempio n. 3
0
        public async Task <OccupantResponse> InsertOccupantQuery(IDbConnection db, OccupantInsertRequest occupant)
        {
            OccupantResponse insertedOccupant = await db.QueryFirstAsync <OccupantResponse>(
                sql : "[Houses].[Occupants_Insert]",
                param : occupant,
                commandType : CommandType.StoredProcedure
                );

            return(insertedOccupant);
        }
Esempio n. 4
0
        public async Task <bool> InviteOccupant(OccupantInviteRequest invite)
        {
            // TODO: Send invite email!
            return(await asyncConnection(invite.InvitedByUserId, invite.InvitedByOccupantId, async db =>
            {
                bool occupantInvited = false;
                OccupantInviteResponse existingOccupant = GetFirebaseUserByEmail(invite.Email);
                if (existingOccupant != null)
                {
                    this.logger.Information($"Creating Occupant from invite: {invite.ToString()}");
                    OccupantInsertRequest createOccupant = new OccupantInsertRequest
                    {
                        InviteAccepted = false,
                        UserId = existingOccupant.Uid,
                        DisplayName = existingOccupant.DisplayName,
                        EnteredBy = invite.InvitedByUserId,
                        InvitedByOccupantId = invite.InvitedByOccupantId
                    };
                    this.logger.Information($"Creating Occupant: {createOccupant.ToString()}");
                    OccupantResponse newOccupant = await this.InsertOccupantQuery(db, createOccupant);

                    this.logger.Information($"Created Occupant: {newOccupant.ToString()}");

                    NewsFeedInsertRequest householdInviteNewsItem = new NewsFeedInsertRequest
                    {
                        EnteredBy = invite.InvitedByUserId,
                        OccupantId = invite.InvitedByOccupantId,
                        Headline = "Invited to a new household",
                        SubHeadline = "Congrats",
                        Story = "You have been invited to a new household! Go to households to accept the invite.",
                        Author = invite.InvitedByUserId,
                        Recipient = newOccupant.UserId,
                    };
                    this.logger.Information($"Creating News Feed Invite: {invite.ToString()}");
                    await newsFeedsRepository.InsertNewsFeedQuery(db, householdInviteNewsItem);
                    occupantInvited = true;
                }
                else
                {
                    // TODO: Improve functionality here!
                    this.logger.Error("Existing occupant: {existingOccupant}, not found for email {invite}", existingOccupant, invite.Email);
                    throw new Exception($"The email address {invite.Email} must sign up to myHouse first");
                }

                return occupantInvited;
            }));
        }
Esempio n. 5
0
        public void InvalidTokenTest()
        {
            OccupantInsertRequest occupantToInsert = new OccupantInsertRequest
            {
                InviteAccepted      = false,
                UserId              = StringGenerator.RandomString(28),
                DisplayName         = StringGenerator.RandomString(100),
                InvitedByOccupantId = 2,
                EnteredBy           = firebaseFixture.H2UserId
            };

            RestClient    client   = GetClient();
            RestRequest   request  = apiCall(firebaseFixture.H1Token, sutEndpoint, sutHttpMethod, occupantToInsert);
            IRestResponse response = client.Execute <OccupantResponse>(request);

            forbiddenExpectations(response);
        }
Esempio n. 6
0
        private int CreateOccupantToDelete()
        {
            string newUserId      = StringGenerator.RandomString(28);
            string newDisplayName = StringGenerator.RandomString(100);
            OccupantInsertRequest occupantToInsert = new OccupantInsertRequest
            {
                InviteAccepted      = false,
                UserId              = newUserId,
                DisplayName         = newDisplayName,
                EnteredBy           = firebaseFixture.H2UserId,
                InvitedByOccupantId = 2,
            };

            RestClient  client  = GetClient();
            RestRequest request = apiCall <OccupantInsertRequest>(firebaseFixture.H2Token, sutEndpoint, sutHttpMethod, occupantToInsert);
            IRestResponse <OccupantResponse> response = client.Execute <OccupantResponse>(request);

            return(response.Data != null ? response.Data.OccupantId : 0);
        }