diff --git a/src/GreenHome.Api/Controllers/AlertConditionsController.cs b/src/GreenHome.Api/Controllers/AlertConditionsController.cs
index ef0593e..bf85bf9 100644
--- a/src/GreenHome.Api/Controllers/AlertConditionsController.cs
+++ b/src/GreenHome.Api/Controllers/AlertConditionsController.cs
@@ -81,5 +81,15 @@ public class AlertConditionsController : ControllerBase
         }
         return Ok();
     }
+
+    /// <summary>
+    /// دریافت شرایط هشدار رله‌ای (notificationType > 0) برای یک دستگاه
+    /// </summary>
+    [HttpGet("relay/{deviceId}")]
+    public async Task<ActionResult<object>> GetRelayConditions(int deviceId, CancellationToken cancellationToken)
+    {
+        var conditions = await alertConditionService.GetRelayConditionsAsync(deviceId, cancellationToken);
+        return Ok(new { conditions });
+    }
 }
 
diff --git a/src/GreenHome.Api/Controllers/TelemetryController.cs b/src/GreenHome.Api/Controllers/TelemetryController.cs
index f009a97..f519120 100644
--- a/src/GreenHome.Api/Controllers/TelemetryController.cs
+++ b/src/GreenHome.Api/Controllers/TelemetryController.cs
@@ -9,11 +9,13 @@ public class TelemetryController : ControllerBase
 {
     private readonly ITelemetryService telemetryService;
     private readonly IAlertService alertService;
+    private readonly IAlertConditionService alertConditionService;
 
-    public TelemetryController(ITelemetryService telemetryService, IAlertService alertService)
+    public TelemetryController(ITelemetryService telemetryService, IAlertService alertService, IAlertConditionService alertConditionService)
     {
         this.telemetryService = telemetryService;
         this.alertService = alertService;
+        this.alertConditionService = alertConditionService;
     }
 
     [HttpGet]
@@ -25,7 +27,7 @@ public class TelemetryController : ControllerBase
     }
 
     [HttpGet("AddData")]
-    public async Task<ActionResult<string>> Create([FromQuery] TelemetryDto telementry, CancellationToken cancellationToken)
+    public async Task<ActionResult<string>> Create([FromQuery] TelemetryDto telementry, [FromQuery] string? lastUpdateDate, CancellationToken cancellationToken)
     {
 
         telementry.TimestampUtc = DateTime.UtcNow;
@@ -43,28 +45,47 @@ public class TelemetryController : ControllerBase
             }
         }
 
-        // Check and send alerts if needed (fire and forget)
-        // _ = Task.Run(async () =>
-        // {
-        //     try
-        //     {
-        //         // Get deviceId from the saved telemetry record
-        //         var deviceId = telementry.DeviceId;
-        //         if (deviceId > 0)
-        //         {
-        //             await alertService.CheckAndSendAlertsAsync(deviceId, telementry, cancellationToken);
-        //         }
-        //     }
-        //     catch
-        //     {
-        //         // Log error but don't fail the request
-        //         // Errors are logged in AlertService
-        //     }
-        // }, cancellationToken);
+        // Check if relay conditions have been updated since lastUpdateDate
+        if (deviceId > 0 && !string.IsNullOrEmpty(lastUpdateDate))
+        {
+            var parsedDate = ParseLastUpdateDate(lastUpdateDate);
+            // var relayConditions = await alertConditionService.GetUpdatedRelayConditionsAsync(deviceId, parsedDate, cancellationToken);
+            // if (relayConditions.Count > 0)
+            // {
+            //     return Ok(new { conditions = relayConditions });
+            // }
+
+            var hasUpdates = await alertConditionService.HasUpdatedConditionsAsync(deviceId, parsedDate, cancellationToken);
+            if(hasUpdates)
+                return Ok("Relay");
+        }
 
         return Ok(id + "");
     }
 
