Beispiel #1
0
        private void sendInviteEmail(UserInvite invite)
        {
            if (System.Text.RegularExpressions.Regex.IsMatch(invite.ReceiverMail, RegPattern.Email) == false)
            {
                inviteService.DeleteInvite(invite);
                logger.Info(lang.get("exEmailFormat") + ": " + invite.Inviter.Name + "[" + invite.ReceiverMail + "]");
                return;
            }

            MailClient mail = MailClient.Init();

            String title = invite.Inviter.Name + lang.get("inviteMailTitle");
            String msg   = invite.MailBody;

            Result sentResult = mail.Send(invite.ReceiverMail, title, msg);

            if (sentResult.IsValid)
            {
                inviteService.SendDone(invite);
                logger.Info(lang.get("inviteSendDone") + ": " + invite.Inviter.Name + "[" + invite.ReceiverMail + "]");
            }
            else
            {
                inviteService.SendError(invite);
                logger.Info(lang.get("inviteSendFailure") + ": " + invite.Inviter.Name + "[" + invite.ReceiverMail + "]");
            }
        }
Beispiel #2
0
        public bool InviteUser(UserInvite userInvite)
        {
            var identityClaims = (ClaimsIdentity)User.Identity;

            #region guard
            if (string.IsNullOrEmpty(userInvite.Email))
            {
                return(false);
            }
            if (string.IsNullOrEmpty(userInvite.FirstName) && string.IsNullOrEmpty(userInvite.LastName))
            {
                return(false);
            }
            #endregion

            userInvite.CreateBy   = identityClaims.FindFirst("UserName").Value;
            userInvite.ModifyBy   = identityClaims.FindFirst("UserName").Value;
            userInvite.CreateDate = DateTime.UtcNow;
            userInvite.ModifyDate = DateTime.UtcNow;

            UserService userService = new UserService();
            userService.AddInviteUser(userInvite, identityClaims.FindFirst("Email").Value);

            return(true);
        }
Beispiel #3
0
        public void CancelInvite()
        {
            PolicyCheckBuilder()
            .ExpectCheck(SecurityPolicies.CanManageUsersOnSystem)
            .AssertSuccess(
                async userService =>
            {
                var userInvite = new UserInvite
                {
                    Email     = "*****@*****.**",
                    Accepted  = false,
                    Role      = new IdentityRole(),
                    RoleId    = Guid.Empty.ToString(),
                    Created   = DateTime.UtcNow,
                    CreatedBy = "Test creator"
                };

                var userAndRolesContextId = Guid.NewGuid().ToString();
                await using (var userAndRolesDbContext =
                                 InMemoryUserAndRolesDbContext(userAndRolesContextId))
                {
                    await userAndRolesDbContext.AddAsync(userInvite);
                    await userAndRolesDbContext.SaveChangesAsync();
                }

                await using (var userAndRolesDbContext =
                                 InMemoryUserAndRolesDbContext(userAndRolesContextId))
                {
                    var userManagementService =
                        BuildUserManagementService(userAndRolesDbContext, userService.Object);
                    return(await userManagementService.CancelInvite(userInvite.Email));
                }
            });
        }
        public async Task <UserInvite> Create(string email, string roleId, Guid createdById)
        {
            var existingInvite = await _usersAndRolesDbContext
                                 .UserInvites
                                 .AsQueryable()
                                 .SingleOrDefaultAsync(i => i.Email.ToLower().Equals(email.ToLower()));

            if (existingInvite != null)
            {
                return(existingInvite);
            }

            var newInvite = new UserInvite
            {
                Email       = email.ToLower(),
                RoleId      = roleId,
                Created     = DateTime.UtcNow,
                CreatedById = createdById.ToString(),
            };

            _usersAndRolesDbContext.Add(newInvite);
            await _usersAndRolesDbContext.SaveChangesAsync();

            return(newInvite);
        }
        public void ResendInvite_KeyIsRegenerated()
        {
            UserInvite userInvite       = UserInvite.Create(this.userInvitedById, "*****@*****.**");
            Guid       inviteKeyCurrent = userInvite.InviteKey;

            userInvite.ResendInvite();
            inviteKeyCurrent.Should().NotBe(userInvite.InviteKey);
        }
