public async void Invite([FromBody] InviteViewModel model)
        {
            InviteValidator validator = new InviteValidator();
            var             results   = await validator.ValidateAsync(model);

            if (!results.IsValid)
            {
                TempData[TextConstants.TempDataInviteErrorText] = ValidatorHelper.GetErrorString(results.Errors);
                return;
            }

            var ticket = new RegistrationTicket()
            {
                ExpirationDate = DateTime.UtcNow + TimeSpan.FromMinutes(30),
                ProductKey     = model.ProductKey,
                Role           = model.Role
            };

            _ticketManager.AddTicket(ticket);

            var(server, port, login, password, fromEmail) = GetMailConfiguration();

            EmailSender sender = new EmailSender(server,
                                                 string.IsNullOrEmpty(port) ? null : Int32.Parse(port),
                                                 login, password, fromEmail, model.Email);

            var link = GetLink(ticket.Id.ToString());

            Task.Run(() => sender.Send("Invitation link HSM", link));
        }
Exemple #2
0
        private ActionResult ViewInvite(InviteViewModel viewModel)
        {
            var firmaPage = FirmaPageTypeEnum.InviteUser.GetFirmaPage();
            var viewData  = new InviteViewData(CurrentFirmaSession, firmaPage);

            return(RazorView <Invite, InviteViewData, InviteViewModel>(viewData, viewModel));
        }
Exemple #3
0
        public async Task <IActionResult> InviteUser(InviteViewModel inviteViewModel)
        {
            Invite invite = new Invite();

            invite.Email          = inviteViewModel.Email;
            invite.FacilityId     = inviteViewModel.FacilityId;
            invite.OrganizationId = inviteViewModel.organization_id;
            invite.RoleId         = inviteViewModel.RoleId;
            invite.CreationDate   = DateTime.Now;
            var InvitedUser = await _inviteservice.InsertInvite(invite);

            var claimsIdentity = new ClaimsIdentity(new List <Claim>()
            {
                new Claim(ClaimTypes.Name, InvitedUser.Email),
                new Claim(ClaimTypes.NameIdentifier, InvitedUser.Id.ToString()),
            }, "Identity.Application");

            var token = _passwordService.CreateAccessToken(_passwordService.CreateJwtClaims(claimsIdentity));

            var baseUrl = string.Format("{0}://{1}{2}/", Request.Scheme, Request.Host, Request.PathBase) + "api/User/GetInvitedUser?token=" + token;
            //api / User / GetInvitedUser ? id = 4
            var organisation = await _organizationService.GetOrganization(inviteViewModel.organization_id);

            var emailBody     = string.Format(AppConstants.InviteEmailTemplate, baseUrl);
            var emailsubjects = string.Format(AppConstants.InviteEmailSubject, organisation.Name);
            var apiKey        = AppConstants.SendGridKey;
            var result        = await _sendEmailService.send_email_sendgrid(apiKey, invite.Email, emailsubjects, emailBody);

            return(Ok(result));
        }
        public PartialViewResult InviteModal()
        {
            var userId    = User.Identity.GetUserId();
            var user      = db.Users.Find(userId);
            var houseId   = user.HouseholdId;
            var housename = "";

            if (user.Household == null)
            {
                housename = "NoHouse";
            }
            if (user.Household != null)
            {
                housename = user.Household.Name;
            }
            var house     = housename;
            var HouseInfo = new InviteViewModel
            {
                HouseholdId = houseId,
                UserFirst   = user.FirstName,
                UserLast    = user.LastName,
                House       = house,
                SendEmail   = user.Email
            };

            return(PartialView("~/Views/Shared/_InviteModal.cshtml", HouseInfo));
        }
        public async Task SendEventManagerInviteShouldCreateInvite_WhenUserIsOrgAdminForCampaign()
        {
            // Arrange
            var mockMediator = new Mock <IMediator>();
            var @event       = new Event
            {
                Campaign = new Campaign()
                {
                    ManagingOrganizationId = 1
                }
            };

            mockMediator.Setup(mock => mock.SendAsync(It.IsAny <EventByEventIdQuery>())).ReturnsAsync(@event);

            var sut = new InviteController(mockMediator.Object, new FakeUserManager());

            sut.MakeUserAnOrgAdmin(organizationId: "1");
            var invite = new InviteViewModel
            {
                EventId             = 1,
                InviteeEmailAddress = "*****@*****.**",
                CustomMessage       = "test message"
            };

            // Act
            IActionResult result = await sut.SendEventManagerInvite(invite.EventId, invite);

            // Assert
            mockMediator.Verify(x => x.SendAsync(It.Is <CreateEventManagerInviteCommand>(c => c.Invite == invite)), Times.Once);
        }
        public async Task <string> InviteWizardAsync(InviteViewModel inviteViewModel)
        {
            //Create a new Company - Database
            var companyId = await CreateCompanyAsync(inviteViewModel.CompanyName, inviteViewModel.CompanyDescription);

            //Create a new BTUser - UserManager
            var user = new AppUser
            {
                Email          = inviteViewModel.Email,
                UserName       = inviteViewModel.Email,
                FirstName      = inviteViewModel.FirstName,
                LastName       = inviteViewModel.LastName,
                EmailConfirmed = true,
                CompanyId      = companyId
            };
            var result = await _userManager.CreateAsync(user, "Xyz$098#");

            //Assign that user to a role - RoleService
            await _roleService.AddUserToRoleAsync(user, Roles.Admin.ToString());

            //Create a new project - Database
            var projectId = await CreateProjectAsync(inviteViewModel.ProjectName, inviteViewModel.ProjectDescription, companyId);

            //Assign that user to that project - ProjectService
            await _projectService.AddUserToProjectAsync(user.Id, projectId);

            return(user.Id);
        }
