public void CriarVenda(Venda venda)
{
venda.Validar();
venda.ItensVenda.ForEach(x => x.Validar());
AssertionConcern.AssertArgumentEquals(venda.StatusVenda, StatusVendaEnum.Aberto, Erros.StatusOfDifferentSalesOpen);
AplicaValidacoesPadrao(venda);
var usuario = _usuarioRepository.ObterPorCodigo(venda.Usuario.UsuarioCodigo);
venda.Usuario = usuario;
venda.Cliente = null;
venda.FormaPagamento = null;
venda.CondicaoPagamento = null;
_vendaRepository.Criar(venda);
}
public void UnassignUser(User user)
{
AssertionConcern.AssertArgumentNotNull(user, "User must not be null.");
AssertionConcern.AssertArgumentEquals(this.TenantId, user.TenantId, "Wrong tenant for this user.");
this.internalGroup.RemoveUser(user);
DomainEventPublisher
.Instance
.Publish(new UserUnassignedFromRole(
this.TenantId,
this.Name,
user.Username));
}
public void CriarCompra(Compra compra)
{
compra.Validar();
compra.ItensCompra.ForEach(x => x.Validar());
AssertionConcern.AssertArgumentEquals(compra.StatusCompra, StatusCompraEnum.Aberto, Erros.StatusOfDifferentPurchasingOpen);
AplicaValidacoesPadrao(compra);
var usuario = _usuarioRepository.ObterPorCodigo(compra.Usuario.UsuarioCodigo);
compra.Usuario = usuario;
compra.Fornecedor = null;
compra.FormaPagamento = null;
compra.CondicaoPagamento = null;
_compraRepository.Criar(compra);
}
public void AssignGroup(Group group, GroupMemberService groupMemberService)
{
AssertionConcern.AssertStateTrue(this.SupportsNesting, "This role does not support group nesting.");
AssertionConcern.AssertArgumentNotNull(group, "Group must not be null.");
AssertionConcern.AssertArgumentEquals(this.TenantId, group.TenantId, "Wrong tenant for this group.");
this.internalGroup.AddGroup(group, groupMemberService);
DomainEventPublisher
.Instance
.Publish(new GroupAssignedToRole(
this.TenantId,
this.Name,
group.Name));
}
public void UnassignGroup(Group group)
{
AssertionConcern.AssertStateTrue(SupportsNesting, "This role does not support group nesting.");
AssertionConcern.AssertArgumentNotNull(group, "Group must not be null.");
AssertionConcern.AssertArgumentEquals(TenantId, group.TenantId, "Wrong tenant for this group.");
_internalGroup.RemoveGroup(group);
DomainEventPublisher
.Instance
.Publish(new GroupUnassignedFromRole(
TenantId,
Name,
group.Name));
}
public void ChangePassword(string currentPassword, string changedPassword)
{
AssertionConcern.AssertArgumentNotEmpty(
currentPassword,
"Current and new password must be provided.");
AssertionConcern.AssertArgumentEquals(
this.Password,
this.AsEncryptedValue(currentPassword),
"Current password not confirmed.");
this.ProtectPassword(currentPassword, changedPassword);
DomainEventPublisher.Instance.Publish(new UserPasswordChanged(this.TenantId, this.Username));
}
public void PlannedProductBacklogItem(BacklogItem backlogItem)
{
AssertionConcern.AssertArgumentEquals(this.TenantId, backlogItem.TenantId, "The product and backlog item must have same tenant.");
AssertionConcern.AssertArgumentEquals(this.ProductId, backlogItem.ProductId, "The backlog item must belong to product.");
int ordering = this.backlogItems.Count + 1;
ProductBacklogItem productBacklogItem =
new ProductBacklogItem(
this.TenantId,
this.ProductId,
backlogItem.BacklogItemId,
ordering);
this.backlogItems.Add(productBacklogItem);
}
public void RemoveUser(User user)
{
AssertionConcern.AssertArgumentNotNull(user, "User must not be null.");
AssertionConcern.AssertArgumentEquals(this.TenantId, user.TenantId, "Wrong tenant for this group.");
// not a nested remove, only direct member
if (this.GroupMembers.Remove(user.ToGroupMember()) && (!this.IsInternalGroup))
{
DomainEventPublisher
.Instance
.Publish(new GroupUserRemoved(
this.TenantId,
this.Name,
user.Username));
}
}
public void AddUser(User user)
{
AssertionConcern.AssertArgumentNotNull(user, "User must not be null.");
AssertionConcern.AssertArgumentEquals(this.TenantId, user.TenantId, "Wrong tenant for this group.");
AssertionConcern.AssertArgumentTrue(user.IsEnabled, "User is not enabled.");
if (this.GroupMembers.Add(user.ToGroupMember()) && (!this.IsInternalGroup))
{
DomainEventPublisher
.Instance
.Publish(new GroupUserAdded(
this.TenantId,
this.Name,
user.Username));
}
}
public void AddGroup(Group group, GroupMemberService groupMemberService)
{
AssertionConcern.AssertArgumentNotNull(group, "Group must not be null.");
AssertionConcern.AssertArgumentEquals(this.TenantId, group.TenantId, "Wrong tenant for this group.");
AssertionConcern.AssertArgumentFalse(groupMemberService.IsMemberGroup(group, this.ToGroupMember()), "Group recurrsion.");
if (this.GroupMembers.Add(group.ToGroupMember()) && (!this.IsInternalGroup))
{
DomainEventPublisher
.Instance
.Publish(new GroupGroupAdded(
this.TenantId,
this.Name,
group.Name));
}
}
public void RemoveGroup(Group group)
{
AssertionConcern.AssertArgumentNotNull(group, "Group must not be null.");
AssertionConcern.AssertArgumentEquals(this.TenantId, group.TenantId, "Wrong tenant for this group.");
// not a nested remove, only direct member
if (this.GroupMembers.Remove(group.ToGroupMember()) && !this.IsInternalGroup)
{
DomainEventPublisher
.Instance
.Publish(new GroupGroupRemoved(
this.TenantId,
this.Name,
group.Name));
}
}
public void AssignUser(User user)
{
AssertionConcern.AssertArgumentNotNull(user, "User must not be null.");
AssertionConcern.AssertArgumentEquals(TenantId, user.TenantId, "Wrong tenant for this user.");
_internalGroup.AddUser(user);
DomainEventPublisher
.Instance
.Publish(new UserAssignedToRole(
TenantId,
Name,
user.Username,
user.Person.Name.FirstName,
user.Person.Name.LastName,
user.Person.EmailAddress.Address));
}
/// <summary>
/// Uses a <see cref="GroupMemberService"/> to determine
/// whether a given <see cref="User"/> is a member of this
/// or of a nested <see cref="Group"/>.
/// </summary>
/// <param name="user">
/// A <see cref="User"/> entity to check.
/// </param>
/// <param name="groupMemberService">
/// The instance of <see cref="GroupMemberService"/>
/// to use for checking nested group membership.
/// </param>
/// <returns>
/// <c>true</c> if the given <paramref name="user"/>
/// is a member of this group or of a nested group;
/// otherwise, <c>false</c>.
/// </returns>
public bool IsMember(User user, GroupMemberService groupMemberService)
{
AssertionConcern.AssertArgumentNotNull(user, "User must not be null.");
AssertionConcern.AssertArgumentEquals(this.TenantId, user.TenantId, "Wrong tenant for this group.");
AssertionConcern.AssertArgumentTrue(user.IsEnabled, "User is not enabled.");
bool isMember = this.GroupMembers.Contains(user.ToGroupMember());
if (isMember)
{
isMember = groupMemberService.ConfirmUser(this, user);
}
else
{
isMember = groupMemberService.IsUserInNestedGroup(this, user);
}
return(isMember);
}
public void ScheduleFor(Release release)
{
AssertionConcern.AssertArgumentNotNull(release, "Release must not be null.");
AssertionConcern.AssertArgumentEquals(TenantId, release.TenantId, "Release must be of same tenant.");
AssertionConcern.AssertArgumentEquals(ProductId, release.ProductId, "Release must be of same product.");
if (IsScheduledForRelease && !ReleaseId.Equals(release.ReleaseId))
{
UnscheduleFromRelease();
}
if (Status == BacklogItemStatus.Planned)
{
Status = BacklogItemStatus.Scheduled;
}
ReleaseId = release.ReleaseId;
DomainEventPublisher.Instance.Publish(
new BacklogItemScheduled(TenantId, BacklogItemId, release.ReleaseId));
}
public void Validate()
{
AssertionConcern.AssertArgumentNotEmpty(Name, "O campo Nome da categoria não pode estar vazio");
AssertionConcern.AssertArgumentEquals(Code, 0, "O campo Codigo não pode ser 0");
}
void AssertValidTeamMember(TeamMember teamMember)
{
AssertionConcern.AssertArgumentNotNull(teamMember, "A team member must be provided.");
AssertionConcern.AssertArgumentEquals(this.TenantId, teamMember.TenantId, "Team member must be of the same tenant.");
}
public void Should_ThrowsAssertArgumentEquals()
{
var testValue = "DDDValidation Rocks!!";
AssertionConcern.AssertArgumentEquals(testValue, ExpectedString, ErrorMessage);
}
protected void SelfAssertArgumentEquals(object object1, object object2, string message)
{
AssertionConcern.AssertArgumentEquals(object1, object2, message);
}
public void Should_AssertArgumentEquals()
{
var testValue = "DDDValidation Rocks!";
Assert.DoesNotThrow(() => AssertionConcern.AssertArgumentEquals(testValue, ExpectedString, ErrorMessage));
}