Beispiel #6
0
        public IHttpActionResult SendUserInvite(string email)
        {
            var userdevice = UserManager.FindByName(User.Identity.Name);
            var user       = _db.Users.First(node => node.Id == userdevice.UserId);
            var message    = new UserInvite(user, email, ControllerContext);

            message.Send();
            return(Ok());
        }
        public void Remove_UserWasNotInTheGroup_Throws()
        {
            Mock <Group> group = new Mock <Group>();

            group.SetupGet(x => x.Id).Returns(Guid.Empty);

            UserInvite userInvite = UserInvite.Create(this.userInvitedById, "*****@*****.**");

            userInvite.Remove(group.Object);
        }
        public void Add_GrouIsNull_Throws()
        {
            Mock <Group> group = new Mock <Group>();

            group.SetupGet(x => x.Id).Returns(Guid.Empty);

            UserInvite userInvite = UserInvite.Create(this.userInvitedById, "*****@*****.**");

            userInvite.Add(null);
        }
Beispiel #9
0
        /// <summary>
        /// 保存成员(并自动添加企业号成员)
        /// </summary>
        /// <param name="userIds">成员Id</param>
        /// <returns></returns>
        public void SaveMember(string[] userIds, out string msg)
        {
            List <UserEntity> usreList = userBLL.GetList().ToList();
            List <WeChatDeptRelationEntity> departmentList = weChatOrganizeBLL.GetList().ToList();
            int succeed = 0;
            int error   = 0;

            foreach (var userId in userIds)
            {
                try
                {
                    UserEntity userEntity = usreList.Find(t => t.UserId == userId);
                    WeChatDeptRelationEntity weChatDeptRelationEntity = departmentList.Find(t => t.DeptId == userEntity.DepartmentId);


                    UserCreate userCreate = new UserCreate();
                    userCreate.userid   = userEntity.Account;
                    userCreate.name     = userEntity.RealName;
                    userCreate.position = userEntity.PostName;
                    userCreate.mobile   = userEntity.Mobile;
                    userCreate.gender   = userEntity.Gender == 1 ? "1" : "2";
                    userCreate.email    = userEntity.Email;
                    userCreate.weixinid = userEntity.WeChat;
                    string departmentId = weChatDeptRelationEntity.WeChatDeptId.ToString();
                    userCreate.department = new List <string>()
                    {
                        departmentId
                    };
                    var result = userCreate.Send();
                    if (result.errcode == 0)
                    {
                        UserInvite userInvite = new UserInvite();
                        userInvite.userid = userCreate.userid;
                        result            = userInvite.Send();
                    }

                    WeChatUserRelationEntity weChatUserRelationEntity = new WeChatUserRelationEntity();
                    weChatUserRelationEntity.UserRelationId = userCreate.userid;
                    weChatUserRelationEntity.UserId         = userCreate.userid;
                    weChatUserRelationEntity.DeptId         = weChatDeptRelationEntity.DeptId;
                    weChatUserRelationEntity.DeptName       = weChatDeptRelationEntity.DeptName;
                    weChatUserRelationEntity.WeChatDeptId   = departmentId.ToInt();
                    weChatUserRelationEntity.SyncState      = result.errcode.ToString();
                    weChatUserRelationEntity.SyncLog        = result.errmsg;
                    service.SaveForm("", weChatUserRelationEntity);

                    succeed++;
                }
                catch (System.Exception)
                {
                    error++;
                }
            }
            msg = "成功:" + succeed + " ;错误:" + error;
        }