Exemple #7
0
        public async Task CreateEventManagerInvite()
        {
            var handler = new CreateEventManagerInviteCommandHandler(Context);
            var invite  = new InviteViewModel
            {
                CustomMessage       = "message",
                EventId             = 5,
                InviteeEmailAddress = "*****@*****.**",
            };

            var inviteCommand = new CreateEventManagerInviteCommand
            {
                Invite = invite,
                UserId = "userId"
            };

            handler.DateTimeUtcNow = () => new DateTime(2016, 5, 29);

            await handler.Handle(inviteCommand);

            Context.CampaignManagerInvites.Count().ShouldBe(0);
            Context.EventManagerInvites.Count().ShouldBe(1);
            Context.EventManagerInvites.FirstOrDefault().AcceptedDateTimeUtc.ShouldBe(null);
            Context.EventManagerInvites.FirstOrDefault().CustomMessage.ShouldBe("message");
            Context.EventManagerInvites.FirstOrDefault().EventId.ShouldBe(5);
            Context.EventManagerInvites.FirstOrDefault().InviteeEmailAddress.ShouldBe("*****@*****.**");
            Context.EventManagerInvites.FirstOrDefault().RejectedDateTimeUtc.ShouldBe(null);
            Context.EventManagerInvites.FirstOrDefault().RevokedDateTimeUtc.ShouldBe(null);
            Context.EventManagerInvites.FirstOrDefault().SenderUserId.ShouldBe("userId");
            Context.EventManagerInvites.FirstOrDefault().SentDateTimeUtc.ShouldBe(new DateTime(2016, 5, 29));
        }
        public async Task SendEventManagerInvitePostReturnsUnauthorizedResult_WhenUserIsNotOrgAdminForCampaign()
        {
            // Arrange
            var mockMediator = new Mock <IMediator>();
            var @event       = new Event
            {
                Campaign = new Campaign()
                {
                    ManagingOrganizationId = 1
                }
            };

            mockMediator.Setup(mock => mock.SendAsync(It.IsAny <EventByEventIdQuery>())).ReturnsAsync(@event);

            var sut = new InviteController(mockMediator.Object, new FakeUserManager());

            sut.MakeUserAnOrgAdmin(organizationId: "2");
            var invite = new InviteViewModel();

            // Act
            IActionResult result = await sut.SendEventManagerInvite(eventId, invite);

            // Assert
            Assert.IsType <UnauthorizedResult>(result);
        }
        /// <summary>
        /// Generates the invite menu item.
        /// </summary>
        /// <returns></returns>
        private MenuItem GenerateInviteMenuItem()
        {
            var item = new MenuItem();

            item.Header = Resources.InviteViewMenuTitle;

            var isEnabled = startupParams.AuthProvider != null;

            item.IsEnabled = isEnabled;

            item.Click += (sender, args) =>
            {
                var model = new InviteModel(startupParams.AuthProvider);
                model.MessageLogged += this.OnMessageLogged;

                var viewModel = new InviteViewModel(model);

                var view = new InviteView(viewModel)
                {
                    Owner = loadedParams.DynamoWindow,
                    WindowStartupLocation = WindowStartupLocation.CenterOwner
                };

                view.ShowDialog();

                model.MessageLogged -= this.OnMessageLogged;
            };

            return(item);
        }
