private void SetUserData(UserDataDto result)
{
FirstName.Text = result.FirstName;
LastName.Text = result.LastName;
PhoneNumber.Text = result.PhoneNumber;
Username.Text = result.Username;
}
/// <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();
}
/// <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>
/// Update existing row/rows by UserId
/// </summary>
/// <param name="userData">UserDataDto model with needed userId</param>
/// <returns>Returns task</returns>
public async Task <IEnumerable <UserDataDto> > UpdateUserDataByUserId(UserDataDto userData)
{
IEnumerable <UserData> userDataList = new List <UserData>();
if (userData.UserId != 0)
{
userDataList = await this.db.UserData
.Where(u => u.User.Id.Equals(userData.UserId))
.ToListAsync();
}
foreach (var row in userDataList)
{
row.UserText = userData.UserText;
}
await this.db.SaveChangesAsync();
ICollection <UserDataDto> updatedUserDataList = new List <UserDataDto>();
foreach (var row in userDataList)
{
updatedUserDataList.Add(this.autoMapper.Map <UserDataDto>(row));
}
return(updatedUserDataList);
}
/// <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 TestUserDataDto()
{
UserDataDto userDataDto = new UserDataDto(null, null, null, null);
UserDataDto otherUserDataDto = new UserDataDto("Vorname", "Nachname", new DateTime(2000, 01, 01), "UserName");
DtoAssert.TestEqualsAndGetHashCode(userDataDto, otherUserDataDto);
}
public override Task OnConnected()
{
_log.Debug("OnConnected: " + Context.ConnectionId);
Interlocked.Increment(ref _usersCount);
var user = new UserDataDto()
{
ConnectionId = Context.ConnectionId,
ClientId = Context.QueryString["clientId"],
GroupName = Context.QueryString["groupName"],
Token = Context.QueryString["access_token"],
RefreshId = Context.QueryString["refresh_token"],
MachineId = Context.QueryString["machineId"],
SystemName = Context.QueryString["systemName"],
ConnectedAt = DateTime.Now
};
_log.Debug("clientId: " + Context.QueryString["clientId"]);
_log.Debug("groupName: " + Context.QueryString["groupName"]);
_log.Debug("systemName: " + Context.QueryString["systemName"]);
_log.Debug("machineId: " + Context.QueryString["machineId"]);
_users[Context.ConnectionId] = user;
_log.Debug("AddGroup: AddGroup");
AddGroup(Context.ConnectionId, Context.QueryString["systemName"], Context.QueryString["groupName"], Context.QueryString["machineId"]);
return(base.OnConnected());
}
/// <summary>
/// Aktualisiert den Benutzernamen
/// </summary>
/// <param name="userDataDto"></param>
private void Update(UserDataDto userDataDto)
{
_firstName = userDataDto.FirstName;
_lastName = userDataDto.LastName;
_birthday = userDataDto.Birthday;
_userName = userDataDto.UserName;
}
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 HandleEvent(IntegrationEvent @event)
{
var e = @event as IdentityUserAddedEvent;
var dto = new UserDataDto {
Username = e.Username, Secret = e.UserSecret
};
var status = await((UserdataService)_userDataService).CreateNewUser(dto);
}
public async Task <UserDataDto> Upsert([FromBody] UserDataDto userDataDto, CancellationToken cancellationToken)
{
_logger.LogDebug($"Upserting user's data {userDataDto.UserId}");
var result =
await _service.UpsertUserDataAsync(_mapper.Map <UserData>(userDataDto), cancellationToken);
return(_mapper.Map <UserDataDto>(result));
}
public async Task CorporationDeleteByKey()
{
var accrepo = AccountRepo;
var skey = await accrepo.RegisterUser("*****@*****.**", "123");
var userid = await accrepo.CheckSession(skey);
var repo = new CorporationRepo(AccountContextProvider, Logger, null);
var keyRepo = new KeyInfoRepo(Logger, AccountContextProvider);
var keyid1 = await keyRepo.AddKey(userid, 1, "");
var keyid2 = await keyRepo.AddKey(userid, 2, "");
var keyid3 = await keyRepo.AddKey(userid, 3, "");
// stage 1
var userData = new UserDataDto()
{
Pilots = new List <Pilot>(),
Corporations = new Corporation[]
{
new Corporation()
{
EveId = 1, Name = "Corpo1", KeyInfoId = keyid1
},
new Corporation()
{
EveId = 2, Name = "Corpo2", KeyInfoId = keyid2
},
new Corporation()
{
EveId = 3, Name = "Corpo3", KeyInfoId = keyid3
}
}.ToList(),
Jobs = new List <Job>(),
};
await repo.Update(userid, userData);
var corporations = await repo.GetAll(userid);
Assert.AreEqual(3, corporations.Count);
await repo.DeleteByKey(keyid2);
corporations = await repo.GetAll(userid);
Assert.AreEqual(2, corporations.Count);
Assert.IsTrue(corporations.Any(x => x.Name == "Corpo1"));
Assert.IsTrue(corporations.Any(x => x.Name == "Corpo3"));
await repo.DeleteByKey(keyid3);
corporations = await repo.GetAll(userid);
Assert.AreEqual(1, corporations.Count);
Assert.IsTrue(corporations.Any(x => x.Name == "Corpo1"));
}
public async Task SetMethods()
{
var accrepo = AccountRepo;
var skey = await accrepo.RegisterUser("*****@*****.**", "123");
var userid = await accrepo.CheckSession(skey);
var notificationRepo = new NotificationRepo(AccountContextProvider, Logger);
var skillRepo = new SkillRepo(AccountContextProvider, Logger, notificationRepo);
var repo = new PilotRepo(AccountContextProvider, Logger, null);
// stage 1
var userData = new UserDataDto()
{
Pilots = new Pilot[]
{
new Pilot()
{
Name = "Pilot1",
Skills = new List <Skill>(),
EveId = 1,
KeyInfoId = 10,
},
new Pilot()
{
EveId = 2,
Name = "Pilot2",
Skills = new List <Skill>(),
KeyInfoId = 11
}
}.ToList(),
Corporations = new List <Corporation>(),
Jobs = new List <Job>(),
};
await repo.Update(userid, userData);
Assert.AreNotEqual(0, userData.Pilots[0].PilotId);
await repo.SetFreeManufacturingJobsNofificationCount(userData.Pilots[0].PilotId, 10);
await repo.SetFreeResearchJobsNofificationCount(userData.Pilots[1].PilotId, 20);
var pilots = await repo.GetAll(userid);
Assert.AreEqual(2, pilots.Count);
var p1 = pilots.FirstOrDefault(x => x.PilotId == userData.Pilots[0].PilotId);
var p2 = pilots.FirstOrDefault(x => x.PilotId == userData.Pilots[1].PilotId);
Assert.IsNotNull(p1);
Assert.IsNotNull(p2);
Assert.AreEqual(10, p1.FreeManufacturingJobsNofificationCount);
Assert.AreEqual(0, p1.FreeResearchJobsNofificationCount);
Assert.AreEqual(20, p2.FreeResearchJobsNofificationCount);
Assert.AreEqual(0, p2.FreeManufacturingJobsNofificationCount);
}
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 async Task HandleEvent(IntegrationEvent @event)
{
var e = @event as IdentityUserAddedEvent;
_logger.LogDebug("Handling RabbitMQ subscription for user {0} and secret {1}", e.Username, e.UserSecret);
var dto = new UserDataDto {
Username = e.Username, Secret = e.UserSecret
};
var status = await((UserDataService)_userDataService).AddNewUser(dto);
}
/// <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();
}
public static UserData To(UserDataDto dto)
{
return(new UserData
{
Id = dto.Id,
Address1 = dto.Address1,
Address2 = dto.Address2,
Image = dto.Image,
User = dto.User != null?UserDtoMapper.To(dto.User) : null,
});
}
public async Task <IActionResult> UpdateUserInfoByUserId([FromBody] UserDataDto userData)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var updatedTextData = await this._userService.UpdateUserDataByUserId(userData);
return(this.Ok(updatedTextData));
}
public async Task <IActionResult> PostUserInfo([FromBody] UserDataDto userDataDto)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var addedUserData = await this._userService.AddUserData(userDataDto);
return(this.Ok(addedUserData));
}
/// <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>
/// Add new row to UserData table
/// </summary>
/// <param name="userDataDto">UserDataDto model</param>
/// <returns>Returns task</returns>
public async Task <UserDataDto> AddUserData(UserDataDto userDataDto)
{
this.db.UserData.Add(this.autoMapper.Map <UserData>(userDataDto));
await this.db.SaveChangesAsync();
var addedUserData = this.db.UserData
.Include(user => user.User)
.Where(userData => userData.UserText.Equals(userDataDto.UserText)).FirstOrDefault();
return(this.autoMapper.Map <UserDataDto>(addedUserData));
}
public IActionResult Post(UserDataDto userData)
{
var user = _mapper.Map <AppUser>(userData);
var customer = _mapper.Map <Customer>(userData);
var result = _userService.UpdateUser(user, customer);
if (!result.IsSuccess)
{
return(BadRequest(result));
}
return(Ok(result));
}
public IActionResult UpdateUser(UserDataDto dto)
{
string resp = _userservice.UpdateUserData(dto);
if (resp.Contains("successfully"))
{
return(Ok(resp));
}
else
{
return(BadRequest(resp));
}
}
public User(UserDataDto dto, IUserRepository userRepository, ISongCollection songCollection, IAlbumCollection albumCollection, IArtistCollection artistCollection)
{
Id = dto.Id;
Username = dto.Username;
_password = dto.Password;
_apiToken = dto.ApiToken;
_userRepository = userRepository;
_songCollection = songCollection;
_albumCollection = albumCollection;
_artistCollection = artistCollection;
}
public void Create(UserDataDto model)
{
var isExisting = this.UserDataRepository.FindBy(ue => ue.Id == model.Id).Any();
if (!isExisting)
{
this.UserDataRepository.Add(this._mapper.Map <UserDataEntity>(model));
this.UserDataRepository.Save();
}
else
{
throw new Exception("User Data already exists");
}
}
private UserDataDto FindUserDataByGroupName(string groupName)
{
UserDataDto userData = null;
foreach (var item in _users.Values)
{
if (item.GroupName == groupName)
{
userData = item;
break;
}
}
return(userData);
}
private UserDataDto FindUserDataByMachineId(string machineId)
{
UserDataDto userData = null;
foreach (var item in _users.Values)
{
if (item.MachineId.ToLower() == machineId)
{
userData = item;
break;
}
}
return(userData);
}
/// <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>
/// Extension method for mapping UserDataDto model to UserData
/// </summary>
/// <param name="userDataDto">Takes DTO model</param>
/// <returns>Returns entity model</returns>
public static UserData ToUserData(this UserDataDto userDataDto)
{
if (userDataDto == null)
{
return(null);
}
UserData userData = new UserData
{
UserId = userDataDto.UserId,
UserText = userDataDto.UserText
};
return(userData);
}
