private void AssertContactDataEqual(UserContactDto a, UserContactDto b)
{
Assert.Equal(a.Name, b.Name);
Assert.Equal(a.Address, b.Address);
Assert.Equal(a.DateOfBirth, b.DateOfBirth, TimeSpan.FromHours(1));
Assert.True(a.ContactNumbers.SequenceEqual(b.ContactNumbers));
}
/// <summary>
/// Erzeugt eine neue Instanz von <see cref="UserCreateCommand" />
/// </summary>
public UserCreateCommand()
{
UserContactDto = new UserContactDto();
UserDataDto = new UserDataDto();
UserPermissionDto = new UserPermissionDto();
UserPaymentDto = new UserPaymentDto();
}
public void TestUserContactDto()
{
UserContactDto userContactDto1 = new UserContactDto("*****@*****.**", "Straße-des-1.", "1", "01111", "Ort 1", Country.DE, "Unternehmen 1", "http://www.1.de", "0123/456789", "0123/4567890", "0151/123456");
UserContactDto userContactDto2 = new UserContactDto("*****@*****.**", "Straße-des-2.", "2", "02222", "Ort 2", Country.AT, "Unternehmen 2", "http://www.2.de", "0223/456789", "0223/4567890", "0251/123456");
DtoAssert.TestEqualsAndGetHashCode(userContactDto1, userContactDto2);
}
/// <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 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);
}
/// <summary>Initialisiert eine neue Instanz der <see cref="T:System.Object" />-Klasse.</summary>
public UpdateMeCommand()
{
UserContactDto = new UserContactDto();
UserDataDto = new UserDataDto();
UserPaymentDto = new UserPaymentDto();
UserNotificationOptionsDto = new UserNotificationOptionsDto();
}
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);
}
}
public ResultHelper AddUserContact(UserContactDto userContactDto)
{
try
{
if (IsThere(userContactDto))
{
return(new ResultHelper(false, 0, ResultHelper.UnSuccessMessage));
}
usercontact item = new usercontact();
item.UserID = userContactDto.UserID;
item.UserContactID = userContactDto.UserContactID;
item.UserContactTypeID = userContactDto.UserContactTypeID;
item.Contact = userContactDto.Contact;
using (UnitOfWork unitofWork = new UnitOfWork())
{
unitofWork.GetRepository <usercontact>().Insert(item);
unitofWork.saveChanges();
return(new ResultHelper(true, item.UserContactID, ResultHelper.SuccessMessage));
}
}
catch (Exception ex)
{
return(new ResultHelper(false, 0, ResultHelper.UnSuccessMessage + "\n" + ResultHelper.IsThereItem));
}
}
public ActionResult <UserContactDto> Created(UserContactDto dto)
{
var data = dataContext.Set <UserContact>().Add(new UserContact
{
FullName = dto.FullName,
PhoneNumber = dto.PhoneNumber,
Email = dto.Email,
Comment = dto.Comment
});
var builder = new ConfigurationBuilder()
.AddJsonFile("appsettings.json");
var config = builder.Build();
var smtpClient = new SmtpClient(config["Smtp:Host"])
{
Port = int.Parse(config["Smtp:Port"]),
Credentials = new NetworkCredential(config["Smtp:Username"], config["Smtp:Password"]),
EnableSsl = true,
};
var mailMessage = new MailMessage
{
From = new MailAddress("*****@*****.**"),
Subject = "New Contact Submitted",
Body = @$ "<html>
<body>
<section><b>Name:</b> {dto.FullName}</section>
public User(string passwordHash, UserContactDto userContactDto, UserDataDto userDataDto, UserPaymentDto userPaymentDto,
UserNotificationOptionsDto userNotificationOptions,
UserPermissionDto userPermissionDto, IList <Document> documents, EntityCreatedDto entityCreatedDto)
{
// TODO: Muss hier ein Passwort angegeben werden oder nicht?
// Require.NotNullOrWhiteSpace(passwordHash, "passwordHash");
Require.NotNull(userContactDto, "userContactDto");
Require.NotNull(userDataDto, "userDataDto");
Require.NotNull(userPermissionDto, "userPermissionDto");
Require.NotNull(entityCreatedDto, "entityCreatedDto");
Require.NotNull(userPaymentDto, "userPaymentDto");
Require.NotNull(documents, "documents");
Require.NotNull(userNotificationOptions, "userNotificationOptions");
_passwordHash = passwordHash;
Update(userContactDto);
Update(userDataDto);
Update(userPermissionDto);
Update(entityCreatedDto);
Update(userPaymentDto);
Update(userNotificationOptions);
Update(documents);
}
public async Task <UserContactDto> GetUserContactAsync(Guid id)
{
UserEntity user = await _userStorage.FindAsync(u => u.Id == id);
UserContactDto userContactDto = _mapper.Map <UserContactDto>(user);
return(userContactDto);
}
public ActionResult Edit(UserContactDto model)
{
ResultHelper result = JsonConvert.DeserializeObject <ResultHelper>(userContactService.SetUserContact(model));
GetUserContactType(model.UserContactTypeID);
GetUser(model.UserID);
ViewBag.Message = Helper.GetResultMessage(result.Result, result.ResultDescription);
return(View());
}
private async Task <UserContactDto> Update(int contactId, UserContactDto contactData)
{
var response = await _client.PutAsJsonAsync($"/contacts/{contactId}", contactData);
var responseJson = await response.Content.ReadAsStringAsync();
Assert.True(response.IsSuccessStatusCode);
return(JsonConvert.DeserializeObject <UserContactDto>(responseJson));
}
private async Task <UserContactDto> Create(UserContactDto contact)
{
var response = await _client.PostAsJsonAsync("/contacts", contact);
Assert.True(response.IsSuccessStatusCode);
var responseJson = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <UserContactDto>(responseJson));
}
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);
}
/// <summary>
/// Erzeugt eine neue Instanz von <see cref="UserUpdateCommand" />
/// </summary>
public UserUpdateCommand()
{
UserContactDto = new UserContactDto();
UserDataDto = new UserDataDto();
UserPermissionDto = new UserPermissionDto();
UserPaymentDto = new UserPaymentDto();
NewDocuments = new List <UploadedFile>();
DeleteDocuments = new List <Document>();
UserNotificationOptionsDto = new UserNotificationOptionsDto();
}
/// <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);
}
public async Task <UserContactDto> AddContactAsync(int userId, UserContactDto contact)
{
var entity = contact.Adapt <UserContact>();
entity.UserId = userId;
entity = await _contactsRepository.AddAsync(entity);
await _contactsRepository.SaveChangesAsync();
return(entity?.Adapt <UserContactDto>());
}
public async Task <IActionResult> Create(int userId, [FromBody] UserContactDto data)
{
if (data.Id != null)
{
return(BadRequest());
}
_logger.LogTrace("Creating a new contact {ContactName} for {UserId}", data.Name, userId);
var contact = await _userContactsService.AddContactAsync(UserId, data);
_logger.LogTrace("Contact {ContactId} created for {UserId}", contact.Id, userId);
return(Ok(contact));
}
/// <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);
}
/// <summary>
/// Aktualisiert die Kontaktdaten des Nutzers
/// </summary>
/// <param name="userContactDto"></param>
private void Update(UserContactDto userContactDto)
{
_email = userContactDto.Email;
_city = userContactDto.City;
_company = userContactDto.Company;
_country = userContactDto.Country;
_postalCode = userContactDto.PostalCode;
_street = userContactDto.Street;
_streetNumber = userContactDto.StreetNumber;
_url = userContactDto.Url;
_phone = userContactDto.Phone;
_phonePrivate = userContactDto.PhonePrivate;
_mobile = userContactDto.Mobile;
}
public bool IsThere(UserContactDto userContactDto)
{
using (UnitOfWork unitofWork = new UnitOfWork())
{
var item = unitofWork.GetRepository <usercontact>().GetById(x => x.Contact == userContactDto.Contact && x.UserID == userContactDto.UserID && x.UserContactTypeID == userContactDto.UserContactTypeID);
if (item != null)
{
return(true);
}
else
{
return(false);
}
}
}
public override User Build()
{
EntityCreatedDto entityCreatedDto = new EntityCreatedDto(_createdBy, _createdAt);
UserContactDto userContactDto = new UserContactDto(_email, _street, _streetNumber, _postalCode, _city, _country, _company, _url, _phone, _privatePhone, _mobile);
UserDataDto userDataDto = new UserDataDto(_firstname, _lastname, _birthday, _username);
UserPaymentDto userPaymentDto = new UserPaymentDto();
UserNotificationOptionsDto notificationOptions = UserNotificationOptionsDto.AllOn;
UserPermissionDto userPermissionDto = new UserPermissionDto(_roles, _isEnabled);
User user = new User(_passwordHash, userContactDto, userDataDto, userPaymentDto, notificationOptions, userPermissionDto, _documents, entityCreatedDto);
_userDao.Save(user);
_userDao.Flush();
return(user);
}
public UserContactDto CreateUserContactDto(string email, string street, string streetNumber, string postalCode, string city,
Country countryTwoLetterIsoCode, string company, string url, string phone, string phonePrivate, string mobile)
{
UserContactDto userContactDto = new UserContactDto(email,
street,
streetNumber,
postalCode,
city,
countryTwoLetterIsoCode,
company,
url,
phone,
phonePrivate,
mobile);
return(userContactDto);
}
public async Task <IActionResult> Update(int userId, int contactId, [FromBody] UserContactDto data)
{
if (data.Id != null)
{
return(BadRequest());
}
_logger.LogTrace("Replacing contact {ContactId} for user {UserId}, data : {Data}", userId, contactId, data);
var contact = await _userContactsService.UpdateContactAsync(UserId, contactId, data);
if (contact == null)
{
_logger.LogDebug("Contact {ContactId} for user {UserId} not found", userId, contactId);
return(NotFound());
}
return(Ok(contact));
}
/// <summary>
/// Überprüft, ob es Änderungen am Nutzer gab.
/// </summary>
/// <param name="user">Der Nutzer in seiner ungeänderten Form.</param>
/// <param name="passwordHash">Der neue PasswordHash</param>
/// <param name="userContactDto">Die neuen Kontaktdaten</param>
/// <param name="userDataDto">Die neuen Nutzerdaten</param>
/// <param name="userPaymentDto">Die neuen Zahlungsinformationen</param>
/// <param name="userPermissionDto">Die neuen Berechtigungsinformationen</param>
/// <param name="userDocuments"></param>
/// <returns></returns>
/// <remarks>
/// Wenn ein Dto oder eine Eigenschaft sowieso nicht geändert werden soll, dann den Wert nutzen, der am Nutzer
/// hinterlegt ist.
/// </remarks>
private bool IsDirty(User user, string passwordHash, UserContactDto userContactDto, UserDataDto userDataDto,
UserPaymentDto userPaymentDto, UserNotificationOptionsDto userNotificationOptionsDto,
UserPermissionDto userPermissionDto, IList <Document> userDocuments)
{
Require.NotNull(user, "user");
Require.NotNull(userContactDto, "userContactDto");
Require.NotNull(userDataDto, "userDataDto");
Require.NotNull(userPermissionDto, "userPermissionDto");
Require.NotNull(userPaymentDto, "userPaymentDto");
Require.NotNull(userNotificationOptionsDto, "userNotificationOptionsDto");
if (user.PasswordHash != passwordHash)
{
return(true);
}
if (!Equals(user.GetUserContactDto(), userContactDto))
{
return(true);
}
if (!Equals(user.GetUserPaymentDto(), userPaymentDto))
{
return(true);
}
if (!Equals(user.GetUserPermissionDto(), userPermissionDto))
{
return(true);
}
if (!Equals(user.GetUserDataDto(), userDataDto))
{
return(true);
}
if (!Equals(user.GetNotificationOptions(), userNotificationOptionsDto))
{
return(true);
}
if (!ListHelper.AreEquivalent(user.Documents, userDocuments))
{
return(true);
}
return(false);
}
public List <UserContactDto> GetAllUserContact()
{
try
{
List <UserContactDto> list = new List <UserContactDto>();
using (UnitOfWork unitofWork = new UnitOfWork())
{
var query = from uc in unitofWork.GetRepository <usercontact>().Select(null, null)
join us in unitofWork.GetRepository <user>().Select(null, null) on uc.UserID equals us.UserID
join ut in unitofWork.GetRepository <usercontacttype>().Select(null, null) on uc.UserContactTypeID equals ut.UserContactTypeID
select new
{
UserID = us.UserID,
UserContactTypeID = ut.UserContactTypeID,
UserContactTypeName = ut.TypeName,
UserName = us.Name,
UserSurName = us.SurName,
ContactName = uc.Contact,
ContactID = uc.UserContactID,
};
foreach (var item in query)
{
UserContactDto uc = new UserContactDto();
uc.UserContactID = item.ContactID;
uc.Contact = item.ContactName;
uc.UserDto = new UserDto();
uc.UserDto.UserID = item.UserID;
uc.UserDto.Name = item.UserName;
uc.UserDto.SurName = item.UserSurName;
uc.UserContactTypeDto = new UserContactTypeDto();
uc.UserContactTypeDto.UserContactTypeID = item.UserContactTypeID;
uc.UserContactTypeDto.TypeName = item.UserContactTypeName;
list.Add(uc);
}
return(list);
}
}
catch (Exception ex)
{
return(new List <UserContactDto>());
}
}
public User Create(string passwordHash, UserContactDto userContactDto, UserDataDto userDataDto, UserPaymentDto userPaymentDto,
UserPermissionDto userPermissionDto, EntityCreatedDto entityCreatedDto)
{
Require.NotNull(userContactDto);
Require.NotNull(userDataDto);
Require.NotNull(entityCreatedDto, "entityCreatedDto");
User user = new User(passwordHash,
userContactDto,
userDataDto,
userPaymentDto,
/*Standardmäßig alle Benachrichtigungen an*/
UserNotificationOptionsDto.AllOn,
userPermissionDto,
new List <Document>(),
entityCreatedDto);
return(UserDao.Save(user));
}
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 async Task GetUserContct_CallWithMockedIProjectUser_ReturnOkObjectResult()
{
// Arrange
var mock = new Mock <IUser>();
var id = Guid.NewGuid();
var userContact = new UserContactDto()
{
Email = "*****@*****.**",
};
mock.Setup(u => u.GetUserContactAsync(id)).ReturnsAsync(userContact);
var controller = new UsersController(mock.Object);
// Act
var result = await controller.GetUserContact(id);
var response = (OkObjectResult)result;
// Assert
Assert.IsType <OkObjectResult>(result);
Assert.IsType <ResponseDto <UserContactDto> >(response.Value);
}