Exemple #10
0
        public async Task <IActionResult> InviteUser(int id, [FromBody] InviteViewModel model)
        {
            var userId = User.GetUserId();

            if (model.UserId == userId)
            {
                return(this.BadRequestError("You can't invite yourself."));
            }

            var ev = await _eventService.GetEventByIdAsync(id, nameof(Event.Period), nameof(Event.Owner));

            if (userId != ev.Owner.Id)
            {
                return(this.BadRequestError("Only owner can invite users."));
            }

            if (ev.IsPrivate)
            {
                return(this.BadRequestError("You can't invite users on private event."));
            }

            if (ev.IsOld(DateTime.UtcNow))
            {
                return(this.BadRequestError("You can't invite users on events from the past."));
            }

            await _eventService.InviteUserAsync(ev.Id, model.UserId, userId, model.IsReadOnly);

            var invitation = await _invitationService.GetInvitationAsync(id, model.UserId);

            await _invitationManager.UserInvitedAsync(model.UserId, _mapper.Map <InvitationViewModel>(invitation));

            return(Ok());
        }
        public async Task <IActionResult> Create([Bind("Email, FirstName, LastName, CompanyName, CompanyDescription, ProjectName, ProjectDescription")] InviteViewModel inviteViewModel)
        {
            if (ModelState.IsValid)
            {
                var userId = await _inviteService.InviteWizardAsync(inviteViewModel);

                var companyId = _context.Companies.FirstOrDefault(c => c.Name == inviteViewModel.CompanyName).Id;
                var invite    = new Invite
                {
                    Email        = inviteViewModel.Email,
                    CompanyId    = companyId,
                    InviteDate   = DateTime.Now,
                    IsValid      = true,
                    InvitorId    = _userManager.GetUserId(User),
                    InviteeId    = userId,
                    CompanyToken = Guid.NewGuid()
                };
                _context.Add(invite);
                await _context.SaveChangesAsync();

                var code        = invite.CompanyToken;
                var callbackUrl = Url.Action(
                    "AcceptInvite",
                    "Tickets",
                    values: new { userId, code, },
                    protocol: Request.Scheme);

                await _emailSender.SendEmailAsync(invite.Email, "Join my Bug Tracker",
                                                  $"Create a ticket in my bug tracker by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");

                return(RedirectToAction(nameof(Index)));
            }

            return(View(inviteViewModel));
        }
Exemple #12
0
 internal List <InviteViewModel> getInviteByStudentId(string studentId)
 {
     using (SqlConnection sqlConnection = new SqlConnection(connectionString))
     {
         using (SqlCommand command = new SqlCommand("sp_UserGetInvitesByStudentId", sqlConnection))
         {
             try
             {
                 sqlConnection.Open();
                 command.CommandType = CommandType.StoredProcedure;
                 command.Parameters.AddWithValue("@Student", studentId);
                 SqlDataReader          rdr        = command.ExecuteReader();
                 List <InviteViewModel> inviteList = new List <InviteViewModel>();
                 while (rdr.Read())
                 {
                     InviteViewModel invite = new InviteViewModel();
                     invite.Id         = Convert.ToInt32(rdr["Id"]);
                     invite.StudentId  = rdr["StudentId"].ToString();
                     invite.TeacherId  = rdr["TeacherId"].ToString();
                     invite.SubjectId  = Convert.ToInt32(rdr["SubjectId"]);
                     invite.Accepted   = Convert.ToBoolean(rdr["Accepted"]);
                     invite.CreateDate = Convert.ToDateTime(rdr["CreateDate"]);
                     inviteList.Add(invite);
                 }
                 return(inviteList);
             }
             catch (Exception ex)
             {
                 throw ex;
             }
         }
     }
 }