+    /// <summary>
+    /// Parse date string in format: yyyy/MM/dd-HH:mm
+    /// </summary>
+    private static DateTime? ParseLastUpdateDate(string dateStr)
+    {
+        if (string.IsNullOrEmpty(dateStr))
+            return null;
+
+        // Try parsing as yyyy/MM/dd-HH:mm
+        if (DateTime.TryParseExact(dateStr, "yyyy/MM/dd-HH:mm", null, System.Globalization.DateTimeStyles.None, out var result))
+        {
+            return DateTime.SpecifyKind(result, DateTimeKind.Utc);
+        }
+
+        // Try parsing as yyyy-MM-dd HH:mm (ISO-like)
+        if (DateTime.TryParseExact(dateStr, "yyyy-MM-dd HH:mm", null, System.Globalization.DateTimeStyles.None, out var result2))
+        {
+            return DateTime.SpecifyKind(result2, DateTimeKind.Utc);
+        }
+
+        return null;
+    }
+
     [HttpGet("minmax")]
     public async Task<ActionResult<TelemetryMinMax>> MinMax([FromQuery] int deviceId, [FromQuery] DateTime? startUtc, [FromQuery] DateTime? endUtc, CancellationToken cancellationToken)
     {
diff --git a/src/GreenHome.Application/Dtos.cs b/src/GreenHome.Application/Dtos.cs
index 66f4516..c7e05bb 100644
--- a/src/GreenHome.Application/Dtos.cs
+++ b/src/GreenHome.Application/Dtos.cs
@@ -136,6 +136,7 @@ public sealed class DeviceSettingsDto
     public int UploadIntervalMin { get; set; } = 5;
     public string DevicePhoneNumber { get; set; } = string.Empty;
     public Domain.SimCardType? SimCardType { get; set; }
+    public int RelayCount { get; set; } = 4;
     public string SmsRecievers { get; set; } = string.Empty;
     public string? TokenCode { get; set; }
     public string? VerificationCode { get; set; }
@@ -171,6 +172,28 @@ public sealed class AlertRuleDto
     public int Order { get; set; }
 }
 
+/// <summary>
+/// DTO for relay alert conditions (notificationType > 0)
+/// </summary>
+public sealed class RelayConditionDto
+{
+    public int Enabled { get; set; }
+    public int TimeType { get; set; }
+    public string Relay { get; set; } = string.Empty;
+    public List<RelayRuleDto> Rules { get; set; } = new();
+}
+
+/// <summary>
+/// DTO for relay condition rules
+/// </summary>
+public sealed class RelayRuleDto
+{
+    public string Sensor { get; set; } = string.Empty;
+    public string Op { get; set; } = string.Empty;
+    public decimal V1 { get; set; }
+    public decimal? V2 { get; set; }
+}
+
 public sealed class CreateAlertConditionRequest
 {
     public required int DeviceId { get; set; }
diff --git a/src/GreenHome.Application/IAlertConditionService.cs b/src/GreenHome.Application/IAlertConditionService.cs
index 4b4ea09..c532eda 100644
--- a/src/GreenHome.Application/IAlertConditionService.cs
+++ b/src/GreenHome.Application/IAlertConditionService.cs
@@ -8,5 +8,18 @@ public interface IAlertConditionService
     Task UpdateAsync(UpdateAlertConditionRequest request, CancellationToken cancellationToken);
     Task DeleteAsync(int id, CancellationToken cancellationToken);
     Task<bool> ToggleEnabledAsync(int id, bool isEnabled, CancellationToken cancellationToken);
+    
+    /// <summary>
+    /// دریافت شرایط هشدار رله‌ای (notificationType > 0) برای یک دستگاه
+    /// </summary>
+    Task<IReadOnlyList<RelayConditionDto>> GetRelayConditionsAsync(int deviceId, CancellationToken cancellationToken);
+    
+    /// <summary>
+    /// دریافت شرایط هشدار رله‌ای که بعد از تاریخ مشخصی به‌روزرسانی شده‌اند
+    /// اگر هیچ رکوردی به‌روزرسانی نشده باشد، لیست خالی برمی‌گرداند
+    /// </summary>
+    Task<IReadOnlyList<RelayConditionDto>> GetUpdatedRelayConditionsAsync(int deviceId, DateTime? lastUpdateDate, CancellationToken cancellationToken);
+
+    Task<bool> HasUpdatedConditionsAsync(int deviceId, DateTime? lastUpdateDate, CancellationToken cancellationToken);
 }
 
diff --git a/src/GreenHome.Domain/DeviceSettings.cs b/src/GreenHome.Domain/DeviceSettings.cs
index 3244c59..8bb7eae 100644
--- a/src/GreenHome.Domain/DeviceSettings.cs
+++ b/src/GreenHome.Domain/DeviceSettings.cs
@@ -84,6 +84,11 @@ public sealed class DeviceSettings
     /// </summary>
     public SimCardType? SimCardType { get; set; }
 