Beispiel #10
0
 public UserInviteView(UserInvite userInvite)
 {
     Id              = userInvite.Id;
     GuildId         = userInvite.GuildId.ToString();
     TargetChannelId = userInvite.TargetChannelId.ToString();
     JoinedUserId    = userInvite.JoinedUserId.ToString();
     UsedInvite      = userInvite.UsedInvite;
     InviteIssuerId  = userInvite.InviteIssuerId.ToString();
     JoinedAt        = userInvite.JoinedAt;
     InviteCreatedAt = userInvite.InviteCreatedAt;
 }
        public void Add_UserIsAlreadyAddedToTheGroup_Throws()
        {
            Mock <Group> group = new Mock <Group>();

            group.SetupGet(x => x.Id).Returns(Guid.Empty);

            UserInvite userInvite = UserInvite.Create(this.userInvitedById, "*****@*****.**");

            userInvite.Add(group.Object);
            userInvite.Add(group.Object);
        }
        public void Add_UserIsAddedToTheGroup()
        {
            Mock <Group> group = new Mock <Group>();

            group.SetupGet(x => x.Id).Returns(Guid.Empty);

            UserInvite userInvite = UserInvite.Create(this.userInvitedById, "*****@*****.**");

            userInvite.Add(group.Object);

            userInvite.GroupIds[0].Should().Be(Guid.Empty);
        }
Beispiel #13
0
        public virtual void AddMail( User inviter, List<String> mailList, String mailBody )
        {
            foreach (String mail in mailList) {

                if (hasExist( inviter, mail )) continue;

                UserInvite ui = new UserInvite();
                ui.Inviter = inviter;
                ui.MailBody = mailBody;
                ui.ReceiverMail = mail;
                ui.insert();
            }
        }
Beispiel #14
0
        /// <summary>
        /// Remove the invite based on the id.
        /// </summary>
        /// <param name="inviteId"></param>
        /// <returns>True if the invite is removed, false otherwise.</returns>
        public bool RemoveInvite(int inviteId)
        {
            UserInvite invite = _inviteRepository.GetById(inviteId);

            if (invite == null)
            {
                return(false);
            }

            _inviteRepository.Delete(invite);

            return(true);
        }
        private void UserInviteClick(object sender, System.Windows.RoutedEventArgs e)
        {
            var username = UserInvite.Text;

            string factoryString = (string)FactoryList.SelectedItem;
            int    factoryID     = getIdFromFactoryString(factoryString);

            ClientServerUtil csu     = ClientServerUtil.getInstance();
            String           message = csu.addMemberToMemberAccess(factoryID, username, factoryString);

            showPopUp(message);
            UserInvite.Clear();
        }
        public void Remove_UserIsRemovedFromTheGroup()
        {
            Mock <Group> group = new Mock <Group>();

            group.SetupGet(x => x.Id).Returns(Guid.Empty);

            UserInvite userInvite = UserInvite.Create(this.userInvitedById, "*****@*****.**");

            userInvite.Add(group.Object);
            userInvite.Remove(group.Object);

            userInvite.GroupIds.Should().HaveCount(0);
        }
Beispiel #17
0
        public async Task <UserInvite> SendInviteEmail(UserInvite userInvite)
        {
            var path = "SendInvite";

            var userInviteRequestDto = new UserInviteRequestDTO()
            {
                ConfirmationUri = CreateConfirmationUri(),
                UserInvite      = userInvite
            };

            var controllerResponseDTO = await Post <UserInviteRequestDTO>(path, userInviteRequestDto);

            return(controllerResponseDTO.Content.UserInvite);
        }
        public void Remove_UserInviteIsInCollection_Removes()
        {
            Guid userInvitedById = Guid.NewGuid();

            UserInvite userInviteA = UserInvite.Create(
                userInvitedById,
                "*****@*****.**"
                );

            this.group.Add(userInviteA);
            this.group.Remove(userInviteA);

            this.group.Invites.Should().HaveCount(0);
        }
