Activities of "starting"

Hi,

I have observed that the DbUpdateConcurrencyException occurs only when the following configurations are applied in the sample code below:

The RowVersion property is defined in the entity:

csharp

public byte[] RowVersion { get; set; }

The RowVersion property is configured as a concurrency token in the OnModelCreating method:

csharp modelBuilder.Entity<Product>() .Property(p => p.RowVersion) .IsRowVersion();

In the context of using ABP framework classes, I have none of them include a RowVersion property or implement the IHasConcurrencyStamp interface. Therefore, encountering an AbpDbConcurrencyException is unexpected in this scenario.

My requirement is to update records without considering concurrent modifications by other users.

Could you please adjust my code to achieve this behavior?

Thank you.

" namespace SQL { public class Product { public int Id { get; set; } public string Name { get; set; } public decimal Price { get; set; }

    [Timestamp]
    public byte[] RowVersion { get; set; }
}

public class AppDbContext : DbContext
{
    public DbSet<Product> Products { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=ProductsDb;Trusted_Connection=True;");
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Product>()
            .Property(p => p.RowVersion)
            .IsRowVersion();
    }
}

public class Program
{
    public static void Main()
    {
        using var context = new AppDbContext();
        context.Database.EnsureDeleted();
        context.Database.EnsureCreated();

        var product = new Product { Name = "TestProduct", Price = 9.99m };
        context.Products.Add(product);
        context.SaveChanges();

        //var deleteTask = Task.Run(() => DeleteProduct(product.Id));
        //var updateTask = Task.Run(() => UpdateProductPrice(product.Id, 5.00m));

        //Task.WaitAll(deleteTask, updateTask);
        //Console.WriteLine("Nebenläufigkeitsdemo abgeschlossen. Drücken Sie eine beliebige Taste zum Beenden.");

        for (int i = 0; i < 100; i++)
        {
            Task.Run(() => UpdateProductPrice(product.Id, i*5.00m));
        }

        Console.WriteLine();
        Console.WriteLine("# Finish");
        Console.ReadKey();
    }

    private static void DeleteProduct(int productId)
    {
        using var context = new AppDbContext();
        var product = context.Products.Find(productId);
        if (product != null)
        {
            context.Products.Remove(product);
            try
            {
                context.SaveChanges();
                Console.WriteLine("Produkt gelöscht.");
            }
            catch (DbUpdateConcurrencyException)
            {
                Console.WriteLine("Nebenläufigkeitskonflikt beim Löschen des Produkts.");
            }
        }
    }

    private static void UpdateProductPrice(int productId, decimal increment)
    {
        //Thread.Sleep(100); // Verzögerung, um Überschneidung zu simulieren
        using var context = new AppDbContext();
        var product = context.Products.Find(productId);
        if (product != null)
        {
            product.Price += increment;
            try
            {
                context.SaveChanges();
                Console.WriteLine("Produktpreis aktualisiert.");
            }
            catch (DbUpdateConcurrencyException)
            {
                Console.WriteLine("Nebenläufigkeitskonflikt bei der Aktualisierung des Produktpreises.");
            }
        }
    }
}

}"

The AbpDbConcurrencyException shouldnt be thrown, it is coming from your framework.

Please give me the correct code, without throwing the exceptions (AbpDbConcurrencyException + EF Exception)

The following solution is not enough:

` public async Task

 // Überprüfe, ob das Meeting existiert
 if (meeting == null)
 {
     throw new BusinessException($"Meeting mit Id {meetingId} nicht gefunden.");
 }

 // Prüfe, ob der anfragende Benutzer Teilnehmer des Meetings ist
 var participant = meeting.Participants.FirstOrDefault(p => p.UserId == userId);
 if (participant == null)
 {
     throw new BusinessException("Sie haben keinen Zugriff auf dieses Meeting.");
 }

 #endregion

 // Optimistic Concurrency: Setze den ConcurrencyStamp des geladenen Meeting-Entities 
 // auf den vom Frontend gelieferten Wert. So erkennt das EF/ABP-Framework, 
 // falls das Meeting zwischenzeitlich von jemand anderem geändert wurde.
 //meeting.ConcurrencyStamp = input.ConcurrencyStamp;

 // Alle folgenden DB-Änderungen laufen in einer Transaktion (ABP UnitOfWork),
 // um Konsistenz sicherzustellen – entweder werden alle Änderungen gespeichert oder keine.
 try
 {
     #region Globale Überschreibung der AllMoodTypes (nur Admin)
     if (userMode == UserModeDto.Admin)
     {

         var moodTypeIds = input.AllMoodTypes.Where(m => m.Delete).Select(x => x.Id).ToList();
         var moodVotes = await _moodVoteRepository.GetListAsync(mv => moodTypeIds.Contains(mv.MoodTypeId));

         foreach (var moodVote in moodVotes)
         {
             await _moodVoteRepository.DeleteAsync(moodVote, autoSave: true);
         }

         // 1. Lösche alle MoodTypes, die vom Administrator zum Entfernen markiert wurden
         foreach (var moodTypeDto in moodTypeIds)
         {
             // Löschen des MoodType (falls bereits von anderem Admin gelöscht, wirft dies eine Exception)
             await _moodTypeRepository.DeleteAsync(moodTypeDto, autoSave: true);
         }

         // 2. Lade die verbleibenden existierenden MoodTypes aus der DB (nach evtl. Löschungen)
         var existingMoodTypes = await _moodTypeRepository.GetListAsync();

         // 3. Füge neue MoodTypes hinzu oder aktualisiere bestehende anhand der Admin-Eingaben
         foreach (var moodTypeDto in input.AllMoodTypes)
         {
             if (moodTypeDto.Delete)
             {
                 // Überspringe MoodTypes, die bereits gelöscht wurden
                 continue;
             }

             var moodTypeEntity = existingMoodTypes.FirstOrDefault(mt => mt.Id == moodTypeDto.Id);
             if (moodTypeEntity == null)
             {
                 // MoodType existiert noch nicht -> neu anlegen
                 var newMoodType = new MoodType
                 {
                     Name = moodTypeDto.Name,
                     Description = moodTypeDto.Description,
                     Color = moodTypeDto.Color,
                     CreatedAt = DateTime.UtcNow
                     // Id (Key) wird bei Bedarf vom ORM/DB vergeben (z.B. Identity oder Guid über GuidGenerator)
                 };
                 await _moodTypeRepository.InsertAsync(newMoodType, autoSave: true);
             }
             else
             {
                 // MoodType existiert bereits -> aktualisieren
                 // Setze auch hier den ConcurrencyStamp, um parallele Änderungen an MoodTypes zu erkennen
                 //moodTypeEntity.ConcurrencyStamp = moodTypeDto.ConcurrencyStamp;
                 moodTypeEntity.Name = moodTypeDto.Name;
                 moodTypeEntity.Description = moodTypeDto.Description;
                 moodTypeEntity.Color = moodTypeDto.Color;
                 moodTypeEntity.UpdatedAt = DateTime.UtcNow;
                 await _moodTypeRepository.UpdateAsync(moodTypeEntity, autoSave: true);
             }
         }
     }
     #endregion

     #region Vorhandene Moods überschreiben bzw. hinzufügen (MoodVotes)

     if (input.AllMoodTypes != null && input.AllMoodTypes.Count > 0)
     {
         // Entferne alle bisherigen MoodVotes des Teilnehmers, um sie durch die neuen zu ersetzen
         await _moodVoteRepository.DeleteAsync(mv => mv.ParticipantId == participant.Id);
         // Lege für jeden im Frontend ausgewählten MoodType einen neuen MoodVote an
         foreach (var moodTypeDto in input.AllMoodTypes)
         {
             if (moodTypeDto.Selected)
             {
                 var newMoodVote = new MoodVote
                 {
                     ParticipantId = participant.Id,
                     MoodTypeId = moodTypeDto.Id,
                     VoteTime = DateTime.UtcNow
                 };
                 await _moodVoteRepository.InsertAsync(newMoodVote, autoSave: true);
             }
         }
     }
     #endregion

     #region Hinzufügen neuer Nachrichten (UserMessages) für den Teilnehmer
     // Speichere alle neuen Nachrichten, die vom Teilnehmer im Frontend hinzugefügt wurden
     foreach (var messageDto in (input.UserMessages ?? new List<MessageDto>()))
     {
         var newMessage = new Message
         {
             ParticipantId = participant.Id,
             CurrentMessage = messageDto.CurrentMessage,
             CreatedAt = DateTime.UtcNow
         };
         await _messageRepository.InsertAsync(newMessage, autoSave: true);
     }
     #endregion

     #region Sonstige Eigenschaften aktualisieren
     // Aktualisiere die Meeting-Eigenschaften
     meeting.ScheduledTime = input.ScheduledTime;
     meeting.UpdatedAt = DateTime.UtcNow;
     #endregion

     // Speichere die Änderungen am Meeting (ConcurrencyStamp wird vom Framework geprüft)
     var updatedMeeting = await _meetingRepository.UpdateAsync(meeting, autoSave: true);

     #region DTO vorbereiten (Ergebnis für das Frontend)
     // Mappe das aktualisierte Meeting-Entity zurück auf das MeetingDto
     var meetingDto = ObjectMapper.Map<Meeting, MeetingDto>(updatedMeeting);

     #region AllMoodTypes für das Ausgabe-DTO
     // Hole die aktuelle Liste aller MoodTypes aus der Datenbank 
     var moodTypes = await _moodTypeRepository.GetListAsync();

     // Markiere im MoodType-Listening diejenigen als 'Selected', die der Teilnehmer jetzt ausgewählt hat
     if (participant.MoodVotes != null && participant.MoodVotes.Any())
     {
         // Falls die MoodVotes des Teilnehmers bereits im Kontext verfügbar sind, nutze sie
         foreach (var vote in participant.MoodVotes)
         {
             var moodType = moodTypes.FirstOrDefault(m => m.Id == vote.MoodTypeId);
             if (moodType != null)
             {
                 moodType.Selected = true;
             }
         }
     }
     else
     {
         // Falls die MoodVotes nicht im Kontext geladen sind, verwende die aktuelle Auswahl aus dem Input
         foreach (var moodTypeDto in input.AllMoodTypes)
         {
             var moodType = moodTypes.FirstOrDefault(m => m.Id == moodTypeDto.Id);
             if (moodType != null)
             {
                 moodType.Selected = moodTypeDto.Selected;
             }
         }
     }

     // Wandle die MoodType-Entitäten in DTOs um (immer eine Liste bereitstellen, auch wenn leer)
     meetingDto.AllMoodTypes = moodTypes.Any()
         ? ObjectMapper.Map<List<MoodType>, List<MoodTypeDto>>(moodTypes)
         : new List<MoodTypeDto>();
     #endregion

     #region UserMessages für das Ausgabe-DTO
     // Hole alle Nachrichten für den Teilnehmer und mappe sie auf DTOs 
     var messages = await _messageRepository.GetListAsync(m => m.ParticipantId == participant.Id);
     meetingDto.UserMessages = messages.Any()
         ? ObjectMapper.Map<List<Message>, List<MessageDto>>(messages)
         : new List<MessageDto>();
     #endregion

     #endregion

     // Gebe das aktualisierte Meeting als DTO zurück
     return meetingDto;
 }
 catch (AbpDbConcurrencyException)
 {
     // Falls zwischen Laden und Speichern eine parallele Änderung entdeckt wurde (optimistische Sperre),
     // wird eine verständliche Ausnahme geworfen, die z.B. im Frontend angezeigt werden kann.
     //throw new BusinessException("Das Meeting wurde in der Zwischenzeit von einem anderen Benutzer geändert. Bitte laden Sie die Seite neu und versuchen Sie es erneut.");

     var queryableMeeting1 = await _meetingRepository.WithDetailsAsync(m => m.Participants);
     var meetingQuery1 = queryableMeeting1.Where(x => x.Id == meetingId);
     var meeting1 = await AsyncExecuter.FirstOrDefaultAsync(meetingQuery1);

     return ObjectMapper.Map<Meeting, MeetingDto>(meeting1);
 }
 catch (Exception ex)
 {
     Logger.LogError(ex, "Ein unerwarteter Fehler ist aufgetreten.");

     var queryableMeeting1 = await _meetingRepository.WithDetailsAsync(m => m.Participants);
     var meetingQuery1 = queryableMeeting1.Where(x => x.Id == meetingId);
     var meeting1 = await AsyncExecuter.FirstOrDefaultAsync(meetingQuery1);

     return ObjectMapper.Map<Meeting, MeetingDto>(meeting1);
 }

}

and

`[DisableAuditing] public async Task ReceiveHeartbeatAsync(Guid userId, Guid meetingId, string userAgent, UserModeDto userMode) { try { var participant = await _participantRepository.FirstOrDefaultAsync(p => p.UserId == userId && p.MeetingId == meetingId); if (participant != null) { participant.LastHeartbeat = DateTime.UtcNow; participant.UserAgent = userAgent; participant.eUserMode = (UserMode)userMode; if (participant.IsInactive) { participant.IsInactive = false; } // Änderung explizit speichern, um Verbindung schnell freizugeben await _participantRepository.UpdateAsync(participant); } else { var newParticipant = new Participant { LastHeartbeat = DateTime.UtcNow, eUserMode = (UserMode)userMode, MeetingId = meetingId, UserId = userId, UserAgent = userAgent, IsInactive = false // Neuer Teilnehmer ist aktiv };

          await _participantRepository.InsertAsync(newParticipant, autoSave: true);
      }
  }
  catch (AbpDbConcurrencyException ex)
  {
      // Fail silently
      Logger.LogWarning(ex, "Ein Konkurrenzfehler ist aufgetreten, wurde jedoch behandelt.");
  }
  catch (Exception ex)
  { 
      Logger.LogError(ex, "Ein unerwarteter Fehler ist aufgetreten.");
  }

} `

I send you the standard-log: "** public async static Task<int> Main(string[] args)

 {
     Log.Logger = new LoggerConfiguration()
         .WriteTo.Async(c => c.File("Logs/logs.txt"))
         .WriteTo.Async(c => c.Console())
         .CreateBootstrapLogger();

     try
     {
         Log.Information("Starting VibeScan.HttpApi.Host.");
         var builder = WebApplication.CreateBuilder(args);
         builder.Host
             .AddAppSettingsSecretsJson()
             .UseAutofac()
             .UseSerilog((context, services, loggerConfiguration) =>
             {
                 loggerConfiguration
                 #if DEBUG
                     .MinimumLevel.Debug()
                 #else
                     .MinimumLevel.Information()
                 #endif
                     .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
                     .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
                     .Enrich.FromLogContext()
                     .WriteTo.Async(c => c.File("Logs/logs.txt"))
                     .WriteTo.Async(c => c.Console())
                     .WriteTo.Async(c => c.AbpStudio(services));
             });
         await builder.AddApplicationAsync<VibeScanHttpApiHostModule>();
         var app = builder.Build();
         await app.InitializeApplicationAsync();
         await app.RunAsync();
         return 0;
     }
     catch (Exception ex)
     {
         if (ex is HostAbortedException)
         {
             throw;
         }

         Log.Fatal(ex, "Host terminated unexpectedly!");
         return 1;
     }"**

ok, sent the mail

/// <summary>
/// Führt die Statusprüfung nach erfolgreichem Heartbeat (aus dem Frontend) aus
/// Überprüft den Status des Benutzers und aktualisiert die Stimmungstypen.
/// Der Server kann den Status des Benutzers überwachen und bei Inaktivität den Benutzer und all seine Einstellungen löschen.
/// Der Heartbeat wird alle xxx ms gesendet.
/// </summary>
/// <param name="userId"></param>
/// <param name="meetingId"></param>
/// <returns></returns>
[DisableAuditing]
public async Task ReceiveHeartbeatAsync(Guid userId, Guid meetingId, string userAgent, UserModeDto userMode)
{
    var participant = await _participantRepository.FirstOrDefaultAsync(p => p.UserId == userId && p.MeetingId == meetingId);
    if (participant != null)
    {
        participant.LastHeartbeat = DateTime.UtcNow;
        participant.UserAgent = userAgent;
        participant.eUserMode = (UserMode)userMode;
        if (participant.IsInactive)
        {
            participant.IsInactive = false;
        }
        // Änderung explizit speichern, um Verbindung schnell freizugeben
        await _participantRepository.UpdateAsync(participant);
    }
    else
    {
        var newParticipant = new Participant
        {
            LastHeartbeat = DateTime.UtcNow,
            eUserMode = (UserMode)userMode,
            MeetingId = meetingId,
            UserId = userId,
            UserAgent = userAgent,
            IsInactive = false // Neuer Teilnehmer ist aktiv
        };

        await _participantRepository.InsertAsync(newParticipant, autoSave: true);
    }
}

2025-03-31 10:53:39.938 +02:00 [INF] Executed action xxx.Services.VibeScan.HeartbeatAppService.CheckParticipantStatusAsync (VibeScan.Application) in 145.3677ms 2025-03-31 10:53:39.938 +02:00 [INF] Executed endpoint 'xxx.Services.VibeScan.HeartbeatAppService.CheckParticipantStatusAsync (VibeScan.Application)' 2025-03-31 10:53:39.939 +02:00 [INF] Executed action xxx.Services.VibeScan.HeartbeatAppService.CheckParticipantStatusAsync (VibeScan.Application) in 151.6886ms 2025-03-31 10:53:39.939 +02:00 [INF] Executed endpoint 'xxx.Services.VibeScan.HeartbeatAppService.CheckParticipantStatusAsync (VibeScan.Application)' 2025-03-31 10:53:39.950 +02:00 [INF] Executed action xxx.Services.VibeScan.HeartbeatAppService.CheckParticipantStatusAsync (VibeScan.Application) in 160.7774ms 2025-03-31 10:53:39.950 +02:00 [INF] Executed endpoint 'xxx.Services.VibeScan.HeartbeatAppService.CheckParticipantStatusAsync (VibeScan.Application)' 2025-03-31 10:53:39.950 +02:00 [INF] Executed action xxx.Services.VibeScan.HeartbeatAppService.CheckParticipantStatusAsync (VibeScan.Application) in 162.9852ms 2025-03-31 10:53:39.950 +02:00 [INF] Executed endpoint 'xxx.Services.VibeScan.HeartbeatAppService.CheckParticipantStatusAsync (VibeScan.Application)' 2025-03-31 10:53:39.950 +02:00 [INF] Request finished HTTP/2 POST https://localhost:44398/api/app/heartbeat/check-messsages-to-delete - 204 null null 151.3811ms 2025-03-31 10:53:39.951 +02:00 [ERR] ---------- RemoteServiceErrorInfo ---------- { "code": null, "message": "The data you have submitted has already been changed by another user. Discard your changes and try again.", "details": null, "data": null, "validationErrors": null }

2025-03-31 10:53:39.953 +02:00 [INF] Executed action xxx.Services.VibeScan.HeartbeatAppService.CheckParticipantStatusAsync (VibeScan.Application) in 104.8075ms 2025-03-31 10:53:39.953 +02:00 [INF] Executed endpoint 'xxx.Services.VibeScan.HeartbeatAppService.CheckParticipantStatusAsync (VibeScan.Application)' 2025-03-31 10:53:39.953 +02:00 [ERR] The database operation was expected to affect 1 row(s), but actually affected 0 row(s); data may have been modified or deleted since entities were loaded. See https://go.microsoft.com/fwlink/?LinkId=527962 for information on understanding and handling optimistic concurrency exceptions. Volo.Abp.Data.AbpDbConcurrencyException: The database operation was expected to affect 1 row(s), but actually affected 0 row(s); data may have been modified or deleted since entities were loaded. See https://go.microsoft.com/fwlink/?LinkId=527962 for information on understanding and handling optimistic concurrency exceptions. ---> Microsoft.EntityFrameworkCore.DbUpdateConcurrencyException: The database operation was expected to affect 1 row(s), but actually affected 0 row(s); data may have been modified or deleted since entities were loaded. See https://go.microsoft.com/fwlink/?LinkId=527962 for information on understanding and handling optimistic concurrency exceptions. at Microsoft.EntityFrameworkCore.Update.AffectedCountModificationCommandBatch.ThrowAggregateUpdateConcurrencyExceptionAsync(RelationalDataReader reader, Int32 commandIndex, Int32 expectedRowsAffected, Int32 rowsAffected, CancellationToken cancellationToken) at Microsoft.EntityFrameworkCore.Update.AffectedCountModificationCommandBatch.ConsumeResultSetWithRowsAffectedOnlyAsync(Int32 commandIndex, RelationalDataReader reader, CancellationToken cancellationToken) at Microsoft.EntityFrameworkCore.Update.AffectedCountModificationCommandBatch.ConsumeAsync(RelationalDataReader reader, CancellationToken cancellationToken) at Microsoft.EntityFrameworkCore.Update.ReaderModificationCommandBatch.ExecuteAsync(IRelationalConnection connection, CancellationToken cancellationToken) at Microsoft.EntityFrameworkCore.Update.ReaderModificationCommandBatch.ExecuteAsync(IRelationalConnection connection, CancellationToken cancellationToken) at Microsoft.EntityFrameworkCore.SqlServer.Update.Internal.SqlServerModificationCommandBatch.ExecuteAsync(IRelationalConnection connection, CancellationToken cancellationToken) at Microsoft.EntityFrameworkCore.Update.Internal.BatchExecutor.ExecuteAsync(IEnumerable1 commandBatches, IRelationalConnection connection, CancellationToken cancellationToken) at Microsoft.EntityFrameworkCore.Update.Internal.BatchExecutor.ExecuteAsync(IEnumerable1 commandBatches, IRelationalConnection connection, CancellationToken cancellationToken) at Microsoft.EntityFrameworkCore.Update.Internal.BatchExecutor.ExecuteAsync(IEnumerable1 commandBatches, IRelationalConnection connection, CancellationToken cancellationToken) at Microsoft.EntityFrameworkCore.Storage.RelationalDatabase.SaveChangesAsync(IList1 entries, CancellationToken cancellationToken) at Microsoft.EntityFrameworkCore.ChangeTracking.Internal.StateManager.SaveChangesAsync(IList1 entriesToSave, CancellationToken cancellationToken) at Microsoft.EntityFrameworkCore.ChangeTracking.Internal.StateManager.SaveChangesAsync(StateManager stateManager, Boolean acceptAllChangesOnSuccess, CancellationToken cancellationToken) at Microsoft.EntityFrameworkCore.SqlServer.Storage.Internal.SqlServerExecutionStrategy.ExecuteAsync[TState,TResult](TState state, Func4 operation, Func4 verifySucceeded, CancellationToken cancellationToken) at Microsoft.EntityFrameworkCore.DbContext.SaveChangesAsync(Boolean acceptAllChangesOnSuccess, CancellationToken cancellationToken) at Volo.Abp.EntityFrameworkCore.AbpDbContext1.SaveChangesAsync(Boolean acceptAllChangesOnSuccess, CancellationToken cancellationToken) --- End of inner exception stack trace --- at Volo.Abp.EntityFrameworkCore.AbpDbContext`1.SaveChangesAsync(Boolean acceptAllChangesOnSuccess, CancellationToken cancellationToken) at Volo.Abp.Uow.UnitOfWork.SaveChangesAsync(CancellationToken cancellationToken) at Volo.Abp.AspNetCore.Mvc.Uow.AbpUowActionFilter.SaveChangesAsync(ActionExecutingContext context, IUnitOfWorkManager unitOfWorkManager, CancellationToken cancellationToken) at Volo.Abp.AspNetCore.Mvc.Uow.AbpUowActionFilter.SaveChangesAsync(ActionExecutingContext context, IUnitOfWorkManager unitOfWorkManager, CancellationToken cancellationToken) at Volo.Abp.AspNetCore.Mvc.Uow.AbpUowActionFilter.OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next) at Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker.

It must been thrown by the framework directly because " catch (AbpDbConcurrencyException) { // Falls zwischen Laden und Speichern eine parallele Änderung entdeckt wurde (optimistische Sperre), // wird eine verständliche Ausnahme geworfen, die z.B. im Frontend angezeigt werden kann. throw new BusinessException("Das Meeting wurde in der Zwischenzeit von einem anderen Benutzer geändert. Bitte laden Sie die Seite neu und versuchen Sie es erneut."); }" in my method is not beeing throwns instead the english is shown

no, its not working, i still get that error , not that often but it will appear (espiacially when change the data a lot over different clients)

Yes, thats the model

its not there anymore (commented out)