public Payment(PaymentDto paymentDto, Account recipient, Account sender, User requestRecipient, User requestSender,
EntityCreatedDto entityCreatedDto)
{
Require.NotNull(paymentDto, "paymentDto");
Require.NotNull(recipient, "recipient");
Require.NotNull(sender, "sender");
Require.NotNull(entityCreatedDto, "entityCreatedDto");
Require.NotNull(requestRecipient, "requestRecipient");
Require.NotNull(requestSender, "requestSender");
if (!recipient.Membership.UserGroup.Equals(sender.Membership.UserGroup))
{
throw new InvalidOperationException(
$"Der Empfänger {recipient.Membership.User.DisplayName} muss in der gleichen Gruppe {sender.Membership.UserGroup.Name} wie der Sender {sender.Membership.User.DisplayName} sein. Ist aber in der Gruppe {recipient.Membership.UserGroup.Name}");
}
_amount = paymentDto.Amount;
_text = paymentDto.Text;
_paymentType = paymentDto.PaymentType;
_recipient = recipient;
_sender = sender;
_createdBy = entityCreatedDto.CreatedBy;
_createdAt = entityCreatedDto.CreatedAt;
_requestRecipient = requestRecipient;
_requestSender = requestSender;
}
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);
}
/// <summary>
/// Aktualisiert den Zeitpunkt und die Person der Erstellung dieses Nutzers.
/// </summary>
/// <param name="entityCreatedDto"></param>
private void Update(EntityCreatedDto entityCreatedDto)
{
Require.NotNull(entityCreatedDto, "entityCreatedDto");
_createdBy = entityCreatedDto.CreatedBy;
_createdAt = entityCreatedDto.CreatedAt;
}
public void TestSaveAndLoad()
{
// given:
string expectedAdditionalInformations = "Keine";
string expectedName = "die firma";
int acceptedBalance = -10;
UserGroupDto userGroupDto = new UserGroupDto(expectedAdditionalInformations, expectedName, acceptedBalance);
DateTime createdAt = new DateTime(2016, 12, 12);
User createdBy = UserCreator.Create();
EntityCreatedDto entityCreatedDto = new EntityCreatedDto(createdBy, createdAt);
UserGroup userGroup = new UserGroup(userGroupDto, entityCreatedDto);
// when:
userGroup = UserGroupDao.Save(userGroup);
UserGroupDao.FlushAndClear();
UserGroup actualBrokerPool = UserGroupDao.Get(userGroup.Id);
// then:
actualBrokerPool.GetDto().ShouldBeEquivalentTo(userGroupDto);
actualBrokerPool.AdditionalInformations.ShouldBeEquivalentTo(expectedAdditionalInformations);
actualBrokerPool.ChangedAt.Should().Be(null);
actualBrokerPool.ChangedBy.Should().BeNull();
actualBrokerPool.CreatedAt.ShouldBeEquivalentTo(createdAt);
actualBrokerPool.CreatedBy.ShouldBeEquivalentTo(createdBy);
actualBrokerPool.Name.ShouldBeEquivalentTo(expectedName);
actualBrokerPool.BalanceOverdraftLimit.ShouldBeEquivalentTo(acceptedBalance);
}
/// <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 ProposedUser(string userName, ProposedUserDataDto proposedUserDataDto, ProposedUserContactDto proposedUserContactDto,
EntityCreatedDto entityCreatedDto)
{
UpdateUsername(userName);
Update(proposedUserDataDto);
Update(proposedUserContactDto);
Update(entityCreatedDto);
}
public void OnCreated(EntityCreatedDto entityInfo)
{
if (entityInfo.Success)
{
LoadGridData();
this.Show();
}
}
public virtual void Update(string userName, ProposedUserDataDto proposedUserDataDto, ProposedUserContactDto proposedUserContactDto,
EntityCreatedDto entityCreatedDto)
{
_userName = userName;
Update(proposedUserDataDto);
Update(proposedUserContactDto);
Update(entityCreatedDto);
}
public PeanutComment(string comment, EntityCreatedDto entityCreatedDto)
{
Require.NotNull(entityCreatedDto, "entityCreatedDto");
Update(comment);
_createdBy = entityCreatedDto.CreatedBy;
_createdAt = entityCreatedDto.CreatedAt;
}
public async Task <IActionResult> PostNestedField(string app, string name, long parentId, [FromBody] AddFieldDto request)
{
var context = await CommandBus.PublishAsync(request.ToCommand(parentId));
var result = context.Result <EntityCreatedResult <long> >();
var response = EntityCreatedDto.FromResult(result);
return(StatusCode(201, response));
}
public async Task <IActionResult> PostRule(string app, [FromBody] CreateRuleDto request)
{
var context = await CommandBus.PublishAsync(request.ToCommand());
var result = context.Result <EntityCreatedResult <Guid> >();
var response = EntityCreatedDto.FromResult(result);
return(CreatedAtAction(nameof(GetRules), new { app }, response));
}
void IEntityCreator.OnCreated(EntityCreatedDto entityInfo)
{
if (entityInfo.Success)
{
var source = (BindingSource)organizationsComboBox.DataSource;
// вставляем новую организацию предпоследней перед кнопкой "Создать"
source.Insert(source.Count - 1, new KeyValuePair <int, string>(entityInfo.Id, entityInfo.DisplayValue));
}
}
/// <summary>
/// Fügt einen neuen Kommentar zum Peanut hinzu.
/// </summary>
/// <param name="updateComment"></param>
/// <param name="entityCreatedDto"></param>
/// <returns></returns>
public virtual PeanutComment AddComment(string updateComment, EntityCreatedDto entityCreatedDto)
{
PeanutComment comment = new PeanutComment(updateComment, entityCreatedDto);
_comments.Add(comment);
Update(new EntityChangedDto(entityCreatedDto.CreatedBy, entityCreatedDto.CreatedAt));
return(comment);
}
/// <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<IActionResult> PostApp([FromBody] CreateAppDto request)
{
var command = SimpleMapper.Map(request, new CreateApp());
var context = await CommandBus.PublishAsync(command);
var result = context.Result<EntityCreatedResult<Guid>>();
var response = new EntityCreatedDto { Id = result.ToString(), Version = result.Version };
return CreatedAtAction(nameof(GetApps), response);
}
public async Task <IActionResult> PostSchema(string app, [FromBody] CreateSchemaDto request)
{
var command = request.ToCommand();
var context = await CommandBus.PublishAsync(command);
var result = context.Result <EntityCreatedResult <Guid> >();
var response = new EntityCreatedDto {
Id = command.SchemaId.ToString(), Version = result.Version
};
return(CreatedAtAction(nameof(GetSchema), new { name = request.Name }, response));
}
public ProposedUser Create(string userName, ProposedUserDataDto proposedUserDataDto, ProposedUserContactDto proposedUserContactDto,
EntityCreatedDto entityCreatedDto)
{
Require.NotNullOrWhiteSpace(userName, nameof(userName));
Require.NotNull(proposedUserDataDto, nameof(proposedUserDataDto));
Require.NotNull(proposedUserContactDto, nameof(proposedUserContactDto));
Require.NotNull(entityCreatedDto, nameof(entityCreatedDto));
ProposedUser user = new ProposedUser(userName, proposedUserDataDto, proposedUserContactDto, entityCreatedDto);
return(ProposedUserDao.Save(user));
}
public UserGroup Create(string additionalInformations = null, string name = "Gruppe 1", double?balanceOverdraftLimit = -10, User createdBy = null, DateTime?createdAt = null, bool persist = true)
{
UserGroupDto userGroupDto = new UserGroupDto(additionalInformations, name, balanceOverdraftLimit);
EntityCreatedDto entityCreatedDto = GetEntityCreatedDto(createdBy, createdAt);
UserGroup userGroup = new UserGroup(userGroupDto, entityCreatedDto);
if (persist)
{
userGroup = UserGroupDao.Save(userGroup);
UserGroupDao.Flush();
}
return(userGroup);
}
public void TestDto()
{
// given:
User user = new User();
User otherUser = new User();
// when:
EntityCreatedDto entityCreatedDto = new EntityCreatedDto(user, new DateTime(2017, 1, 1));
EntityCreatedDto otherEntityCreatedDto = new EntityCreatedDto(otherUser, new DateTime(2017, 1, 11));
// then:
DtoAssert.TestEqualsAndGetHashCode(entityCreatedDto, otherEntityCreatedDto);
}
public async Task <IActionResult> PostRule(string app, [FromBody] CreateRuleDto request)
{
var command = request.ToCommand();
var context = await CommandBus.PublishAsync(command);
var result = context.Result <EntityCreatedResult <Guid> >();
var response = new EntityCreatedDto {
Id = result.IdOrValue.ToString(), Version = result.Version
};
return(CreatedAtAction(nameof(GetRules), new { app }, response));
}
public async Task <IActionResult> PostField(string app, string name, [FromBody] AddFieldDto request)
{
var command = SimpleMapper.Map(request, new AddField {
Properties = request.Properties.ToProperties()
});
var context = await CommandBus.PublishAsync(command);
var result = context.Result <EntityCreatedResult <long> >();
var response = new EntityCreatedDto {
Id = result.IdOrValue.ToString(), Version = result.Version
};
return(StatusCode(201, response));
}
public async Task <IActionResult> PostField(string app, string name, [FromBody] AddFieldDto request)
{
var command = new AddField {
Name = request.Name, Partitioning = request.Partitioning, Properties = request.Properties.ToProperties()
};
var context = await CommandBus.PublishAsync(command);
var result = context.Result <EntityCreatedResult <long> >().IdOrValue;
var response = new EntityCreatedDto {
Id = result.ToString()
};
return(StatusCode(201, response));
}
public EntityCreatedDto GetEntityCreatedDto(User createdBy, DateTime?createdAt)
{
if (createdAt == null)
{
DateTime tempDateTime = DateTime.Now;
tempDateTime = tempDateTime.AddMilliseconds(-tempDateTime.Millisecond);
createdAt = tempDateTime;
}
if (createdBy == null)
{
createdBy = UserCreator.Create();
}
EntityCreatedDto entityCreatedDto = new EntityCreatedDto(createdBy, createdAt.Value);
return(entityCreatedDto);
}
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 ProposedUser CreateProposedUser(string username = null, string email = "*****@*****.**",
string lastname = NACHNAME_CONST, Salutation salutation = Salutation.Mister, string title = null,
string firstname = VORNAME_CONST, DateTime?birthday = 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,
User createdBy = null, bool persist = true)
{
if (username == null)
{
username = GetRandomString(10);
}
if (firstname == VORNAME_CONST)
{
firstname = firstname + GetRandomString(4);
}
ProposedUserDataDto proposedUserDataDto = CreateProposedUserDataDto(firstname, lastname, salutation, title, birthday);
ProposedUserContactDto proposedUserContactDto = CreateProposedUserContactDto(email,
company,
street,
streetNumber,
postalCode,
city,
countryTwoLetterIsoCode,
url,
phone,
phonePrivate,
mobile,
fax);
if (createdBy == null)
{
createdBy = UserCreator.Create();
}
EntityCreatedDto entityCreatedDto = new EntityCreatedDto(createdBy, DateTime.Now);
ProposedUser user = Create(username,
proposedUserDataDto,
proposedUserContactDto,
entityCreatedDto,
persist);
return(user);
}
public void TestCreateAndLoadProposedUser()
{
// when:
ProposedUserContactDto updatedProposedUserContactDto = ProposedUserCreator.CreateProposedUserContactDto("*****@*****.**", "Testunternehmen", "Teststraße", "?", "01234", "Teststadt",
Country.DE, "http://www.url.test", "phone", "privat", "mobile", "fax");
ProposedUserDataDto updatedProposedUserDataDto = ProposedUserCreator.CreateProposedUserDataDto("Vorname", "Nachname", Salutation.Mister, "Titel", new DateTime(1980, 01, 02));
EntityCreatedDto creationDto = new EntityCreatedDto(UserCreator.Create(), new DateTime(2016, 12, 12, 15, 30, 0));
ProposedUser user = ProposedUserService.Create("testNutzer", updatedProposedUserDataDto, updatedProposedUserContactDto, creationDto);
ProposedUser actualUser = ProposedUserService.GetByBusinessId(user.BusinessId);
// then:
Assert.AreEqual(user, actualUser);
DtoAssert.AreEqual(updatedProposedUserDataDto, actualUser.GetUserDataDto());
DtoAssert.AreEqual(updatedProposedUserContactDto, actualUser.GetUserContactDto());
}
public override Payment Build()
{
EntityCreatedDto entityCreatedDto = new EntityCreatedDto(_createdBy, _createdAt);
PaymentDto paymentDto = new PaymentDto()
{
Amount = _amount, PaymentType = _paymentType, Text = _text
};
if (_recipientUserGroupMembership != null && _senderUserGroupMembership != null)
{
if (!_recipientUserGroupMembership.UserGroup.Equals(_senderUserGroupMembership.UserGroup))
{
throw new InvalidOperationException(
$"Der Empfänger {_recipientUserGroupMembership.User.DisplayName} muss in der gleichen Gruppe {_senderUserGroupMembership.UserGroup.Name} wie der Sender {_senderUserGroupMembership.User.DisplayName} sein");
}
}
UserGroup userGroup = Create.A.UserGroup();
if (_recipientUserGroupMembership == null)
{
_recipientUserGroupMembership = Create.A.UserGroupMembership().InUserGroup(userGroup);
}
if (_senderUserGroupMembership == null)
{
_senderUserGroupMembership = Create.A.UserGroupMembership().InUserGroup(userGroup);
}
if (_requestRecipent == null)
{
_requestRecipent = Create.A.User();
}
if (_requestSender == null)
{
_requestSender = Create.A.User();
}
return(new Payment(paymentDto,
_recipientUserGroupMembership.Account,
_senderUserGroupMembership.Account,
_requestRecipent,
_requestSender,
entityCreatedDto));
}
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 UserGroup Create(UserGroupDto userGroupDto, IDictionary <User, UserGroupMembershipType> initialUsers, User createdBy)
{
Require.NotNull(userGroupDto, nameof(userGroupDto));
Require.NotNull(createdBy, nameof(createdBy));
Require.NotNull(initialUsers, "initialUsers");
DateTime createdAt = DateTime.Now;
EntityCreatedDto entityCreatedDto = new EntityCreatedDto(createdBy, createdAt);
UserGroup userGroup = new UserGroup(userGroupDto, entityCreatedDto);
userGroup = UserGroupDao.Save(userGroup);
foreach (KeyValuePair <User, UserGroupMembershipType> userGroupMembership in initialUsers)
{
UserGroupDao.Save(new UserGroupMembership(userGroup,
userGroupMembership.Key,
userGroupMembership.Value,
new EntityCreatedDto(createdBy, DateTime.Now)));
}
return(userGroup);
}
public void TestSaveAndLoad()
{
// given :
UserGroup userGroup = UserGroupCreator.Create();
ProposedUserDataDto proposedUserDataDto = new ProposedUserDataDto("Beantragter", "Nutzer", "Prof. Dr.", Salutation.Mister, new DateTime(2000, 2, 20));
ProposedUserContactDto proposedUserContactDto = new ProposedUserContactDto("*****@*****.**", "Straße", "1", "01234", "Stadt", Country.DE, "queo", "http://www.queo.de", "0123-456789", "0123-0123456", "0151-123456");
EntityCreatedDto entityCreatedDto = new EntityCreatedDto(UserCreator.Create(), new DateTime(2017, 01, 01, 01, 01, 01));
ProposedUser user = new ProposedUser("proposedUser", proposedUserDataDto, proposedUserContactDto, entityCreatedDto);
// when:
ProposedUserDao.Save(user);
ProposedUserDao.FlushAndClear();
ProposedUser actualUser = ProposedUserDao.Get(user.Id);
// then:
Assert.AreEqual(user, actualUser);
actualUser.GetUserContactDto().Should().Be(proposedUserContactDto);
actualUser.GetUserDataDto().Should().Be(proposedUserDataDto);
actualUser.CreatedAt.Should().Be(entityCreatedDto.CreatedAt);
actualUser.CreatedBy.Should().Be(entityCreatedDto.CreatedBy);
actualUser.ChangedBy.Should().BeNull();
actualUser.ChangedAt.Should().NotHaveValue();
}
