SharedKernel

SharedKernel/
├── SeedWork/      → EntityBase, Entity, ValueObject, Enumeration, DomainEvent,
│                    IAggregateRoot, IRepository, IUnitOfWork, IAuditableEntity...
├── ValueObjects/  → FullName, Email, Phone, OtpCode, TCKimlikNo, TotpSecret...
├── Enumerations/  → OtpType, AuthProviderType, City...
└── Utils/         → Check, GuidFactory, MobilePhoneUtility...

public abstract class EntityBase<TId> : EntityBase, IEntityBase<TId>, IAuditableEntity, ISoftDeletable
{
    public virtual TId Id { get; protected set; }

    // IAuditableEntity — interceptor doldurur
    public virtual DateTime? CreatedAt { get; protected set; }
    public virtual DateTime? UpdatedAt { get; protected set; }
    public virtual Guid?     CreatedBy { get; protected set; }
    public virtual Guid?     UpdatedBy { get; protected set; }

    // ISoftDeletable — interceptor doldurur
    public virtual DateTime? DeletedAt { get; protected set; }
    public virtual Guid?     DeletedBy { get; protected set; }

    public virtual bool IsDeleted()   => DeletedAt is not null;
    public virtual bool IsTransient() => Id.Equals(default(TId));
    // ... Equals / GetHashCode / == / != kimlik bazlı
}

public abstract class EntityBase : IEntityBase
{
    private List<INotification> _domainEvents;
    public IReadOnlyCollection<INotification> DomainEvents => _domainEvents?.AsReadOnly();

    public void AddDomainEvent(INotification eventItem) { /* listeye ekler */ }
    public void RemoveDomainEvent(INotification eventItem) { /* ... */ }
    public void ClearDomainEvents() { /* ... */ }
}

public abstract class Entity : EntityBase<Guid>
{
    public override bool IsTransient() => base.IsTransient() || CreatedAt == default;
}

public interface IAggregateRoot {}

public abstract class ValueObject
{
    protected abstract IEnumerable<object> GetAtomicValues();

    public override bool Equals(object obj)
    {
        if (obj == null || obj.GetType() != GetType()) return false;
        var other = (ValueObject)obj;
        // GetAtomicValues() sırayla karşılaştırılır
    }

    public override int GetHashCode()
        => GetAtomicValues().Select(x => x?.GetHashCode() ?? 0).Aggregate((x, y) => x ^ y);
}

public sealed class FullName : ValueObject
{
    public string Value { get; }
    // ... ctor validasyonu ...
    protected override IEnumerable<object> GetAtomicValues()
    {
        yield return Value;
    }
}

public abstract class DomainEvent
{
    public string Type => this.GetType().Name;
    public readonly Guid Id;
    public readonly Guid CorrelationID;
    public readonly DateTime CreatedAt;

    public DomainEvent()
    {
        Id = Guid.CreateVersion7(DateTime.UtcNow);
        CreatedAt = DateTime.UtcNow;
    }
    public DomainEvent(Guid correlationID) : this() => this.CorrelationID = correlationID;
}

public class UserCreatedDomainEvent : DomainEvent, INotification
{
    public Guid UserId { get; }
    public FullName? FullName { get; }
    // ...
}

public abstract class Enumeration : IComparable
{
    public int Id { get; private set; }
    public string Name { get; private set; }
    protected Enumeration(int id, string name) { Id = id; Name = name; }

    public static IEnumerable<T> GetAll<T>() where T : Enumeration;
    public static T FromValue<T>(int id) where T : Enumeration;      // bulunamazsa DomainException
    public static T FromName<T>(string name) where T : Enumeration;  // bulunamazsa DomainException
    public static bool InRange<T>(int value) where T : Enumeration;  // geçerli mi?
}

public class Role : Enumeration
{
    public static Role SuperAdmin = new(1, nameof(SuperAdmin));
    public static Role Admin      = new(2, nameof(Admin));
    public static Role Staff      = new(3, nameof(Staff));
    public static Role ReadOnly   = new(4, nameof(ReadOnly));
    public Role(int id, string name) : base(id, name) { }
}

public static class GuidFactory
{
    public static Guid New() => Guid.CreateVersion7(DateTime.UtcNow);
}

public class DomainException : Exception
{
    public DomainException() { }
    public DomainException(string message) : base(message) { }
    public DomainException(string message, Exception innerException) : base(message, innerException) { }
}

Check.NotNull(plan, nameof(plan));
Check.NotNullOrEmpty(providerUserId, nameof(providerUserId));
Check.HasValue(id, nameof(id));          // default(T) değilse geçer
Check.NotEmpty(collection, nameof(collection));
Check.Positive(adet, nameof(adet));

public UserOtpChallenge(User user, Guid id, OtpCode code, OtpType type, DateTime expiryDate)
{
    Check.NotNull(user, nameof(user));
    Check.HasValue(id, nameof(id));
    Check.NotNull(code, nameof(code));
    // ...
}

public interface ISoftDeletable
{
    DateTime? DeletedAt { get; }
    Guid?     DeletedBy { get; }
    bool IsDeleted();
}

public interface IRepository<T> : IRepositoryBase<T> where T : class, IAggregateRoot
{
    IUnitOfWork UnitOfWork { get; }
}

public interface IReadRepository<T> : IReadRepositoryBase<T> where T : class, IEntityBase {}

public interface IUnitOfWork : IDisposable
{
    Task<bool> SaveEntitiesAsync(CancellationToken cancellationToken = default);
}