Beispiel #19
0
        // Umbraco.Code.MapAll -CreateDate -UpdateDate -DeleteDate
        // Umbraco.Code.MapAll -Id -TourData -StartContentIds -StartMediaIds -Language -Username
        // Umbraco.Code.MapAll -PasswordQuestion -SessionTimeout -EmailConfirmedDate -InvitedDate
        // Umbraco.Code.MapAll -SecurityStamp -Avatar -ProviderUserKey -RawPasswordValue
        // Umbraco.Code.MapAll -RawPasswordAnswerValue -Comments -IsApproved -IsLockedOut -LastLoginDate
        // Umbraco.Code.MapAll -LastPasswordChangeDate -LastLockoutDate -FailedPasswordAttempts
        private void Map(UserInvite source, IUser target, MapperContext context)
        {
            target.Email      = source.Email;
            target.Key        = source.Key;
            target.Name       = source.Name;
            target.IsApproved = false;

            target.ClearGroups();
            var groups = _userService.GetUserGroupsByAlias(source.UserGroups.ToArray());

            foreach (var group in groups)
            {
                target.AddGroup(group.ToReadOnlyGroup());
            }
        }
Beispiel #20
0
        public async Task <UserInvite> CreateInvite(InviteViewModel inviteVM)
        {
            var invite = new UserInvite()
            {
                Email        = inviteVM.InviteEmail,
                PracticeId   = (await _context.Practices.Where(prac => prac.SubscriberPractices.Any(sp => sp.SubscriberUserId == _userProvider.GetUserId())).SingleAsync()).Id,
                CreationDate = _dateProvider.GetCurrentDateTime(),
                Code         = _inviteCodeProvider.GetNewInviteCode(),
                Used         = false
            };

            _context.UserInvites.Add(invite);
            await _context.SaveChangesAsync();

            return(invite);
        }
        public virtual void Add(UserInvite userInvite)
        {
            if (userInvite == null)
            {
                throw new ValidationException("UserInvite can't be empty");
            }

            if (this.invites.Contains(userInvite))
            {
                throw new ValidationException("UserInvite is already in the group");
            }

            this.invites.Add(userInvite);

            this.DateModified = TimeProvider.Current.UtcNow;
        }
Beispiel #22
0
        public virtual void AddMail(User inviter, List <String> mailList, String mailBody)
        {
            foreach (String mail in mailList)
            {
                if (hasExist(inviter, mail))
                {
                    continue;
                }

                UserInvite ui = new UserInvite();
                ui.Inviter      = inviter;
                ui.MailBody     = mailBody;
                ui.ReceiverMail = mail;
                ui.insert();
            }
        }
        public void Add_SameUserInvite_ThrowsException()
        {
            Guid userInvitedById = Guid.NewGuid();

            UserInvite userInviteA = UserInvite.Create(
                userInvitedById,
                "*****@*****.**"
                );

            UserInvite userInviteAA = UserInvite.Create(
                userInvitedById,
                "*****@*****.**"
                );

            this.group.Add(userInviteA);
            this.group.Add(userInviteAA);
        }
        public void Create_EmailIsProvided()
        {
            Mock <UserInvite> expected = new Mock <UserInvite>();

            expected.SetupGet(x => x.Email).Returns("*****@*****.**");
            expected.SetupGet(x => x.DateCreated).Returns(TimeProvider.Current.UtcNow);
            expected.SetupGet(x => x.DateModified).Returns(TimeProvider.Current.UtcNow);
            expected.SetupGet(x => x.GroupIds).Returns(new List <Guid>().AsReadOnly());
            expected.SetupGet(x => x.InvitedByUserId).Returns(this.userInvitedById);

            UserInvite actual = UserInvite.Create(this.userInvitedById, "*****@*****.**");

            actual.ShouldBeEquivalentTo(expected.Object, opt =>
                                        opt.Excluding(
                                            prop =>
                                            prop.PropertyPath == "Id" ||
                                            prop.PropertyPath == "InviteKey"
                                            ));
        }
