Come rendere questo disegno più vicino al DDD corretto?

Questa domanda è in qualche modo soggettiva e conduce a una discussione più che a una risposta diretta, che, come qualcuno ha sottolineato, non è appropriata per il formato stackoverflow. Detto questo, penso che tu abbia solo bisogno di alcuni esempi codificati su come affrontare i problemi, quindi ti darò una possibilità, solo per darti qualche idea.

La prima cosa che direi è:

"domain objects are not allowed to show methods to the application layer"

Questo semplicemente non è vero - sarei interessato a sapere da dove hai letto questo. Il livello dell'applicazione è l'orchestratore tra interfaccia utente, infrastruttura e amp; Dominio, e quindi ovviamente ha bisogno di invocare metodi su entità di dominio.

Ho scritto un esempio in codice su come affrontare il tuo problema. Mi scuso per il fatto che sia in C #, ma non conosco il PHP - si spera che otterrete comunque il succo da una prospettiva di struttura.

Forse non avrei dovuto farlo, ma ho leggermente modificato i tuoi oggetti di dominio. Non ho potuto fare a meno di sentire che era leggermente imperfetto, in quanto nel sistema esiste il concetto di "Utente Bannato", anche se il divieto è scaduto.

Per cominciare, ecco il servizio applicativo - questo è ciò che l'interfaccia utente chiamerebbe:

public class ModeratorApplicationService
{
    private IUserRepository _userRepository;
    private IModeratorRepository _moderatorRepository;

    public void BanUser(Guid moderatorId, Guid userToBeBannedId)
    {
        Moderator moderator = _moderatorRepository.GetById(moderatorId);
        User userToBeBanned = _userRepository.GetById(userToBeBannedId);

        using (IUnitOfWork unitOfWork = UnitOfWorkFactory.Create())
        {
            userToBeBanned.Ban(moderator);

            _userRepository.Save(userToBeBanned);
            _moderatorRepository.Save(moderator);
        }
    }
}

Piuttosto semplice. Recuperi il moderatore che fa il divieto, l'utente che il moderatore vuole vietare e chiama il metodo "Ban" sull'utente, passando il moderatore. Questo modificherà lo stato sia del moderatore che dell'amplificatore; utente (spiegato di seguito), che necessita quindi di persistere tramite i repository corrispondenti.

La classe utente:

public class User : IUser
{
    private readonly Guid _userId;
    private readonly string _userName;
    private readonly List<ServingBan> _servingBans = new List<ServingBan>();

    public Guid UserId
    {
        get { return _userId; }
    }

    public string Username
    {
        get { return _userName; }
    }

    public void Ban(Moderator bannedByModerator)
    {
        IssuedBan issuedBan = bannedByModerator.IssueBan(this);

        _servingBans.Add(new ServingBan(bannedByModerator.UserId, issuedBan.BanDate, issuedBan.BanExpiry));
    }

    public bool IsBanned()
    {
        return (_servingBans.FindAll(CurrentBans).Count > 0);
    }

    public User(Guid userId, string userName)
    {
        _userId = userId;
        _userName = userName;
    }

    private bool CurrentBans(ServingBan ban)
    {
        return (ban.BanExpiry > DateTime.Now);
    }

}

public class ServingBan
{
    private readonly DateTime _banDate;
    private readonly DateTime _banExpiry;
    private readonly Guid _bannedByModeratorId;

    public DateTime BanDate
    {
        get { return _banDate;}
    }

    public DateTime BanExpiry
    {
        get { return _banExpiry; }
    }

    public ServingBan(Guid bannedByModeratorId, DateTime banDate, DateTime banExpiry)
    {
        _bannedByModeratorId = bannedByModeratorId;
        _banDate = banDate;
        _banExpiry = banExpiry;
    }
}

L'invariante per un utente è che non possono eseguire determinate azioni quando sono bannati, quindi dobbiamo essere in grado di identificare se un utente è attualmente bannato. Per raggiungere questo obiettivo l'utente mantiene un elenco di divieti di pubblicazione che sono stati emessi dai moderatori. Il metodo IsBanned () verifica la scadenza di eventuali divieti di pubblicazione. Quando viene chiamato il metodo Ban (), riceve un moderatore come parametro. Ciò richiede quindi al moderatore di emettere un divieto:

public class Moderator : User
{
    private readonly List<IssuedBan> _issuedbans = new List<IssuedBan>();

    public bool CanBan()
    {
        return (_issuedbans.FindAll(BansWithTodaysDate).Count < 3);
    }

    public IssuedBan IssueBan(User user)
    {
        if (!CanBan())
            throw new InvalidOperationException("Ban limit for today has been exceeded");

        IssuedBan issuedBan = new IssuedBan(user.UserId, DateTime.Now, DateTime.Now.AddDays(7));

        _issuedbans.Add(issuedBan); 

        return issuedBan;
    }

    private bool BansWithTodaysDate(IssuedBan ban)
    {
        return (ban.BanDate.Date == DateTime.Today.Date);
    }
}

public class IssuedBan
{
    private readonly Guid _bannedUserId;
    private readonly DateTime _banDate;
    private readonly DateTime _banExpiry;

    public DateTime BanDate { get { return _banDate;}}

    public DateTime BanExpiry { get { return _banExpiry;}}

    public IssuedBan(Guid bannedUserId, DateTime banDate, DateTime banExpiry)
    {
        _bannedUserId = bannedUserId;
        _banDate = banDate;
        _banExpiry = banExpiry;
    }
}

L'invariante per il moderatore è che può emettere solo 3 divieti al giorno. Pertanto, quando viene chiamato il metodo IssueBan, controlla che il moderatore non abbia 3 divieti emessi con la data odierna nella sua lista di divieti emessi. Quindi aggiunge il divieto appena emesso alla sua lista e lo restituisce.

Soggettivo, e sono sicuro che qualcuno non sarà d'accordo con l'approccio, ma si spera che ti dia un'idea o come possa combaciare.

Sposta tutta la tua logica che altera lo stato a un livello di servizio (es: ModeratorService) che conosce sia le Entità che i Repository.

ModeratorService.BanUser(User, UserBanRepository, etc.)
{
    // handle ban logic in the ModeratorService
    // update User object
    // update repository
}