Exemple #13
0
        public IActionResult AddNewRecordLabel(InviteViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            var response = _userManager.CreateUser(model.Name, model.Email, Role.RecordLabel);

            if (response == null)
            {
                ModelState.AddModelError("Email", "Email already exists");
                return(View(model));
            }
            var user = response.Result;

            _recordLabelManager.Create(new RecordLabel()
            {
                User = user
            }, CurrentLoggedUserId);
            _recordLabelManager.Save();
            var code        = _userManager.GeneratePasswordResetTokenAsync(user).Result;
            var callbackUrl = Url.ResetPasswordCallbackLink(user.Id.ToString(), code, Request.Scheme);

            _emailsManager.PrepareSendMail(EmailTemplateType.InvitedRecordLabel, model.Email, callbackUrl);

            return(View("SuccessfullyInvited"));
        }
        public async Task <IActionResult> SendEventManagerInvite(int eventId, InviteViewModel invite)
        {
            if (invite == null)
            {
                return(BadRequest());
            }

            if (ModelState.IsValid)
            {
                var @event = await _mediator.SendAsync(new EventByEventIdQuery { EventId = eventId });

                if (@event == null)
                {
                    return(BadRequest());
                }

                if (!IsUserAuthorizedToSendInvite(@event.Campaign.ManagingOrganizationId))
                {
                    return(Unauthorized());
                }

                invite.EventId = eventId;
                var user = await _userManager.GetUserAsync(User);

                await _mediator.SendAsync(new CreateEventManagerInviteCommand { Invite = invite, UserId = user?.Id });

                return(RedirectToAction(actionName: "Details", controllerName: "Event", routeValues: new { area = AreaNames.Admin, id = invite.EventId }));
            }

            return(View("Send", invite));
        }
Exemple #15
0
        /// <summary>
        /// Create an invite and send it to the user.
        /// </summary>
        /// <param name="invite"> The invite.  </param>
        /// <param name="userId"> The user id of the person doing the inviting.  </param>
        /// <param name="inviteIndexUri"> The invite Index Uri. </param>
        /// <returns> The <see cref="InviteViewModel"/>.  </returns>
        public InviteViewModel CreateInvite(InviteViewModel invite, int userId, Uri inviteIndexUri)
        {
            // Check if the invite already exists
            var foundInvite = this.repo.GetInvite(invite.InviteeEmailAddress);

            if (foundInvite != null)
            {
                return(this.ResendInvite(foundInvite, inviteIndexUri)
                    ? this.conversions.ConvertDatabaseModelToViewModel(foundInvite)
                    : null);
            }

            var inviteToCreate = this.conversions.ConvertViewModelToDatabaseModel(invite);

            inviteToCreate.CreatorID = userId;
            inviteToCreate.CreatedAt = DateTime.Now;
            inviteToCreate.Token     = Guid.NewGuid().ToString();

            var createdInvite = this.repo.CreateInvite(inviteToCreate);

            if (createdInvite == null)
            {
                return(null);
            }

            var email = new InviteEmail(createdInvite);

            email.Send(inviteIndexUri);

            return(this.conversions.ConvertDatabaseModelToViewModel(createdInvite));
        }
        public async Task <IActionResult> SendCampaignManagerInvite(int campaignId, InviteViewModel invite)
        {
            if (invite == null)
            {
                return(BadRequest());
            }

            if (ModelState.IsValid)
            {
                var campaign = await _mediator.SendAsync(new CampaignByCampaignIdQuery { CampaignId = campaignId });

                if (campaign == null)
                {
                    return(BadRequest());
                }

                if (!IsUserAuthorizedToSendInvite(campaign.ManagingOrganizationId))
                {
                    return(Unauthorized());
                }

                invite.CampaignId = campaignId;
                var user = await _userManager.GetUserAsync(User);

                await _mediator.SendAsync(new CreateCampaignManagerInviteCommand { Invite = invite, UserId = user?.Id });

                return(RedirectToAction(actionName: "Details", controllerName: "Campaign", routeValues: new { area = "Admin", id = invite.CampaignId }));
            }

            return(View("Send", invite));
        }
        public async Task <IActionResult> Edit(InviteViewModel model)
        {
            if (ModelState.IsValid)
            {
                var currentUser = await User.GetApplicationUser(_userManager);

                var invite = await _context.Invites.Include(i => i.CreatedUser).SingleAsync(m => m.Id == model.Id);

                if (invite == null || invite.InvitedById != currentUser.Id)
                {
                    return(NotFound());
                }

                var createdUser = invite.CreatedUser;

                createdUser.Email       = model.Email;
                createdUser.DisplayName = model.Email;
                createdUser.UserName    = model.Email;

                await _userManager.UpdateAsync(createdUser);

                await _invitesService.SendEmail(invite, Url);

                return(RedirectToAction(nameof(Index)));
            }

            return(View(model));
        }
        public async Task SendEventManagerInviteShouldNotCreateInvite_WhenUserIsNotOrgAdminForCampaign()
        {
            // Arrange
            var mockMediator = new Mock <IMediator>();
            var @event       = new Event
            {
                Campaign = new Campaign()
                {
                    ManagingOrganizationId = 1
                }
            };

            mockMediator.Setup(mock => mock.SendAsync(It.IsAny <EventByEventIdQuery>())).ReturnsAsync(@event);

            var sut = new InviteController(mockMediator.Object, new FakeUserManager());

            sut.MakeUserAnOrgAdmin(organizationId: "2");
            var invite = new InviteViewModel();

            // Act
            IActionResult result = await sut.SendEventManagerInvite(eventId, invite);

            // Assert
            mockMediator.Verify(x => x.SendAsync(It.IsAny <CreateCampaignManagerInviteCommand>()), Times.Never);
        }