Beispiel #25
0
        /// <summary>
        /// Checks whether the invite code is valid or not based on the code and the creation time, if the invite is older than 1 day it will be removed (and return false).
        /// </summary>
        /// <param name="inviteCode"></param>
        /// <param name="invite"></param>
        /// <returns>True if the invite is valid, false otherwise.</returns>
        public bool IsValidInviteCode(string inviteCode, out UserInvite invite)
        {
            invite = _inviteRepository.TableNoTracking.FirstOrDefault(invite => invite.InviteCode == inviteCode);

            if (invite == null)
            {
                return(false);
            }

            //invites are only valid for a day
            if (invite.CreationTime.AddDays(1) < DateTime.Now)
            {
                _inviteRepository.Delete(invite);

                invite = null;

                return(false);
            }

            return(true);
        }
Beispiel #26
0
        public async Task <Response> SendEmailInvite(UserInvite invite, Uri confirmationUri)
        {
            var client = new SendGridClient(SendGridOptions.APIKey);

            var message = new SendGridMessage();

            message.SetFrom(SendGridOptions.FromEmail);
            message.AddTo(invite.EmailAddress);
            message.SetTemplateId(SendGridOptions.TemplateId);

            var emailTemplateData = new EmailTemplateData()
            {
                FirstName       = "Josh",
                ConfirmationUri = confirmationUri
            };

            message.SetTemplateData(emailTemplateData);
            message.SetClickTracking(true, true);

            return(await client.SendEmailAsync(message));
        }
Beispiel #27
0
        public static void UpdateUserInvite(SocketGuildUser user, Invite invite, bool unknown = false)
        {
            using MySqlConnection connection = MySQL.getConnection();

            if (unknown)
            {
                invite = new Invite
                {
                    Code   = "Unknown",
                    UserID = 1,
                    Uses   = 0
                }
            }
            ;

            string query = "SELECT * FROM UserInvites";
            IEnumerable <UserInvite> userInvites = connection.Query <UserInvite>(query);

            foreach (UserInvite UserInvite in userInvites)
            {
                if (UserInvite.UserID == user.Id)
                {
                    // Remove it if it exists.
                    query = $"DELETE FROM UserInvites WHERE Code={UserInvite.Code}";
                    connection.Execute(query);
                    return;
                }
            }

            // Add it because it doesn't exist.

            UserInvite userInvite = new UserInvite
            {
                UserID = user.Id,
                Code   = invite.Code
            };

            query = $"INSERT INTO UserInvites (UserID, Code) VALUES ({userInvite.UserID}, '{userInvite.Code}')";
            connection.Execute(query);
        }
Beispiel #28
0
        public bool AddInviteUser(UserInvite userInvite, string inviterEmail)
        {
            using (var context = new ApplicationDbContext())
            {
                try
                {
                    //Get UserId
                    var inviter = context.Users.FirstOrDefault(x => x.Email == inviterEmail);
                    userInvite.InviterUserId = inviter.Id;

                    context.UserInviites.Add(userInvite);
                    context.SaveChanges();
                    //SEND EMAIL
                    return(true);
                }
                catch (Exception e)
                {
                    LogSingleton.ErrorException(e);
                    return(false);
                }
            }
        }