+    /// <summary>
+    /// تعداد رله‌ها
+    /// </summary>
+    public int RelayCount { get; set; } = 4;
+
     [StringLength(120)]
     public string SmsRecievers { get; set; } = string.Empty;
     
diff --git a/src/GreenHome.Infrastructure/AlertConditionService.cs b/src/GreenHome.Infrastructure/AlertConditionService.cs
index 095acf8..c09ba7f 100644
--- a/src/GreenHome.Infrastructure/AlertConditionService.cs
+++ b/src/GreenHome.Infrastructure/AlertConditionService.cs
@@ -127,5 +127,60 @@ public sealed class AlertConditionService : IAlertConditionService
         await dbContext.SaveChangesAsync(cancellationToken);
         return true;
     }
+
+    public async Task<IReadOnlyList<RelayConditionDto>> GetRelayConditionsAsync(int deviceId, CancellationToken cancellationToken)
+    {
+        var conditions = await dbContext.AlertConditions
+            .Include(x => x.Rules)
+            .Where(x => x.DeviceId == deviceId && (int)x.NotificationType > 0)
+            .OrderByDescending(x => x.CreatedAt)
+            .AsNoTracking()
+            .ToListAsync(cancellationToken);
+
+        var result = conditions.Select(c => new RelayConditionDto
+        {
+            Enabled = c.IsEnabled ? 1 : 0,
+            TimeType = (int)c.TimeType,
+            Relay = "R" + (int)c.NotificationType,
+            Rules = c.Rules.OrderBy(r => r.Order).Select(r => new RelayRuleDto
+            {
+                Sensor = ((int)r.SensorType).ToString(),
+                Op = ((int)r.ComparisonType).ToString(),
+                V1 = r.Value1,
+                V2 = r.Value2
+            }).ToList()
+        }).ToList();
+
+        return result;
+    }
+
+    public async Task<IReadOnlyList<RelayConditionDto>> GetUpdatedRelayConditionsAsync(int deviceId, DateTime? lastUpdateDate, CancellationToken cancellationToken)
+    {
+        // اگر lastUpdateDate null باشه، یعنی کلاینت تا حالا هیچ داده‌ای نگرفته، همه رو برگردون
+        if (lastUpdateDate == null)
+        {
+            return await GetRelayConditionsAsync(deviceId, cancellationToken);
+        }
+
+        var hasUpdates = await dbContext.AlertConditions
+            .AnyAsync(x => x.DeviceId == deviceId && (int)x.NotificationType > 0 && x.UpdatedAt > lastUpdateDate, cancellationToken);
+
+        if (!hasUpdates)
+        {
+            return Array.Empty<RelayConditionDto>();
+        }
+
+        return await GetRelayConditionsAsync(deviceId, cancellationToken);
+    }
+
+    public async Task<bool> HasUpdatedConditionsAsync(int deviceId, DateTime? lastUpdateDate, CancellationToken cancellationToken)
+    {
+        if(lastUpdateDate == null) return true;
+
+        var hasUpdates = await dbContext.AlertConditions
+            .AnyAsync(x => x.DeviceId == deviceId && (int)x.NotificationType > 0 && x.UpdatedAt > lastUpdateDate, cancellationToken);
+
+        return hasUpdates;
+    }
 }
 
diff --git a/src/GreenHome.Infrastructure/AlertService.cs b/src/GreenHome.Infrastructure/AlertService.cs
index 7016ded..cac755b 100644
--- a/src/GreenHome.Infrastructure/AlertService.cs
+++ b/src/GreenHome.Infrastructure/AlertService.cs
@@ -112,16 +112,20 @@ public sealed class AlertService : IAlertService
             // Check if all rules match (AND logic)
             var allRulesMatch = condition.Rules.All(rule => CheckRule(rule, telemetry));
 
-            if (allRulesMatch && condition.Rules.Any())
+            if (allRulesMatch && condition.Rules.Count != 0)
             {
                 // All rules passed, send alert if cooldown period has passed
                 // await SendAlertForConditionAsync(condition, device, usersToAlert, telemetry, cancellationToken);
-                string? message = await GetAlertMessage(condition, device, device.User, telemetry, cancellationToken);
-                if(message != null && message.Length > 0)
-                    messages.Add(message);
+                AlertNotification notif = await GetAlertMessage(condition, device, device.User, telemetry, cancellationToken);
+                if(notif != null && !string.IsNullOrEmpty(notif.Message))
+                {
+                    messages.Add(notif.Message);
+                    await dbContext.AlertNotifications.AddAsync(notif, cancellationToken);
+                }
                 // return message;
             }
         }