Exemple #19
0
        public JsonResult Invite([FromBody] InviteViewModel model)
        {
            SmtpClient client = new SmtpClient(Configuration["Smtp:Host"], int.Parse(Configuration["Smtp:Port"]));

            client.UseDefaultCredentials = false;
            client.Credentials           = new NetworkCredential(Configuration["Smtp:User"], Configuration["Smtp:Password"]);

            MailMessage message = new MailMessage();

            message.From = new MailAddress("*****@*****.**");
            message.To.Add(new MailAddress(model.Email));

            StreamReader reader = new StreamReader("Emails/invitation.html");
            string       letter = reader.ReadToEnd();

            reader.Dispose();
            reader.Close();
            message.Body       = letter;
            message.IsBodyHtml = true;

            message.Subject = "You are the chosen one";

            client.Send(message);

            return(Json(new
            {
                status = true
            }));
        }
        public ActionResult AddtoHouse(InviteViewModel model, int id)
        {
            var house = db.Household.Find(id);

            model.Id.Equals(id);

            return(View(model));
        }
        public void Startup(ViewStartupParams p)
        {
            publishModel     = new PublishModel(p.AuthProvider, p.CustomNodeManager);
            publishViewModel = new PublishViewModel(publishModel);

            inviteModel = new InviteModel(p.AuthProvider);
            inviteModel.MessageLogged += this.OnMessageLogged;
            inviteViewModel            = new InviteViewModel(inviteModel);
        }
        public void InviteRejected()
        {
            var  i      = new InviteViewModel(new Structures.AndersonInvite());
            bool result = true;

            i.InviteProcessed += (_, b) => result = b;

            i.Invite_Rejected.Execute();
            Assert.False(result);
        }
        public void InviteAccepted()
        {
            var  i      = new InviteViewModel(new Structures.AndersonInvite());
            bool result = false;

            i.InviteProcessed += (_, b) => result = b;

            i.Invite_Accepted.Execute();
            Assert.True(result);
        }
        public IActionResult Invite()
        {
            var listOfContacts = GetEmailsList();
            var model          = new InviteViewModel()
            {
                Contacts = listOfContacts
            };

            return(View(model));
        }
        public async Task <IActionResult> Invite(string name)
        {
            var users = await userService.GetAllAsync();

            ViewData["Users"] = new SelectList(users.Where(u => u.Rank != "Admin" && u.Rank != "Organizer"), "Username", "Username");
            var inviteViewModel = new InviteViewModel();

            inviteViewModel.Name = name;
            return(View(inviteViewModel));
        }