Beispiel #29
0
        public async Task <InviteCodeResult> GetCodeDetails(string code)
        {
            UserInvite dbInvite = await _context.UserInvites.Where(invite => invite.Code == code).SingleOrDefaultAsync();

            if (dbInvite == null)
            {
                return new InviteCodeResult()
                       {
                           Success = false, Error = "Code not found."
                       }
            }
            ;

            if (dbInvite.Used)
            {
                return new InviteCodeResult()
                       {
                           Success = false, Error = "Code has already been used."
                       }
            }
            ;

            if (dbInvite.CreationDate.AddDays(7) < _dateProvider.GetCurrentDateTime())
            {
                return new InviteCodeResult()
                       {
                           Success = false, Error = "Code expired."
                       }
            }
            ;

            dbInvite.Used = true;
            await _context.SaveChangesAsync();

            return(new InviteCodeResult()
            {
                Success = true, Error = "", PracticeId = dbInvite.PracticeId
            });
        }
        public async Task <ActionResult> AddLike(string username)
        {
            var sourceUserId = User.GetUserId();
            var invitedUser  = await _unitOfWork.UserRepository.GetUserByUsername(username);

            var sourceUser = await _unitOfWork.InviteRepository.GetUserWithInvites(sourceUserId);

            if (invitedUser == null)
            {
                return(NotFound());
            }

            if (sourceUser.UserName == username)
            {
                return(BadRequest("You cannot invite yourself"));
            }

            var userInvite = await _unitOfWork.InviteRepository.GetUserInvite(sourceUserId, invitedUser.Id);

            if (userInvite != null)
            {
                return(BadRequest("You already invited this user"));
            }

            userInvite = new UserInvite
            {
                SourceUserId  = sourceUserId,
                InvitedUserId = invitedUser.Id
            };

            sourceUser.InvitedUsers.Add(userInvite);

            if (await _unitOfWork.Complete())
            {
                return(Ok());
            }

            return(BadRequest("Failed to invite user"));
        }
Beispiel #31
0
        public async Task <Either <ActionResult, UserInvite> > InviteUser(string email, string inviteCreatedByUser,
                                                                          string roleId)
        {
            return(await _userService
                   .CheckCanManageAllUsers()
                   .OnSuccess <ActionResult, Unit, UserInvite>(async() =>
            {
                if (string.IsNullOrWhiteSpace(email))
                {
                    return ValidationActionResult(InvalidEmailAddress);
                }

                if (_usersAndRolesDbContext.Users.Any(u => u.Email.ToLower() == email.ToLower()))
                {
                    return ValidationActionResult(UserAlreadyExists);
                }

                var role = await _usersAndRolesDbContext.Roles.FirstOrDefaultAsync(r => r.Id == roleId);
                if (role == null)
                {
                    return ValidationActionResult(InvalidUserRole);
                }

                var invite = new UserInvite
                {
                    Email = email.ToLower(),
                    Created = DateTime.UtcNow,
                    CreatedBy = inviteCreatedByUser,
                    Role = role
                };
                await _usersAndRolesDbContext.UserInvites.AddAsync(invite);
                await _usersAndRolesDbContext.SaveChangesAsync();
                SendInviteEmail(email);
                return invite;
            }));
        }
Beispiel #32
0
        private void sendInviteEmail( UserInvite invite )
        {
            if (System.Text.RegularExpressions.Regex.IsMatch( invite.ReceiverMail, RegPattern.Email ) == false) {
                inviteService.DeleteInvite( invite );
                logger.Info( lang.get( "exEmailFormat" ) + ": " + invite.Inviter.Name + "[" + invite.ReceiverMail + "]" );
                return;
            }

            MailService mail = MailUtil.getMailService();

            String title = invite.Inviter.Name + lang.get( "inviteMailTitle" );
            String msg = invite.MailBody;

            Boolean isSent = mail.send( invite.ReceiverMail, title, msg );

            if (isSent) {
                inviteService.SendDone( invite );
                logger.Info( lang.get( "inviteSendDone" ) + ": " + invite.Inviter.Name + "[" + invite.ReceiverMail + "]" );
            }
            else {
                inviteService.SendError( invite );
                logger.Info( lang.get( "inviteSendFailure" ) + ": " + invite.Inviter.Name + "[" + invite.ReceiverMail + "]" );
            }
        }
Beispiel #33
0
 public void SendError( UserInvite invite )
 {
     invite.SendStatus = UserInviteEmailStatus.Failure;
     invite.update();
 }
Beispiel #34
0
 public void DeleteInvite( UserInvite invite )
 {
     invite.delete();
 }
Beispiel #35
0
 public void SendDone( UserInvite invite )
 {
     invite.SendStatus = UserInviteEmailStatus.Done;
     invite.update();
 }