+        await dbContext.SaveChangesAsync(cancellationToken);
 
         if(telemetry.OldPower == 0 && telemetry.Power == 1)
         {
@@ -163,7 +167,7 @@ public sealed class AlertService : IAlertService
         };
     }
 
-    private async Task<string?> GetAlertMessage(
+    private async Task<AlertNotification> GetAlertMessage(
         Domain.AlertCondition condition,
         Domain.Device device,
         User user,
@@ -204,12 +208,12 @@ public sealed class AlertService : IAlertService
             //MessageOutboxIds = messageOutboxIds,
             //ErrorMessage = errorMessage,
             SentAt = sentAt,
-            IsSent = true
+            //IsSent = true
         };
 
-        dbContext.AlertNotifications.Add(notification);
+        // dbContext.AlertNotifications.Add(notification);
 
-        return message;
+        return notification;
     }
 
     private async Task SendAlertForConditionAsync(
diff --git a/src/GreenHome.Infrastructure/GreenHomeDbContext.cs b/src/GreenHome.Infrastructure/GreenHomeDbContext.cs
index 3e22b8c..8916f1b 100644
--- a/src/GreenHome.Infrastructure/GreenHomeDbContext.cs
+++ b/src/GreenHome.Infrastructure/GreenHomeDbContext.cs
@@ -75,6 +75,7 @@ public sealed class GreenHomeDbContext : DbContext
             b.Property(x => x.MinimumCallIntervalMinutes).HasDefaultValue(60);
             b.Property(x => x.AreaSquareMeters).HasColumnType("decimal(18,2)");
             b.Property(x => x.SmsRecievers).HasMaxLength(120);
+            b.Property(x => x.RelayCount).HasDefaultValue(4);
             b.HasOne(x => x.Device)
                 .WithMany()
                 .HasForeignKey(x => x.DeviceId)
diff --git a/src/GreenHome.Infrastructure/Migrations/20260428054608_AddRelayCountToDeviceSettings.Designer.cs b/src/GreenHome.Infrastructure/Migrations/20260428054608_AddRelayCountToDeviceSettings.Designer.cs
new file mode 100644
index 0000000..c3a83c6
--- /dev/null
+++ b/src/GreenHome.Infrastructure/Migrations/20260428054608_AddRelayCountToDeviceSettings.Designer.cs
@@ -0,0 +1,1251 @@
+// <auto-generated />
+using System;
+using GreenHome.Infrastructure;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace GreenHome.Infrastructure.Migrations
+{
+    [DbContext(typeof(GreenHomeDbContext))]
+    [Migration("20260428054608_AddRelayCountToDeviceSettings")]
+    partial class AddRelayCountToDeviceSettings
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.9")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("GreenHome.Domain.AIQuery", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Answer")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("CompletionTokens")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DeviceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Model")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<int>("PromptTokens")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Question")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<long?>("ResponseTimeMs")
+                        .HasColumnType("bigint");
+
+                    b.Property<double?>("Temperature")
+                        .HasColumnType("float");
+
+                    b.Property<int>("TotalTokens")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.HasIndex("DeviceId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AIQueries", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.AlertCondition", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("CallCooldownMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("DeviceId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("NotificationType")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SmsCooldownMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TimeType")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeviceId");
+
+                    b.ToTable("AlertConditions", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.AlertLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AlertConditionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("AlertType")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DeviceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ErrorMessage")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<int>("NotificationType")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PhoneNumber")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.Property<long>("ProcessingTimeMs")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("SentAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AlertConditionId");
+
+                    b.HasIndex("AlertType");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("DeviceId", "SentAt");
+
+                    b.HasIndex("UserId", "SentAt");
+
+                    b.ToTable("AlertLogs", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.AlertNotification", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AlertConditionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DeviceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ErrorMessage")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<bool>("IsSent")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("MessageOutboxIds")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("NotificationType")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("SentAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AlertConditionId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("DeviceId", "UserId", "AlertConditionId", "SentAt");
+
+                    b.ToTable("AlertNotifications", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.AlertRule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AlertConditionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ComparisonType")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SensorType")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Value1")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal?>("Value2")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AlertConditionId");
+
+                    b.ToTable("AlertRules", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.Checklist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("CreatedByUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<int>("DeviceId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedByUserId");
+
+                    b.HasIndex("DeviceId", "IsActive");
+
+                    b.ToTable("Checklists", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.ChecklistCompletion", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChecklistId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CompletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("CompletedByUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<string>("PersianDate")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("nvarchar(10)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CompletedByUserId");
+
+                    b.HasIndex("ChecklistId", "PersianDate");
+
+                    b.ToTable("ChecklistCompletions", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.ChecklistItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChecklistId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<bool>("IsRequired")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(300)
+                        .HasColumnType("nvarchar(300)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId", "Order");
+
+                    b.ToTable("ChecklistItems", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.ChecklistItemCompletion", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChecklistCompletionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ChecklistItemId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsChecked")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistCompletionId");
+
+                    b.HasIndex("ChecklistItemId");
+
+                    b.ToTable("ChecklistItemCompletions", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.DailyReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Analysis")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("CompletionTokens")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("DeviceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Model")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("PersianDate")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("nvarchar(10)");
+
+                    b.Property<int>("PersianDay")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PersianMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PersianYear")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PromptTokens")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RecordCount")
+                        .HasColumnType("int");
+
+                    b.Property<long?>("ResponseTimeMs")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SampledRecordCount")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TotalTokens")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.HasIndex("DeviceId", "PersianDate")
+                        .IsUnique();
+
+                    b.HasIndex("DeviceId", "PersianYear", "PersianMonth");
+
+                    b.ToTable("DailyReports", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.Device", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("DeviceName")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("nvarchar(10)");
+
+                    b.Property<string>("Location")
+                        .IsRequired()
+                        .HasMaxLength(250)
+                        .HasColumnType("nvarchar(250)");
+
+                    b.Property<string>("NeshanLocation")
+                        .IsRequired()
+                        .HasMaxLength(80)
+                        .HasColumnType("nvarchar(80)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Devices", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.DevicePost", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AuthorUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(5000)
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("DeviceId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AuthorUserId");
+
+                    b.HasIndex("DeviceId", "CreatedAt");
+
+                    b.ToTable("DevicePosts", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.DevicePostImage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<int>("DevicePostId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("nvarchar(255)");
+
+                    b.Property<string>("FilePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DevicePostId");
+
+                    b.ToTable("DevicePostImages", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.DeviceSettings", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal?>("AreaSquareMeters")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("City")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("DeviceId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("DeviceId1")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DevicePhoneNumber")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<decimal?>("Latitude")
+                        .HasColumnType("decimal(9,6)");
+
+                    b.Property<decimal?>("Longitude")
+                        .HasColumnType("decimal(9,6)");
+
+                    b.Property<int>("MinimumCallIntervalMinutes")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(60);
+
+                    b.Property<int>("MinimumSmsIntervalMinutes")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(15);
+
+                    b.Property<string>("ProductType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Province")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<int>("RelayCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(4);
+
+                    b.Property<int?>("SimCardType")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SmsRecievers")
+                        .IsRequired()
+                        .HasMaxLength(120)
+                        .HasColumnType("nvarchar(120)");
+
+                    b.Property<string>("TokenCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("TokenExpiresAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("UploadIntervalMin")
+                        .HasColumnType("int");
+
+                    b.Property<string>("VerificationCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeviceId")
+                        .IsUnique();
+
+                    b.HasIndex("DeviceId1");
+
+                    b.ToTable("DeviceSettings", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.DeviceUser", b =>
+                {
+                    b.Property<int>("DeviceId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("ReceiveAlerts")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.HasKey("DeviceId", "UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("DeviceUsers", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.ReportImage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("nvarchar(255)");
+
+                    b.Property<string>("FilePath")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("UploadedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("UserDailyReportId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserDailyReportId");
+
+                    b.ToTable("ReportImages", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.TelemetryRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal?>("BatteryPercent")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal?>("BatteryVoltage")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("DeviceId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("GasPPM")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("HumidityPercent")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("Lux")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("PersianDate")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("nvarchar(10)");
+
+                    b.Property<int>("PersianMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PersianYear")
+                        .HasColumnType("int");
+
+                    b.Property<byte?>("Power")
+                        .HasColumnType("tinyint");
+
+                    b.Property<DateTime>("ServerTimestampUtc")
+                        .HasColumnType("datetime2");
+
+                    b.Property<decimal>("SoilPercent")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<decimal>("TemperatureC")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime>("TimestampUtc")
+                        .HasColumnType("datetime2");
+
+                    b.Property<decimal?>("Voltage")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeviceId", "ServerTimestampUtc");
+
+                    b.HasIndex("DeviceId", "TimestampUtc");
+
+                    b.HasIndex("DeviceId", "PersianYear", "PersianMonth");
+
+                    b.ToTable("Telemetry", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Family")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<DateTime?>("LastLoginAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Mobile")
+                        .IsRequired()
+                        .HasMaxLength(11)
+                        .HasColumnType("nvarchar(11)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Mobile")
+                        .IsUnique();
+
+                    b.ToTable("Users", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.UserDailyReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("DeviceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Notes")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<string>("Observations")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Operations")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PersianDate")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("nvarchar(10)");
+
+                    b.Property<int>("PersianDay")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PersianMonth")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PersianYear")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("DeviceId", "PersianDate");
+
+                    b.HasIndex("DeviceId", "PersianYear", "PersianMonth");
+
+                    b.ToTable("UserDailyReports", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.VerificationCode", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(4)
+                        .HasColumnType("nvarchar(4)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("IsUsed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Mobile")
+                        .IsRequired()
+                        .HasMaxLength(11)
+                        .HasColumnType("nvarchar(11)");
+
+                    b.Property<DateTime?>("UsedAt")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Mobile", "Code", "IsUsed");
+
+                    b.ToTable("VerificationCodes", (string)null);
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.AIQuery", b =>
+                {
+                    b.HasOne("GreenHome.Domain.Device", "Device")
+                        .WithMany()
+                        .HasForeignKey("DeviceId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("GreenHome.Domain.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Device");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.AlertCondition", b =>
+                {
+                    b.HasOne("GreenHome.Domain.Device", "Device")
+                        .WithMany()
+                        .HasForeignKey("DeviceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Device");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.AlertLog", b =>
+                {
+                    b.HasOne("GreenHome.Domain.AlertCondition", "AlertCondition")
+                        .WithMany()
+                        .HasForeignKey("AlertConditionId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("GreenHome.Domain.Device", "Device")
+                        .WithMany()
+                        .HasForeignKey("DeviceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("GreenHome.Domain.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("AlertCondition");
+
+                    b.Navigation("Device");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.AlertNotification", b =>
+                {
+                    b.HasOne("GreenHome.Domain.AlertCondition", "AlertCondition")
+                        .WithMany()
+                        .HasForeignKey("AlertConditionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("GreenHome.Domain.Device", "Device")
+                        .WithMany()
+                        .HasForeignKey("DeviceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("GreenHome.Domain.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("AlertCondition");
+
+                    b.Navigation("Device");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.AlertRule", b =>
+                {
+                    b.HasOne("GreenHome.Domain.AlertCondition", "AlertCondition")
+                        .WithMany("Rules")
+                        .HasForeignKey("AlertConditionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AlertCondition");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.Checklist", b =>
+                {
+                    b.HasOne("GreenHome.Domain.User", "CreatedByUser")
+                        .WithMany()
+                        .HasForeignKey("CreatedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("GreenHome.Domain.Device", "Device")
+                        .WithMany()
+                        .HasForeignKey("DeviceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CreatedByUser");
+
+                    b.Navigation("Device");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.ChecklistCompletion", b =>
+                {
+                    b.HasOne("GreenHome.Domain.Checklist", "Checklist")
+                        .WithMany("Completions")
+                        .HasForeignKey("ChecklistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GreenHome.Domain.User", "CompletedByUser")
+                        .WithMany()
+                        .HasForeignKey("CompletedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Checklist");
+
+                    b.Navigation("CompletedByUser");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.ChecklistItem", b =>
+                {
+                    b.HasOne("GreenHome.Domain.Checklist", "Checklist")
+                        .WithMany("Items")
+                        .HasForeignKey("ChecklistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Checklist");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.ChecklistItemCompletion", b =>
+                {
+                    b.HasOne("GreenHome.Domain.ChecklistCompletion", "ChecklistCompletion")
+                        .WithMany("ItemCompletions")
+                        .HasForeignKey("ChecklistCompletionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GreenHome.Domain.ChecklistItem", "ChecklistItem")
+                        .WithMany()
+                        .HasForeignKey("ChecklistItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ChecklistCompletion");
+
+                    b.Navigation("ChecklistItem");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.DailyReport", b =>
+                {
+                    b.HasOne("GreenHome.Domain.Device", "Device")
+                        .WithMany()
+                        .HasForeignKey("DeviceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Device");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.Device", b =>
+                {
+                    b.HasOne("GreenHome.Domain.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.DevicePost", b =>
+                {
+                    b.HasOne("GreenHome.Domain.User", "AuthorUser")
+                        .WithMany()
+                        .HasForeignKey("AuthorUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("GreenHome.Domain.Device", "Device")
+                        .WithMany()
+                        .HasForeignKey("DeviceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AuthorUser");
+
+                    b.Navigation("Device");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.DevicePostImage", b =>
+                {
+                    b.HasOne("GreenHome.Domain.DevicePost", "DevicePost")
+                        .WithMany("Images")
+                        .HasForeignKey("DevicePostId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DevicePost");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.DeviceSettings", b =>
+                {
+                    b.HasOne("GreenHome.Domain.Device", "Device")
+                        .WithMany()
+                        .HasForeignKey("DeviceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GreenHome.Domain.Device", null)
+                        .WithMany("DeviceSettings")
+                        .HasForeignKey("DeviceId1");
+
+                    b.Navigation("Device");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.DeviceUser", b =>
+                {
+                    b.HasOne("GreenHome.Domain.Device", "Device")
+                        .WithMany("DeviceUsers")
+                        .HasForeignKey("DeviceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GreenHome.Domain.User", "User")
+                        .WithMany("DeviceUsers")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Device");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.ReportImage", b =>
+                {
+                    b.HasOne("GreenHome.Domain.UserDailyReport", "UserDailyReport")
+                        .WithMany("Images")
+                        .HasForeignKey("UserDailyReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UserDailyReport");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.UserDailyReport", b =>
+                {
+                    b.HasOne("GreenHome.Domain.Device", "Device")
+                        .WithMany()
+                        .HasForeignKey("DeviceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("GreenHome.Domain.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Device");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.AlertCondition", b =>
+                {
+                    b.Navigation("Rules");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.Checklist", b =>
+                {
+                    b.Navigation("Completions");
+
+                    b.Navigation("Items");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.ChecklistCompletion", b =>
+                {
+                    b.Navigation("ItemCompletions");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.Device", b =>
+                {
+                    b.Navigation("DeviceSettings");
+
+                    b.Navigation("DeviceUsers");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.DevicePost", b =>
+                {
+                    b.Navigation("Images");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.User", b =>
+                {
+                    b.Navigation("DeviceUsers");
+                });
+
+            modelBuilder.Entity("GreenHome.Domain.UserDailyReport", b =>
+                {
+                    b.Navigation("Images");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/GreenHome.Infrastructure/Migrations/20260428054608_AddRelayCountToDeviceSettings.cs b/src/GreenHome.Infrastructure/Migrations/20260428054608_AddRelayCountToDeviceSettings.cs
new file mode 100644
index 0000000..1a364a7
--- /dev/null
+++ b/src/GreenHome.Infrastructure/Migrations/20260428054608_AddRelayCountToDeviceSettings.cs
@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace GreenHome.Infrastructure.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddRelayCountToDeviceSettings : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "RelayCount",
+                table: "DeviceSettings",
+                type: "int",
+                nullable: false,
+                defaultValue: 4);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "RelayCount",
+                table: "DeviceSettings");
+        }
+    }
+}
diff --git a/src/GreenHome.Infrastructure/Migrations/GreenHomeDbContextModelSnapshot.cs b/src/GreenHome.Infrastructure/Migrations/GreenHomeDbContextModelSnapshot.cs
index 49af6f7..9e1dbb6 100644
--- a/src/GreenHome.Infrastructure/Migrations/GreenHomeDbContextModelSnapshot.cs
+++ b/src/GreenHome.Infrastructure/Migrations/GreenHomeDbContextModelSnapshot.cs
@@ -623,6 +623,11 @@ namespace GreenHome.Infrastructure.Migrations
                         .HasMaxLength(100)
                         .HasColumnType("nvarchar(100)");
 
+                    b.Property<int>("RelayCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(4);
+
                     b.Property<int?>("SimCardType")
                         .HasColumnType("int");