Exemple #26
0
        private ActionResult ViewInvite(InviteViewModel viewModel)
        {
            var neptunePage   = NeptunePage.GetNeptunePageByPageType(NeptunePageType.InviteUser);
            var organizations = HttpRequestStorage.DatabaseEntities.Organizations.OrderBy(x => x.OrganizationName).ToList();
            var cancelUrl     = Request.UrlReferrer != null?Request.UrlReferrer.ToString() : SitkaRoute <HomeController> .BuildUrlFromExpression(x => x.Index());

            var viewData = new InviteViewData(CurrentPerson, organizations, neptunePage, cancelUrl);

            return(RazorView <Invite, InviteViewData, InviteViewModel>(viewData, viewModel));
        }
        public async Task <IActionResult> SendInvite([FromBody] InviteViewModel invite)
        {
            if (User.Identity.IsAuthenticated &&
                !DataService.GetUserByNameWithOrg(User.Identity.Name).IsAdministrator)
            {
                return(Unauthorized());
            }
            if (!ModelState.IsValid)
            {
                return(BadRequest());
            }

            Request.Headers.TryGetValue("OrganizationID", out var orgID);


            if (!DataService.DoesUserExist(invite.InvitedUser))
            {
                var result = await DataService.CreateUser(invite.InvitedUser, invite.IsAdmin, orgID);

                if (result)
                {
                    var user = await UserManager.FindByEmailAsync(invite.InvitedUser);

                    await UserManager.ConfirmEmailAsync(user, await UserManager.GenerateEmailConfirmationTokenAsync(user));

                    return(Ok());
                }
                else
                {
                    return(BadRequest("There was an issue creating the new account."));
                }
            }
            else
            {
                var newInvite = DataService.AddInvite(orgID, invite);

                var inviteURL   = $"{Request.Scheme}://{Request.Host}/Invite?id={newInvite.ID}";
                var emailResult = await EmailSender.SendEmailAsync(invite.InvitedUser, "Invitation to Organization in Remotely",
                                                                   $@"<img src='{Request.Scheme}://{Request.Host}/images/Remotely_Logo.png'/>
                            <br><br>
                            Hello!
                            <br><br>
                            You've been invited to join an organization in Remotely.
                            <br><br>
                            You can join the organization by <a href='{HtmlEncoder.Default.Encode(inviteURL)}'>clicking here</a>.",
                                                                   orgID);

                if (!emailResult)
                {
                    return(Problem("There was an error sending the invitation email."));
                }

                return(Ok());
            }
        }
        public IActionResult SendInvite([FromBody] InviteViewModel model)
        {
            //Получаем из токена username
            var username = User.Identity.Name;

            //Ищем данного пользователя
            var user = _context.Users
                       .Include(u => u.UserGroups)
                       .ThenInclude(ug => ug.Group)
                       .FirstOrDefault(u => u.Username == username);

            int group_id = model.GroupId;

            //Ищем данную группу
            var group = _context.Groups
                        .Include(g => g.UserGroups)
                        .ThenInclude(ug => ug.User)
                        .FirstOrDefault(g => g.Id == group_id);

            var requesterUsername = model.UserName;

            //Ищем пользователя, который сделал запрос
            var userToInvite = _context.Users
                               .Include(u => u.UserGroups)
                               .ThenInclude(ug => ug.Group)
                               .FirstOrDefault(u => u.Username == requesterUsername);

            //Если все существует
            if (user != null && group != null && userToInvite != null)
            {
                //Смотрим сть ли уже у пользователя приглашение
                var request = _context.Invites
                              .Include(ppr => ppr.User)
                              .Include(ppr => ppr.Group)
                              .FirstOrDefault(ppr => ppr.Group.Id == group_id && ppr.User.Id == userToInvite.Id);

                //Если нет, то приглашаем, если есть то игнорируем
                if (request == null)
                {
                    var newInvite = new InviteToGroup
                    {
                        User  = userToInvite,
                        Group = group
                    };
                    _context.Invites.Add(newInvite);
                    _context.SaveChanges();
                }

                return(Ok());
            }
            else
            {
                return(Unauthorized());
            }
        }
        public async Task <IActionResult> ChooseJury(string name)
        {
            var users = await this.userService.GetAllAsync();

            ViewData["Users"] = new SelectList(users.Where(u => u.Rank == "Master" || u.Rank == "Wise and Benevolent Photo Dictator"),
                                               "Username", "Username");
            var inviteViewModel = new InviteViewModel();

            inviteViewModel.Name = name;
            return(View(inviteViewModel));
        }
Exemple #30
0
        //you are now
        //leaving the main page
        //we will miss you

        public ActionResult InviteUser(int id)
        {
            if (db.Households.FirstOrDefault(h => h.Id == id).Keyword == null)
            {
                return(RedirectToAction("SetKeyword", new { Id = id }));
            }
            var model = new InviteViewModel();

            model.Id = id;
            return(View(model));
        }