public void Update(User user, string passwordHash, UserContactDto userContactDto, UserDataDto userDataDto, UserPaymentDto userPaymentDto, UserNotificationOptionsDto userNotificationOptionsDto, UserPermissionDto userPermissionDto, IList <UploadedFile> newDocuments, IList <Document> documentsToDelete, EntityChangedDto entityChangedDto) { Require.NotNull(user, "user"); Require.NotNull(userContactDto, "userContactDto"); Require.NotNull(userDataDto, "userDataDto"); Require.NotNull(userPermissionDto, "userPermissionDto"); Require.NotNull(entityChangedDto, "entityChangedDto"); Require.NotNull(documentsToDelete, "documentsToDelete"); Require.NotNull(newDocuments, "newDocuments"); IList <Document> documentsToAssign = newDocuments.Select(uf => DocumentRepository.Create(uf)).ToList(); IList <Document> userDocuments = user.Documents.Except(documentsToDelete).Concat(documentsToAssign).ToList(); if (IsDirty(user, passwordHash, userContactDto, userDataDto, userPaymentDto, userNotificationOptionsDto, userPermissionDto, userDocuments)) { user.Update(passwordHash, userContactDto, userDataDto, userPaymentDto, userNotificationOptionsDto, userPermissionDto, userDocuments, entityChangedDto); } }
/// <summary> /// Aktualisiert die Daten. /// </summary> /// <param name="userGroupDto"> /// <see cref="UserGroupDto" /> /// </param> /// <param name="entityChangedDto"> /// <see cref="EntityChangedDto" /> /// </param> public virtual void Update(UserGroupDto userGroupDto, EntityChangedDto entityChangedDto) { Require.NotNull(userGroupDto, nameof(userGroupDto)); Require.NotNull(entityChangedDto, nameof(entityChangedDto)); Update(userGroupDto); Update(entityChangedDto); }
/// <summary> /// Erstellt einen zufälligen Benutzer und gibt diesen zurück wenn keine Dtos übergeben werden /// </summary> /// <returns></returns> public User Create(string username, string passwordHash, UserDataDto userDataDto, UserContactDto userContactDto, UserPaymentDto userPaymentDto, UserNotificationOptionsDto userNotifications, UserPermissionDto userPermissionDto, EntityCreatedDto entityCreatedDto, EntityChangedDto entityChangedDto, IList <Document> documents, bool persist = true) { User user = new User(passwordHash, userContactDto, userDataDto, userPaymentDto, userNotifications, userPermissionDto, documents, entityCreatedDto); if (entityChangedDto != null) { user.Update(userContactDto, userDataDto, userPaymentDto, userNotifications, entityChangedDto); } if (persist) { UserDao.Save(user); UserDao.Flush(); } return(user); }
public void TestUpdate() { // given: UserGroup userGroupToUpdate = UserGroupCreator.Create(); string expectedAdditionalInformations = "Keine"; string expectedName = "die firma"; int expectedAcceptedBalance = -20; UserGroupDto userGroupDtoForUpdate = new UserGroupDto(expectedAdditionalInformations, expectedName, expectedAcceptedBalance); User changedBy = UserCreator.Create("changed by"); DateTime changedAt = new DateTime(2016, 12, 22); EntityChangedDto entityChangedDto = new EntityChangedDto(changedBy, changedAt); // when: userGroupToUpdate.Update(userGroupDtoForUpdate, entityChangedDto); UserGroupDao.FlushAndClear(); UserGroup actualBrokerPool = UserGroupDao.Get(userGroupToUpdate.Id); // then: actualBrokerPool.GetDto().ShouldBeEquivalentTo(userGroupDtoForUpdate); actualBrokerPool.AdditionalInformations.ShouldBeEquivalentTo(expectedAdditionalInformations); actualBrokerPool.BalanceOverdraftLimit.ShouldBeEquivalentTo(expectedAcceptedBalance); actualBrokerPool.ChangedAt.Should().Be(changedAt); actualBrokerPool.ChangedBy.Should().Be(changedBy); actualBrokerPool.Name.ShouldBeEquivalentTo(expectedName); }
/// <summary> /// Markiert den Peanut als fixiert. /// </summary> /// <param name="peanutState">Der neue Status, welchen der Peanut erhalten soll.</param> /// <param name="entityChangedDto"></param> public virtual void UpdateState(PeanutState peanutState, EntityChangedDto entityChangedDto) { Require.NotNull(entityChangedDto, "entityChangedDto"); _peanutState = peanutState; Update(entityChangedDto); }
public void TestUpdateUserProfileProperties() { // given: User user = UserCreator.Create(); User userToUpdate = UserDao.Get(user.Id); UserContactDto userContactDto = UserCreator.CreateUserContactDto("*****@*****.**", "Nürnberger Ei", "0", "01067", "Dresden", Country.DE, "Nürnberger Eieruhren GmbH", "http://www.nuernberger-eier.de", "phone", "privat", "mobile"); UserDataDto userDataDto = UserCreator.CreateUserDataDto("neuerVorname", "neuerNachname", new DateTime(1990, 01, 03), "UserName"); UserPaymentDto userPaymentDto = new UserPaymentDto("paypal", true); UserNotificationOptionsDto notificationsDto = UserNotificationOptionsDto.AllOn; User changedBy = UserCreator.Create(); EntityChangedDto entityChangedDto = new EntityChangedDto(changedBy, new DateTime(2017, 01, 01, 01, 01, 01)); // when: userToUpdate.Update(userContactDto, userDataDto, userPaymentDto, notificationsDto, entityChangedDto); UserDao.FlushAndClear(); User actualUser = UserDao.Get(userToUpdate.Id); // then: DtoAssert.AreEqual(userContactDto, actualUser.GetUserContactDto()); DtoAssert.AreEqual(userDataDto, actualUser.GetUserDataDto()); actualUser.ChangedBy.Should().Be(entityChangedDto.ChangedBy); actualUser.ChangedAt.Should().Be(entityChangedDto.ChangedAt); }
public void ResetPassword(User user, string password, EntityChangedDto entityChangedDto) { Require.NotNull(entityChangedDto, "entityChangedDto"); user.UpdatePassword(password, entityChangedDto); user.UpdatePasswordResetCode(Guid.Empty); }
/// <summary> /// Aktualisiert den Zeitpunkt und den durchführenden Nutzer der letzten Änderung an diesem Nutzer. /// </summary> /// <param name="entityChangedDto"></param> private void Update(EntityChangedDto entityChangedDto) { Require.NotNull(entityChangedDto, "entityChangedDto"); _changedBy = entityChangedDto.ChangedBy; _changedAt = entityChangedDto.ChangedAt; }
/// <summary> /// Entfernt alle übergebenen Dokumente aus der Liste mit Dokumenten, sofern sie in dieser enthalten sind. /// </summary> /// <param name="entityChanged"></param> /// <param name="documents"></param> public virtual void RemoveDocuments(EntityChangedDto entityChanged, params Document[] documents) { Require.NotNull(entityChanged, "entityChanged"); Require.NotNull(documents, "documents"); Update(entityChanged); _documents = _documents.Except(documents).ToList(); }
public virtual void Update(string userName, ProposedUserDataDto proposedUserDataDto, ProposedUserContactDto proposedUserContactDto, EntityChangedDto entityChangedDto) { _userName = userName; Update(proposedUserDataDto); Update(proposedUserContactDto); Update(entityChangedDto); }
/// <summary> /// Markiert eine Rechnung als abgerechnet. /// </summary> /// <param name="entityChangedDto"></param> public virtual void Settle(EntityChangedDto entityChangedDto) { Require.NotNull(entityChangedDto, "entityChangedDto"); _isSettled = true; _settlementDate = entityChangedDto.ChangedAt; Update(entityChangedDto); }
public virtual void Update(string comment, EntityChangedDto entityChangedDto) { Require.NotNull(entityChangedDto, "entityChangedDto"); Update(comment); _changedBy = entityChangedDto.ChangedBy; _changedAt = entityChangedDto.ChangedAt; }
public void TestUpdateUserAllProperties() { // given: User user = UserCreator.Create(); User userToUpdate = UserDao.Get(user.Id); UserContactDto userContactDto = UserCreator.CreateUserContactDto("*****@*****.**", "Nürnberger Ei", "0", "01067", "Dresden", Country.DE, "Nürnberger Eieruhren GmbH", "http://www.nuernberger-eier.de", "phone", "privat", "mobile"); string username = "******"; UserDataDto userDataDto = UserCreator.CreateUserDataDto("neuerVorname", "neuerNachname", null, username); User changedBy = UserCreator.Create(); EntityChangedDto entityChangedDto = new EntityChangedDto(changedBy, new DateTime(2017, 01, 01, 01, 01, 01)); UserPermissionDto userPermissionDto = new UserPermissionDto(new List <string> { Roles.Administrator }, true); UserNotificationOptionsDto notificationsDto = UserNotificationOptionsDto.AllOn; string passwordHash = "newPasswordhash"; List <Document> documents = new List <Document> { DocumentCreator.Create() }; UserPaymentDto userPaymentDto = new UserPaymentDto("", false); // when: userToUpdate.Update(passwordHash, userContactDto, userDataDto, userPaymentDto, notificationsDto, userPermissionDto, documents, entityChangedDto); UserDao.FlushAndClear(); User actualUser = UserDao.Get(userToUpdate.Id); // then: DtoAssert.AreEqual(userContactDto, actualUser.GetUserContactDto()); DtoAssert.AreEqual(userDataDto, actualUser.GetUserDataDto()); DtoAssert.AreEqual(notificationsDto, actualUser.GetNotificationOptions()); DtoAssert.AreEqual(userPermissionDto, actualUser.GetUserPermissionDto()); actualUser.ChangedBy.Should().Be(entityChangedDto.ChangedBy); actualUser.ChangedAt.Should().Be(entityChangedDto.ChangedAt); actualUser.UserName.Should().Be(username); actualUser.PasswordHash.Should().Be(passwordHash); actualUser.Documents.ShouldBeEquivalentTo(documents); }
public void Update(ProposedUser user, string username, ProposedUserDataDto proposedUserDataDto, ProposedUserContactDto proposedUserContactDto, EntityChangedDto entityChangedDto) { Require.NotNull(user, "user"); Require.NotNullOrWhiteSpace(username, "username"); Require.NotNull(proposedUserDataDto, "proposedUserDataDto"); Require.NotNull(proposedUserContactDto, "proposedUserContactDto"); Require.NotNull(entityChangedDto, "entityChangedDto"); user.Update(username, proposedUserDataDto, proposedUserContactDto, entityChangedDto); }
/// <summary> /// Markiert die Zahlung als abgelehnt. /// </summary> /// <param name="declineReason">Warum wird die Zahlung abgelehnt?</param> /// <param name="entityChangedDto">Wann und von wem wurde die Zahlung abgelehnt.</param> public virtual void Decline(string declineReason, EntityChangedDto entityChangedDto) { Require.NotNull(entityChangedDto, "entityChangedDto"); Require.NotNullOrWhiteSpace(declineReason, "declineReason"); _paymentStatus = PaymentStatus.Declined; _declineReason = declineReason; _declinedBy = entityChangedDto.ChangedBy; _declinedAt = entityChangedDto.ChangedAt; }
/// <summary> /// Erzeugt einen neuen Nutzer /// </summary> /// <returns></returns> public User Create(string username = null, string email = "*****@*****.**", string lastname = NACHNAME_CONST, string firstname = VORNAME_CONST, string passwordHash = null, string street = STREET_CONST, string streetNumber = STREET_NUMBER_CONST, string postalCode = POSTALCODE_CONST, string city = CITY_CONST, Country countryTwoLetterIsoCode = COUNTRY_CONST, string company = COMPANY_CONST, string url = URL_CONST, string phone = null, string phonePrivate = null, string mobile = null, string fax = null, string payPalBusinessName = null, bool autoAcceptPayPalPayments = true, EntityCreatedDto creationDto = null, EntityChangedDto latestChangeDto = null, IList <string> roles = null, bool isEnabled = true, IList <Document> documents = null, DateTime?birthday = null, bool persist = true) { if (username == null) { username = GetRandomString(10); } if (firstname == VORNAME_CONST) { firstname = firstname + GetRandomString(4); } if (roles == null) { roles = new List <string> { Roles.Member }; } if (documents == null) { documents = new List <Document>(); } UserContactDto userContactDto = CreateUserContactDto(email, street, streetNumber, postalCode, city, countryTwoLetterIsoCode, company, url, phone, phonePrivate, mobile); UserDataDto userDataDto = CreateUserDataDto(firstname, lastname, birthday, username); UserPermissionDto userPermissionDto = CreateUserPermissionDto(roles, isEnabled); UserPaymentDto userPaymentDto = CreateUserPaymentDto(payPalBusinessName, autoAcceptPayPalPayments); UserNotificationOptionsDto userNotifications = UserNotificationOptionsDto.AllOn; if (creationDto == null) { creationDto = new EntityCreatedDto(null, DateTime.Now.Date); } User user = Create(username, passwordHash, userDataDto, userContactDto, userPaymentDto, userNotifications, userPermissionDto, creationDto, latestChangeDto, documents, persist); return(user); }
/// <summary> /// Akzeptiert die Zahlung der Rechnung durch einen Debitor. /// </summary> /// <param name="user"></param> /// <param name="entityChangedDto"></param> public virtual void AcceptByDebitor(User user, EntityChangedDto entityChangedDto) { Require.NotNull(user, "user"); Require.NotNull(entityChangedDto, "entityChangedDto"); BillUserGroupDebitor debitor = _userGroupDebitors.SingleOrDefault(debMem => debMem.UserGroupMembership.User.Equals(user)); if (debitor != null) { debitor.Accept(); Update(entityChangedDto); } }
/// <summary> /// Fügt Teilnahmen an diesem Peanut hinzu. /// </summary> /// <param name="entityChanged"></param> /// <param name="participations"></param> public virtual void AddParticipators(EntityChangedDto entityChanged, params PeanutParticipation[] participations) { Require.NotNull(entityChanged, "entityChanged"); Require.NotNull(participations, "participations"); Update(entityChanged); foreach (PeanutParticipation participation in participations) { if (!_participations.Contains(participation)) { _participations.Add(participation); } } }
/// <summary> /// Entfernt Teilnahmen aus dem Peanut. /// </summary> /// <param name="entityChanged"></param> /// <param name="participatorsToDelete"></param> public virtual void RemoveParticipators(EntityChangedDto entityChanged, params UserGroupMembership[] participatorsToDelete) { Require.NotNull(entityChanged, "entityChanged"); Require.NotNull(participatorsToDelete, "participatorsToDelete"); Update(entityChanged); foreach (UserGroupMembership userGroupMembership in participatorsToDelete) { PeanutParticipation participationToDelete = _participations.SingleOrDefault(p => p.UserGroupMembership.Equals(userGroupMembership)); if (participationToDelete != null) { _participations.Remove(participationToDelete); } } }
public UserGroup Update(UserGroup userGroup, UserGroupDto userGroupDto, User changedBy) { Require.NotNull(userGroup, nameof(userGroup)); Require.NotNull(userGroupDto, nameof(userGroupDto)); Require.NotNull(changedBy, nameof(changedBy)); if (userGroupDto.Equals(userGroup.GetDto())) { return(userGroup); } EntityChangedDto entityChangedDto = new EntityChangedDto(changedBy, DateTime.Now); userGroup.Update(userGroupDto, entityChangedDto); return(userGroup); }
public void Update(User user, string username, string passwordHash) { Require.NotNull(user, "user"); Require.NotNullOrWhiteSpace(username, "username"); Require.NotNullOrWhiteSpace(passwordHash, "passwordHash"); if (IsDirty(user, passwordHash, user.GetUserContactDto(), user.GetUserDataDto(), user.GetUserPaymentDto(), user.GetNotificationOptions(), user.GetUserPermissionDto(), user.Documents)) { EntityChangedDto changedDto = new EntityChangedDto(user, DateTime.Now); user.UpdatePassword(passwordHash, changedDto); } }
public void Update(User user, UserContactDto userContactDto, UserDataDto userDataDto, UserPaymentDto userPaymentDto, UserNotificationOptionsDto userNotificationOptionsDto, EntityChangedDto entityChangedDto) { Require.NotNull(user, "user"); Require.NotNull(userContactDto, "userContactDto"); Require.NotNull(userDataDto, "userDataDto"); Require.NotNull(entityChangedDto, "entityChangedDto"); Require.NotNull(userPaymentDto, "userPaymentDto"); if (IsDirty(user, user.PasswordHash, userContactDto, userDataDto, userPaymentDto, userNotificationOptionsDto, user.GetUserPermissionDto(), user.Documents)) { user.Update(userContactDto, userDataDto, userPaymentDto, userNotificationOptionsDto, entityChangedDto); } }
public void TestUpdateUserProfile() { // given: User userToUpdate = UserCreator.Create(); UserContactDto userContactDto = new UserContactDto("*****@*****.**", "Straße", "1", "01234", "Stadt", Country.DE, "Unternehmen", "http://www.test.url", "phone", "privat", "mobile"); UserDataDto userDataDto = new UserDataDto("neuerVorname", "neuerNachname", new DateTime(1950, 05, 05), "UserName"); UserPaymentDto userPaymentDto = new UserPaymentDto("PayPal", true); EntityChangedDto changeDto = new EntityChangedDto(UserCreator.Create(), new DateTime(2017, 01, 01, 01, 02, 03)); UserNotificationOptionsDto notificationsDto = UserNotificationOptionsDto.AllOff; // when: UserService.Update(userToUpdate, userContactDto, userDataDto, userPaymentDto, notificationsDto, changeDto); UserService.UserDao.FlushAndClear(); User actualUser = UserService.GetById(userToUpdate.Id); // then: DtoAssert.AreEqual(userContactDto, actualUser.GetUserContactDto()); DtoAssert.AreEqual(userDataDto, actualUser.GetUserDataDto()); DtoAssert.AreEqual(notificationsDto, actualUser.GetNotificationOptions()); actualUser.ChangedBy.Should().Be(changeDto.ChangedBy); actualUser.ChangedAt.Should().Be(changeDto.ChangedAt); }
/// <summary> /// Aktualisiert alle Eigenschaften des Nutzer und markiert ihn als geändert. /// </summary> /// <param name="passwordHash"></param> /// <param name="userContactDto"></param> /// <param name="userDataDto"></param> /// <param name="userPaymentDto"></param> /// <param name="userNotificationOptionsDto"></param> /// <param name="userPermissionDto"></param> /// <param name="documents"> /// Liste mit Dokumenten, die am Nutzer hinterlegt sein soll. Die Liste enthält sowohl neue, als /// auch weiterhin hinterlegte Dokumente /// </param> /// <param name="entityChangedDto"></param> public virtual void Update(string passwordHash, UserContactDto userContactDto, UserDataDto userDataDto, UserPaymentDto userPaymentDto, UserNotificationOptionsDto userNotificationOptionsDto, UserPermissionDto userPermissionDto, IList <Document> documents, EntityChangedDto entityChangedDto) { Require.NotNullOrWhiteSpace(passwordHash, "passwordHash"); Require.NotNull(userContactDto, "userContactDto"); Require.NotNull(userDataDto, "userDataDto"); Require.NotNull(userPermissionDto, "userPermissionDto"); Require.NotNull(entityChangedDto, "entityChangedDto"); Require.NotNull(documents, "documents"); Require.NotNull(userPaymentDto, "userPaymentDto"); Require.NotNull(userNotificationOptionsDto, "userNotificationOptionsDto"); _passwordHash = passwordHash; Update(userContactDto); Update(userDataDto); Update(userPermissionDto); Update(documents); Update(userPaymentDto); Update(userNotificationOptionsDto); Update(entityChangedDto); }
private void Update(EntityChangedDto entityChanged) { _changedAt = entityChanged.ChangedAt; _changedBy = entityChanged.ChangedBy; }
/// <summary> /// Markiert die Zahlung als akzeptiert. /// </summary> /// <param name="entityChangedDto"></param> public virtual void Accept(EntityChangedDto entityChangedDto) { _paymentStatus = PaymentStatus.Accecpted; _acceptedBy = entityChangedDto.ChangedBy; _acceptedAt = entityChangedDto.ChangedAt; }
/// <summary> /// Aktualisiert das Passwort, bzw. den Hash des vom Nutzer verwendeten Passworts. /// </summary> /// <param name="passwordHash"></param> /// <param name="entityChangedDto">Wer hat das Passwort geändert und wann?</param> public virtual void UpdatePassword(string passwordHash, EntityChangedDto entityChangedDto) { _passwordHash = passwordHash; Update(entityChangedDto); }
/// <summary> /// Aktualisiert die Profildaten des Nutzers und markiert ihn als geändert. /// </summary> /// <param name="userContactDto"></param> /// <param name="userDataDto"></param> /// <param name="userPaymentDto"></param> /// <param name="userNotificationOptionsDto"></param> /// <param name="entityChangedDto"></param> public virtual void Update(UserContactDto userContactDto, UserDataDto userDataDto, UserPaymentDto userPaymentDto, UserNotificationOptionsDto userNotificationOptionsDto, EntityChangedDto entityChangedDto) { Require.NotNull(userContactDto, "userContactDto"); Require.NotNull(userDataDto, "userDataDto"); Require.NotNull(entityChangedDto, "entityChangedDto"); Require.NotNull(userPaymentDto, "userPaymentDto"); Require.NotNull(userNotificationOptionsDto, "userNotificationOptionsDto"); Update(userContactDto); Update(userDataDto); Update(userPaymentDto); Update(userNotificationOptionsDto); Update(entityChangedDto); }
public void TestUpdateUser() { // given: Service.UserService userService = new UserService(); userService.UserDao = ContextRegistry.GetContext().GetObject <IUserDao>(); Document document1 = DocumentCreator.Create(); Document document2 = DocumentCreator.Create(); Document document3 = DocumentCreator.Create(); User userToUpdate = UserCreator.Create(documents: new [] { document1, document2 }); UploadedFile uploadedFile = new UploadedFile(new FileInfo("C:\\Temp\\passbild.png")); Mock <IDocumentRepository> fileServiceMock = new Mock <IDocumentRepository>(); fileServiceMock.Setup(s => s.Create(uploadedFile)).Returns(document3); userService.DocumentRepository = fileServiceMock.Object; // when: // UserLoginDto userLoginDto = UserUtil.CreateUserLoginDto("neuernutzer", "anderesPasswort", false); UserContactDto userContactDto = new UserContactDto("*****@*****.**", "Straße", "1", "01234", "Stadt", Country.DE, "Unternehmen", "http://www.test.url", "phone", "privat", "mobile"); const string NEW_USERNAME = "******"; const string NEW_PASSWORDHASH = "andererPasswortHash"; UserDataDto userDataDto = new UserDataDto("neuerVorname", "neuerNachname", new DateTime(2000, 02, 02), NEW_USERNAME); UserPaymentDto userPaymentDto = new UserPaymentDto("PayPal", true); UserPermissionDto userPermissionDto = UserCreator.CreateUserPermissionDto(new List <string>() { Roles.Administrator }, false); EntityChangedDto changeDto = new EntityChangedDto(UserCreator.Create(), new DateTime(2017, 01, 01, 01, 02, 03)); UserNotificationOptionsDto userNotificationsDto = UserNotificationOptionsDto.AllOff; userService.Update(userToUpdate, NEW_PASSWORDHASH, userContactDto, userDataDto, userPaymentDto, userNotificationsDto, userPermissionDto, new List <UploadedFile>() { uploadedFile }, new List <Document> { document2 }, changeDto); userService.UserDao.FlushAndClear(); User actualUser = UserService.GetById(userToUpdate.Id); // then: Assert.AreEqual(NEW_USERNAME, actualUser.UserName, "Der Nutzername wurde nicht korrekt übernommen."); Assert.AreEqual(NEW_PASSWORDHASH, actualUser.PasswordHash, "Das Passwort wurde nicht korrekt übernommen."); DtoAssert.AreEqual(userContactDto, actualUser.GetUserContactDto()); DtoAssert.AreEqual(userDataDto, actualUser.GetUserDataDto()); DtoAssert.AreEqual(userNotificationsDto, actualUser.GetNotificationOptions()); DtoAssert.AreEqual(userPermissionDto, actualUser.GetUserPermissionDto()); actualUser.Documents.Should().BeEquivalentTo(document1, document3); actualUser.ChangedBy.Should().Be(changeDto.ChangedBy); actualUser.ChangedAt.Should().Be(changeDto.ChangedAt); }
public virtual void Update(PeanutParticipationDto peanutParticipationDto, EntityChangedDto entityChangedDto) { Update(peanutParticipationDto); Update(entityChangedDto); }