Merge branch 'master' of https://tfs.nuvolar.hu:8443/tfs/AtomERP/_git/WorkFlowCheck

src/WorkFlowCheck.API/Controllers/CheckListController.cs

@@ -301,6 +301,28 @@ namespace WorkFlowCheck.API.Controllers
             return retVal;
         }
 
+        [HttpGet("CloneCheckListTemplateHeader/{id}")]
+        public async Task<ApiResponseDTO<bool>> CloneCheckListTemplateHeader(int id)
+        {
+            var retVal = new ApiResponseDTO<bool>()
+            {
+                IsSuccess = true,
+            };
+            var result = await _checkListService.CloneCheckListTemplateHeaderAsync(id);
+
+            if (result != null)
+            {
+                retVal.IsSuccess = true;
+                retVal.Data = result;
+            }
+            else
+            {
+                retVal.IsSuccess = false;
+                retVal.Errors.Add("No data!");
+            }
+
+            return retVal;
+        }
 
         [HttpGet("GetCheckListTemplateRow/{id}")]
         public async Task<ApiResponseDTO<CheckListTemplateRowDTO>> GetCheckListTemplateRow(int id)

src/WorkFlowCheck.API/Controllers/FCMController.cs

@@ -0,0 +1,147 @@
+using Google.Apis.Auth.OAuth2;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Newtonsoft.Json;
+using Serilog;
+using System.Net.Http.Headers;
+using System.Text;
+using WorkFlowCheck.BL.Services.Interfaces;
+using WorkFlowCheck.Common.DTO;
+
+namespace WorkFlowCheck.API.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class FCMController : ControllerBase
+    {
+        private readonly IMessageService _messageService;
+        public FCMController(IMessageService messageService)
+        {
+            _messageService = messageService;
+        }
+
+        [HttpPost("SendFCMMessage")]
+        public async Task<ApiResponseDTO<bool>> SendFCMMessage([FromBody] FCMMessageDTO fCMMessageDTO)
+        {
+            var retVal = new ApiResponseDTO<bool>()
+            {
+                IsSuccess = true
+            };
+
+            try
+            {
+                var pathToJsonKey = "com-nuvolar-wfcapp-firebase-adminsdk-fbsvc-37642626e4.json";
+                var projectId = "com-nuvolar-wfcapp";
+                var credential = GoogleCredential
+                                    .FromFile(pathToJsonKey)
+                                    .CreateScoped("https://www.googleapis.com/auth/firebase.messaging");
+                var accessToken = await credential.UnderlyingCredential.GetAccessTokenForRequestAsync();
+
+                var client = new HttpClient();
+                client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
+
+
+                var message = new
+                {
+                    message = new
+                    {
+                        token = fCMMessageDTO.Token,
+                        notification = new
+                        {
+                            title = fCMMessageDTO.Title,
+                            body = fCMMessageDTO.Body,
+                        }
+                    }
+                };
+
+                var json = JsonConvert.SerializeObject(message);
+                var content = new StringContent(json, Encoding.UTF8, "application/json");
+
+
+                var response = await client.PostAsync($"https://fcm.googleapis.com/v1/projects/{projectId}/messages:send", content);
+
+                var result = await response.Content.ReadAsStringAsync();
+
+
+            }
+            catch (Exception ex)
+            {
+                retVal.IsSuccess = false;
+                Log.Error(ex.Message);
+            }
+            return retVal;
+        }
+
+        [HttpPost("SendFCMMessageToLastToken")]
+        public async Task<ApiResponseDTO<bool>> SendFCMMessageToLastToken([FromBody] FCMMessageDTO fCMMessageDTO)
+        {
+            var retVal = new ApiResponseDTO<bool>()
+            {
+                IsSuccess = true
+            };
+
+            try
+            {
+                var pathToJsonKey = "com-nuvolar-wfcapp-firebase-adminsdk-fbsvc-37642626e4.json";
+                var projectId = "com-nuvolar-wfcapp";
+                var credential = GoogleCredential
+                                    .FromFile(pathToJsonKey)
+                                    .CreateScoped("https://www.googleapis.com/auth/firebase.messaging");
+                var accessToken = await credential.UnderlyingCredential.GetAccessTokenForRequestAsync();
+
+                var client = new HttpClient();
+                client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
+
+
+                var message = new
+                {
+                    message = new
+                    {
+                        token = await _messageService.GetLastFCMTokensAsync(),
+                        notification = new
+                        {
+                            title = fCMMessageDTO.Title,
+                            body = fCMMessageDTO.Body,
+                        }
+                    }
+                };
+
+                var json = JsonConvert.SerializeObject(message);
+                var content = new StringContent(json, Encoding.UTF8, "application/json");
+
+
+                var response = await client.PostAsync($"https://fcm.googleapis.com/v1/projects/{projectId}/messages:send", content);
+
+                var result = await response.Content.ReadAsStringAsync();
+
+
+            }
+            catch (Exception ex)
+            {
+                retVal.IsSuccess = false;
+                Log.Error(ex.Message);
+            }
+            return retVal;
+        }
+
+        [HttpPost("SendFCMToken")]
+        public async Task<ApiResponseDTO<bool>> SendFCMToken([FromBody] FCMMessageDTO fCMMessageDTO)
+        {
+            var retVal = new ApiResponseDTO<bool>()
+            {
+                IsSuccess = true
+            };
+
+            try
+            {
+                await _messageService.SendFCMTokenAsync(fCMMessageDTO.Token);
+            }
+            catch (Exception ex)
+            {
+                retVal.IsSuccess = false;
+                Log.Error(ex.Message);
+            }
+            return retVal;
+        }
+    }
+}

src/WorkFlowCheck.API/WorkFlowCheck.API.csproj

@@ -17,6 +17,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Google.Apis.Auth" Version="1.69.0" />
     <PackageReference Include="MailKit" Version="4.11.0" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="8.0.11" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.12">

src/WorkFlowCheck.API/com-nuvolar-wfcapp-firebase-adminsdk-fbsvc-37642626e4.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "com-nuvolar-wfcapp",
+  "private_key_id": "37642626e4a61fea715f3ef02a35d53fa9227666",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCVQKzCOgEhaQFo\nxtOYCpOc6XQNOVfNm8Z1xu1uoQtSZZIH3ivJy1IBqlyP/+sQ+7FO3Af5v90ae3rf\nvzd42QC4hrbBPyLGbVJWDHNPOzwg7bbez3waaU4i/7m4YJ61hlOObo888mjAxG8t\nz0cDEQzWPPUlLBCvtzY8Zv3jWdYaBxGUUzHxfemjTVLG7YCUjyt057HJVSH7AJpV\ndhnBi+3xlogsnK227ou/rLWoNyZVDOUaSiMor+LNiQx82eXc+UUaJgjpbI5AMk9z\n7CgAM8CSMOw7BHhCImVXaxH9rLZCsw0xpZnCJuOJKRyIMhrfcWKcHjrgkEW+xErj\nWN9lSkHRAgMBAAECggEAAwH5FUcrVom13b9bfF3ysnPdKwbNvVrLN5yDFIKV7oK1\n3Bca42u3rulIqR15doe275GVLtASL+ZfABcrslGPr1hGIqvvusdRVGL2+CjXveti\nbvgoDmVyvddwzf2S9zIiOQ2i8PHK4P8YZTg/DGmVnFPhRg7utWbMFtClw0UQQKkd\nzRwRDsw0jx9wDpP4EaO+czNvVZnnj+miL8QICN4gjbTdyQiVw2D1KzabwmozfEkM\nqTP+yH9mSC4gAEkG+X3i48QxiXZXvLflfnhF58+mT4yjIBIQbRTi0w9yLWRkcs8n\nmCq/89PZMncpNdCSJqdNOsYXgVaW8OMePxPNER2g4QKBgQDHl47N9AGyukpqEJJK\nR/8u3IwcCjLBb0wk5UxtZyz2JpoyqXoaKw7teqCqhg6lVd8MdIcVITKe0nZ+P29z\nyL+RVC+hGm/OQj6mAVyFEZptMgtQZGA2ThLY4ozZgzTW7uNyChhnUcqTiMCJ0g5g\n05imd6nQFKxI1ZfCsE7qlq6yYQKBgQC/bxKYno/6OT+9TTS+OCYVx9WJ8JCzOqFh\n/S+7qV14Bmml/JmYoSo/umxNOlKu3c7QtjU6caD/r4q/r6RHvvBxMlBu4K+vTEXh\nhFeqYORwTcEkcTDpjAGDekeJsRSxv5bg6QtsW30mtreBBC1/fOAvHD03Tz8GmFsp\nHry7b1WlcQKBgQCrnb51iix3oETh5DPVWQirI4n5hi9UMb24L81CeKepU1Hc4+qQ\nW5uvSHSjizdGpIpwLDYGThA3jeHC9gp/9Qn7DPcTQCcIo984YA1MgfFVmOUvj89G\ngmUkRdA0KuQhNzEsWk/XbvWPW9Op7YrdaLNl15iUyWHGEpo2FeEVRtEZoQKBgF5Z\nM+UcYQGGLa/y2UfXDI43izsM4YQ0JU3SJzBqbLK3FmLEeD8NT3FRRAdb81xT3ZZn\n9xvy3NKnhc6rll/17zMbBSFgg7X19YsMWtiSIIRpDgQT9XNlmWlfXtqx9+0S7B21\nPfgNr0ThUNe5Y2Mt/J+7X0BfQkTR2jwN9h665I9BAoGADx/oQLMXgKGdes4adF1Z\np9miGNsmUgXHdT+CdWkRx5uRd1a5s1Di6sOEUBPyFJ9hYc5ObRuC5q1A24ApASak\n0YCbUV1lqzFI4loXyM5ABqRTRCVGH94PXDAvsRUTTLvRIOliOeOBa8bNGGPlXtFw\nXzrkDjsz71JdNxgvT2Zz7nA=\n-----END PRIVATE KEY-----\n",
+  "client_email": "firebase-adminsdk-fbsvc@com-nuvolar-wfcapp.iam.gserviceaccount.com",
+  "client_id": "109975038898567298706",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/firebase-adminsdk-fbsvc%40com-nuvolar-wfcapp.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

src/WorkFlowCheck.BL/Services/CheckListService.cs

@@ -493,6 +493,53 @@ namespace WorkFlowCheck.BL.Services
         {
             return await DeleteEntityByIdAsync<CheckListTemplateHeader>(id);
         }
+        public async Task<bool> CloneCheckListTemplateHeaderAsync(int id)
+        {
+            var retVal = false;
+            try
+            {
+                var checkListTemplateHeader = await _dbContext.CheckListTemplateHeaders
+                                                              .AsNoTracking()
+                                                              .Include(i => i.CheckListTemplateRows)
+                                                              .Where(w => w.Id == id).FirstOrDefaultAsync();
+                if (checkListTemplateHeader != null)
+                {
+
+                    var newCheckListTemplateHeader = new CheckListTemplateHeader()
+                    {
+                        CheckListTemplateRows = new List<CheckListTemplateRow>(),
+                        Description = checkListTemplateHeader.Description,
+                        IsDeleted = false,
+                        NumberGenerator1Id = checkListTemplateHeader.NumberGenerator1Id,
+                        NumberGenerator2Id = checkListTemplateHeader.NumberGenerator2Id,
+                        ShortName = $"{checkListTemplateHeader.ShortName} (másolat)",
+                    };
+                    foreach (var checkListTemplateRow in checkListTemplateHeader.CheckListTemplateRows)
+                    {
+                        var newCheckListTemplateRow = new CheckListTemplateRow()
+                        {
+                            AnswerType = checkListTemplateRow.AnswerType,
+                            CheckListTemplateHeader = newCheckListTemplateHeader,
+                            CheckPointId = checkListTemplateRow.CheckPointId,
+                            EquipmentId = checkListTemplateRow.EquipmentId,
+                            IsDeleted = false,
+                            OperationDescription = checkListTemplateRow.OperationDescription,
+                            RowIndex = checkListTemplateRow.RowIndex,
+                        };
+                        newCheckListTemplateHeader.CheckListTemplateRows.Add(newCheckListTemplateRow);
+                    }
+                    _dbContext.CheckListTemplateHeaders.Add(newCheckListTemplateHeader);
+                    await _dbContext.SaveChangesAsync();
+                }
+            }
+            catch (Exception ex)
+            {
+                retVal = false;
+                Log.ForContext("TAG", "BusinessFlow").Error(ex.Message);
+            }
+
+            return retVal;
+        }
         public async Task<CheckListTemplateRowDTO> GetCheckListTemplateRowAsync(int id)
         {
             var retVal = new CheckListTemplateRowDTO();

src/WorkFlowCheck.BL/Services/Interfaces/ICheckListService.cs

@@ -20,6 +20,7 @@ namespace WorkFlowCheck.BL.Services.Interfaces
         Task<List<CheckListTemplateHeaderDTO>> GetAllCheckListTemplateHeaderAsync();
         Task<CheckListTemplateHeaderDTO> UpdateCheckListTemplateHeaderAsync(CheckListTemplateHeaderDTO checkListTemplateHeaderDTO);
         Task<bool> DeleteCheckListTemplateHeaderAsync(int id);
+        Task<bool> CloneCheckListTemplateHeaderAsync(int id);
         Task<CheckListTemplateRowDTO> GetCheckListTemplateRowAsync(int id);
         Task<bool> DeleteCheckListTemplateRowAsync(int id);  
         Task<CheckListTemplateRowDTO> UpdateCheckListTemplateRowAsync(CheckListTemplateRowDTO checkListTemplateRowDTO);

src/WorkFlowCheck.BL/Services/Interfaces/IMessageService.cs

@@ -9,5 +9,7 @@ namespace WorkFlowCheck.BL.Services.Interfaces
     public interface IMessageService
     {
         Task<bool> SendMailAsync(List<string> recipients, string subject, string htmlBody);
+        Task<bool> SendFCMTokenAsync(string token);
+        Task<string> GetLastFCMTokensAsync();
     }
 }

src/WorkFlowCheck.BL/Services/MessageService.cs

@@ -4,14 +4,21 @@ using MimeKit;
 using Microsoft.Extensions.Configuration;
 using WorkFlowCheck.BL.Models;
 using WorkFlowCheck.BL.Services.Interfaces;
+using Serilog;
+using WorkFlowCheck.DL.Entities;
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using WorkFlowCheck.DL;
 
 namespace WorkFlowCheck.BL.Services
 {
-    public class MessageService : IMessageService
+    public class MessageService : BaseService, IMessageService
     {
         private readonly EmailSettings _settings;
 
-        public MessageService(IConfiguration configuration)
+        public MessageService(AppDbContext dbContext,
+                                IMapper mapper,
+                                IConfiguration configuration) : base(dbContext, mapper)
         {
             _settings = configuration.GetSection("EmailSettings").Get<EmailSettings>()!;
         }
@@ -41,6 +48,51 @@ namespace WorkFlowCheck.BL.Services
 
             return true;
         }
+        public async Task<bool> SendFCMTokenAsync(string token)
+        {
+            var retVal = true;
+            try
+            {
+                if (string.IsNullOrEmpty(token))
+                {
+                    var FCMToken = new FCMToken()
+                    {
+                        Token = token
+                    };
+                    await _dbContext.FCMTokens.AddAsync(FCMToken);
+                    await _dbContext.SaveChangesAsync();
+                }
+            }
+            catch (Exception ex)
+            {
+                retVal = false;
+                Log.ForContext("TAG", "BusinessFlow").Error(ex.Message);
+            }
+
+            return retVal;
+        }
+        public async Task<string> GetLastFCMTokensAsync()
+        {
+            var retVal = "";
+            try
+            {
+                var FCMToken = await _dbContext.FCMTokens
+                                        .AsNoTracking()
+                                        .OrderByDescending(x => x.CreatedAt)
+                                        .Take(1)
+                                        .FirstOrDefaultAsync();
+                if (FCMToken != null && !string.IsNullOrEmpty(FCMToken.Token))
+                {
+                    retVal += FCMToken.Token;
+                }
+            }
+            catch (Exception ex)
+            {
+                retVal = "";
+                Log.ForContext("TAG", "BusinessFlow").Error(ex.Message);
+            }
+            return retVal;
+        }
     }
 
 }

src/WorkFlowCheck.Common/DTO/FCMMessageDTO.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WorkFlowCheck.Common.DTO
+{
+    public class FCMMessageDTO
+
+    {
+        public string? Token { get; set; }
+        public string? Body { get; set; }
+        public string? Title { get; set; }
+        public int? UserId { get; set; }    
+    }
+}

src/WorkFlowCheck.DL/AppDbContext.cs

@@ -27,6 +27,7 @@ namespace WorkFlowCheck.DL
         public DbSet<Entities.CheckPoint> CheckPoints { get; set; } = null!;
         public DbSet<DeviceMessage> DeviceMessages { get; set; } = null!;   
         public DbSet<Entities.Equipment> Equipments { get; set; } = null!;
+        public DbSet<Entities.FCMToken> FCMTokens { get; set; } = null!;
         public DbSet<Entities.Location> Locations { get; set; } = null!;
         public DbSet<Entities.NumberGeneratorTemplate> NumberGeneratorTemplates { get; set; } = null!;
         public DbSet<Entities.NumberGeneratorTemplateDate> NumberGeneratorTemplateDates { get; set; } = null!;
@@ -48,6 +49,7 @@ namespace WorkFlowCheck.DL
             modelBuilder.ApplyConfiguration(new CheckPointTypeConfiguration());
             modelBuilder.ApplyConfiguration(new DeviceMessageTypeConfiguration());
             modelBuilder.ApplyConfiguration(new EquipmentTypeConfiguration());
+            modelBuilder.ApplyConfiguration(new FCMTokenTypeConfiguration());
             modelBuilder.ApplyConfiguration(new LocationTypeConfiguration());
             modelBuilder.ApplyConfiguration(new NumberGeneratorTypeConfiguration());
             modelBuilder.ApplyConfiguration(new NumberGeneratorDateTypeConfiguration());

src/WorkFlowCheck.DL/Configurations/FCMTokenTypeConfiguration.cs

@@ -0,0 +1,21 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace WorkFlowCheck.DL.Configurations
+{
+    public class FCMTokenTypeConfiguration : IEntityTypeConfiguration<Entities.FCMToken>
+    {
+        public void Configure(EntityTypeBuilder<Entities.FCMToken> builder)
+        {
+            builder.ToTable("FCMToken");
+            builder.HasKey(e => e.Id);
+            builder.Property(e => e.Id).ValueGeneratedOnAdd();
+        }
+
+    }
+}

src/WorkFlowCheck.DL/Entities/FCMToken.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using WorkFlowCheck.DL.Interfaces;
+
+namespace WorkFlowCheck.DL.Entities
+{
+    public  class FCMToken:ISoftDeletableEntity, IAuditableEntity
+    {
+        public int Id { get; set; }
+        public string Token { get; set; } = null!;
+        public bool IsDeleted { get; set; }
+        public DateTime LastModAt { get; set; }
+        public string LastModBy { get; set; } = null!;
+        public DateTime CreatedAt { get; set; }
+        public string CreatedBy { get; set; } = null!;
+    }
+}

src/WorkFlowCheck.DL/Migrations/20250515123614_Extend021.Designer.cs

@@ -0,0 +1,997 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using WorkFlowCheck.DL;
+
+#nullable disable
+
+namespace WorkFlowCheck.DL.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20250515123614_Extend021")]
+    partial class Extend021
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.12")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.CheckListHeader", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AcceptUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CheckListTemplateHeaderId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CheckStatus")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("DateExecution")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DocumentNumber")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("GuidNumber")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsEditable")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsStorno")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("LastModAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AcceptUserId");
+
+                    b.HasIndex("CheckListTemplateHeaderId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("CheckListHeader", (string)null);
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.CheckListRow", 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>("CheckListHeaderId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CheckListTemplateRowId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("GuidNumber")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("LastModAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhotoFileName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CheckListHeaderId");
+
+                    b.HasIndex("CheckListTemplateRowId");
+
+                    b.ToTable("CheckListRow", (string)null);
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.CheckListTemplateHeader", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("LastModAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("NumberGenerator1Id")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("NumberGenerator2Id")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NumberGenerator1Id");
+
+                    b.HasIndex("NumberGenerator2Id");
+
+                    b.ToTable("CheckListTemplateHeader", (string)null);
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.CheckListTemplateRow", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AnswerType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("CheckListTemplateHeaderId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CheckPointId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("LastModAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OperationDescription")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("RowIndex")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CheckListTemplateHeaderId");
+
+                    b.HasIndex("CheckPointId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.ToTable("CheckListTemplateRow", (string)null);
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.CheckPoint", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("LastModAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CheckPoint", (string)null);
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.DeviceMessage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("DeviceIdFrom")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeviceIdTo")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ExtraDataJSON")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsReaded")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ReceiveDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("SendDate")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeviceIdTo")
+                        .HasDatabaseName("IX_DeviceMessage_DeviceIdTo");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("DeviceMessage", (string)null);
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.Equipment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("EquipmentNumber")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("LastModAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Equipment", (string)null);
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.FCMToken", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("LastModAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("FCMToken", (string)null);
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.Location", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FullName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("LastModAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Location", (string)null);
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.NumberGeneratorTemplate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("CurrentNumber")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DigitFormat")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("GenerateType")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LastGeneratedNumber")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Prefix")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PrefixSeparator")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Suffix")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SuffixSeparator")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("NumberGeneratorTemplate", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CurrentNumber = 0,
+                            DigitFormat = "D4",
+                            GenerateType = 0,
+                            LastGeneratedNumber = "",
+                            Prefix = "CHK",
+                            PrefixSeparator = "-",
+                            ShortName = "Ellenőrzési dokumentum sorszámozása",
+                            Suffix = "",
+                            SuffixSeparator = "-"
+                        });
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.NumberGeneratorTemplateDate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("CurrentNumber")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LastGeneratedNumber")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("Month")
+                        .HasColumnType("int");
+
+                    b.Property<int>("NumberGeneratorTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NumberGeneratorTemplateId");
+
+                    b.ToTable("NumberGeneratorTemplateDate", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CurrentNumber = 0,
+                            LastGeneratedNumber = "",
+                            Month = 0,
+                            NumberGeneratorTemplateId = 1,
+                            Year = 1
+                        });
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.Role", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("CanDownloadAPK")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("CanEnableBlocked")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("CanUseMobilApp")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("CanUseWebAdmin")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsAdmin")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("LastModAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("ParentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RoleName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("Roles", (string)null);
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.RoleCheckListTemplateHeader", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("CheckListTemplateHeaderId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CheckListTemplateHeaderId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("RoleCheckListTemplateHeader", (string)null);
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.RoleCheckPoint", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("CheckPointId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CheckPointId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("RoleCheckPoint", (string)null);
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("Active")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("JwtToken")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LastModAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("NFCActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("NFCCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Token2FA")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Active = true,
+                            CreatedAt = new DateTime(2025, 5, 15, 12, 36, 12, 645, DateTimeKind.Utc).AddTicks(5079),
+                            CreatedBy = "System",
+                            Email = "admin@nuvolar.hu",
+                            FirstName = "Administrator",
+                            IsDeleted = false,
+                            JwtToken = "",
+                            LastModAt = new DateTime(2025, 5, 15, 12, 36, 12, 645, DateTimeKind.Utc).AddTicks(5082),
+                            LastModBy = "System",
+                            LastName = "System",
+                            NFCActive = true,
+                            NFCCode = "00000000",
+                            PasswordHash = "eGM0NUREZnJ0ISFFRDIxMKE5TYwthDBuUsTUEO1fBnCR3VdSCmdz47ue0RoVvnkY",
+                            Token2FA = "",
+                            UserName = "admin"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Active = true,
+                            CreatedAt = new DateTime(2025, 5, 15, 12, 36, 12, 656, DateTimeKind.Utc).AddTicks(8830),
+                            CreatedBy = "System",
+                            Email = "user@nuvolar.hu",
+                            FirstName = "User",
+                            IsDeleted = false,
+                            JwtToken = "",
+                            LastModAt = new DateTime(2025, 5, 15, 12, 36, 12, 656, DateTimeKind.Utc).AddTicks(8834),
+                            LastModBy = "System",
+                            LastName = "System",
+                            NFCActive = true,
+                            NFCCode = "00000000",
+                            PasswordHash = "eGM0NUREZnJ0ISFFRDIxMPwM2D9sQSj7zmaSBIsOGe0I9hBFwCGPVbyrYMA5EnKG",
+                            Token2FA = "",
+                            UserName = "user"
+                        });
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.UserRole", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("RoleId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.CheckListHeader", b =>
+                {
+                    b.HasOne("WorkFlowCheck.DL.Entities.User", "AcceptUser")
+                        .WithMany()
+                        .HasForeignKey("AcceptUserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("WorkFlowCheck.DL.Entities.CheckListTemplateHeader", "CheckListTemplateHeader")
+                        .WithMany()
+                        .HasForeignKey("CheckListTemplateHeaderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("WorkFlowCheck.DL.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AcceptUser");
+
+                    b.Navigation("CheckListTemplateHeader");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.CheckListRow", b =>
+                {
+                    b.HasOne("WorkFlowCheck.DL.Entities.CheckListHeader", "CheckListHeader")
+                        .WithMany("CheckListRows")
+                        .HasForeignKey("CheckListHeaderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("WorkFlowCheck.DL.Entities.CheckListTemplateRow", "CheckListTemplateRow")
+                        .WithMany()
+                        .HasForeignKey("CheckListTemplateRowId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CheckListHeader");
+
+                    b.Navigation("CheckListTemplateRow");
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.CheckListTemplateHeader", b =>
+                {
+                    b.HasOne("WorkFlowCheck.DL.Entities.NumberGeneratorTemplate", "NumberGenerator1")
+                        .WithMany()
+                        .HasForeignKey("NumberGenerator1Id");
+
+                    b.HasOne("WorkFlowCheck.DL.Entities.NumberGeneratorTemplate", "NumberGenerator2")
+                        .WithMany()
+                        .HasForeignKey("NumberGenerator2Id");
+
+                    b.Navigation("NumberGenerator1");
+
+                    b.Navigation("NumberGenerator2");
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.CheckListTemplateRow", b =>
+                {
+                    b.HasOne("WorkFlowCheck.DL.Entities.CheckListTemplateHeader", "CheckListTemplateHeader")
+                        .WithMany("CheckListTemplateRows")
+                        .HasForeignKey("CheckListTemplateHeaderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("WorkFlowCheck.DL.Entities.CheckPoint", "CheckPoint")
+                        .WithMany("CheckListTemplateRows")
+                        .HasForeignKey("CheckPointId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("WorkFlowCheck.DL.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CheckListTemplateHeader");
+
+                    b.Navigation("CheckPoint");
+
+                    b.Navigation("Equipment");
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.DeviceMessage", b =>
+                {
+                    b.HasOne("WorkFlowCheck.DL.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId");
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.NumberGeneratorTemplateDate", b =>
+                {
+                    b.HasOne("WorkFlowCheck.DL.Entities.NumberGeneratorTemplate", "NumberGeneratorTemplate")
+                        .WithMany("NumberGeneratorTemplateDates")
+                        .HasForeignKey("NumberGeneratorTemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("NumberGeneratorTemplate");
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.Role", b =>
+                {
+                    b.HasOne("WorkFlowCheck.DL.Entities.Role", "Parent")
+                        .WithMany("Children")
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.RoleCheckListTemplateHeader", b =>
+                {
+                    b.HasOne("WorkFlowCheck.DL.Entities.CheckListTemplateHeader", "CheckListTemplateHeader")
+                        .WithMany()
+                        .HasForeignKey("CheckListTemplateHeaderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("WorkFlowCheck.DL.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CheckListTemplateHeader");
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.RoleCheckPoint", b =>
+                {
+                    b.HasOne("WorkFlowCheck.DL.Entities.CheckPoint", "CheckPoint")
+                        .WithMany()
+                        .HasForeignKey("CheckPointId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("WorkFlowCheck.DL.Entities.Role", "Role")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CheckPoint");
+
+                    b.Navigation("Role");
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.UserRole", b =>
+                {
+                    b.HasOne("WorkFlowCheck.DL.Entities.Role", "Role")
+                        .WithMany("UserRoles")
+                        .HasForeignKey("RoleId");
+
+                    b.HasOne("WorkFlowCheck.DL.Entities.User", "User")
+                        .WithMany("UserRoles")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.CheckListHeader", b =>
+                {
+                    b.Navigation("CheckListRows");
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.CheckListTemplateHeader", b =>
+                {
+                    b.Navigation("CheckListTemplateRows");
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.CheckPoint", b =>
+                {
+                    b.Navigation("CheckListTemplateRows");
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.NumberGeneratorTemplate", b =>
+                {
+                    b.Navigation("NumberGeneratorTemplateDates");
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.Role", b =>
+                {
+                    b.Navigation("Children");
+
+                    b.Navigation("UserRoles");
+                });
+
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.User", b =>
+                {
+                    b.Navigation("UserRoles");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/WorkFlowCheck.DL/Migrations/20250515123614_Extend021.cs

@@ -0,0 +1,68 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace WorkFlowCheck.DL.Migrations
+{
+    /// <inheritdoc />
+    public partial class Extend021 : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "FCMToken",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    Token = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    IsDeleted = table.Column<bool>(type: "bit", nullable: false),
+                    LastModAt = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    LastModBy = table.Column<string>(type: "nvarchar(max)", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    CreatedBy = table.Column<string>(type: "nvarchar(max)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_FCMToken", x => x.Id);
+                });
+
+            migrationBuilder.UpdateData(
+                table: "Users",
+                keyColumn: "Id",
+                keyValue: 1,
+                columns: new[] { "CreatedAt", "LastModAt" },
+                values: new object[] { new DateTime(2025, 5, 15, 12, 36, 12, 645, DateTimeKind.Utc).AddTicks(5079), new DateTime(2025, 5, 15, 12, 36, 12, 645, DateTimeKind.Utc).AddTicks(5082) });
+
+            migrationBuilder.UpdateData(
+                table: "Users",
+                keyColumn: "Id",
+                keyValue: 2,
+                columns: new[] { "CreatedAt", "LastModAt" },
+                values: new object[] { new DateTime(2025, 5, 15, 12, 36, 12, 656, DateTimeKind.Utc).AddTicks(8830), new DateTime(2025, 5, 15, 12, 36, 12, 656, DateTimeKind.Utc).AddTicks(8834) });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "FCMToken");
+
+            migrationBuilder.UpdateData(
+                table: "Users",
+                keyColumn: "Id",
+                keyValue: 1,
+                columns: new[] { "CreatedAt", "LastModAt" },
+                values: new object[] { new DateTime(2025, 4, 10, 9, 50, 12, 488, DateTimeKind.Utc).AddTicks(1377), new DateTime(2025, 4, 10, 9, 50, 12, 488, DateTimeKind.Utc).AddTicks(1382) });
+
+            migrationBuilder.UpdateData(
+                table: "Users",
+                keyColumn: "Id",
+                keyValue: 2,
+                columns: new[] { "CreatedAt", "LastModAt" },
+                values: new object[] { new DateTime(2025, 4, 10, 9, 50, 12, 499, DateTimeKind.Utc).AddTicks(4095), new DateTime(2025, 4, 10, 9, 50, 12, 499, DateTimeKind.Utc).AddTicks(4096) });
+        }
+    }
+}

src/WorkFlowCheck.DL/Migrations/AppDbContextModelSnapshot.cs

@@ -377,6 +377,40 @@ namespace WorkFlowCheck.DL.Migrations
                     b.ToTable("Equipment", (string)null);
                 });
 
+            modelBuilder.Entity("WorkFlowCheck.DL.Entities.FCMToken", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("LastModAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastModBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("FCMToken", (string)null);
+                });
+
             modelBuilder.Entity("WorkFlowCheck.DL.Entities.Location", b =>
                 {
                     b.Property<int>("Id")
@@ -692,13 +726,13 @@ namespace WorkFlowCheck.DL.Migrations
                         {
                             Id = 1,
                             Active = true,
-                            CreatedAt = new DateTime(2025, 4, 10, 9, 50, 12, 488, DateTimeKind.Utc).AddTicks(1377),
+                            CreatedAt = new DateTime(2025, 5, 15, 12, 36, 12, 645, DateTimeKind.Utc).AddTicks(5079),
                             CreatedBy = "System",
                             Email = "admin@nuvolar.hu",
                             FirstName = "Administrator",
                             IsDeleted = false,
                             JwtToken = "",
-                            LastModAt = new DateTime(2025, 4, 10, 9, 50, 12, 488, DateTimeKind.Utc).AddTicks(1382),
+                            LastModAt = new DateTime(2025, 5, 15, 12, 36, 12, 645, DateTimeKind.Utc).AddTicks(5082),
                             LastModBy = "System",
                             LastName = "System",
                             NFCActive = true,
@@ -711,13 +745,13 @@ namespace WorkFlowCheck.DL.Migrations
                         {
                             Id = 2,
                             Active = true,
-                            CreatedAt = new DateTime(2025, 4, 10, 9, 50, 12, 499, DateTimeKind.Utc).AddTicks(4095),
+                            CreatedAt = new DateTime(2025, 5, 15, 12, 36, 12, 656, DateTimeKind.Utc).AddTicks(8830),
                             CreatedBy = "System",
                             Email = "user@nuvolar.hu",
                             FirstName = "User",
                             IsDeleted = false,
                             JwtToken = "",
-                            LastModAt = new DateTime(2025, 4, 10, 9, 50, 12, 499, DateTimeKind.Utc).AddTicks(4096),
+                            LastModAt = new DateTime(2025, 5, 15, 12, 36, 12, 656, DateTimeKind.Utc).AddTicks(8834),
                             LastModBy = "System",
                             LastName = "System",
                             NFCActive = true,

src/WorkFlowCheck.Web/Helpers/SystemHelper.cs

@@ -7,7 +7,7 @@ namespace WorkFlowCheck.Web.Helpers
     public static class SystemHelper
     {
         public static string DatabaseName = "";
-        public static string ProgramVersion = "v1.1.019";
+        public static string ProgramVersion = "v1.1.022";
 
         public async static Task GetAPIInfoAsync(IConfiguration configuration)
         {

src/WorkFlowCheck.Web/Pages/CheckListTemplate/CheckListTemplateHeader/CheckListTemplateHeaderPage.cshtml

@@ -47,7 +47,7 @@
                     { data: "shortName" },
                     { data: "description" },
                     { data: null, render: function (data, type, row) {
-                         return renderActionButtons(row.id);
+                         return renderActionButtonsforCheckListTemplateHeader(row.id);
                     }}
                 ],
                 columnDefs: [
@@ -68,16 +68,59 @@
 
         $('#newCheckListTemplateHeaderBtn').on('click', function ()
         {
-            console.log('New button clicked!"');
             window.location.href = `@Url.Page("./CheckListTemplateHeaderEditPage")?id=0`;
         });
         
+
         $('#tbCheckListTemplateHeadersPage').on('click', '.edit-btn', function ()
         {
             const row = table.row($(this).closest('tr')).data();
             window.location.href = `@Url.Page("./CheckListTemplateHeaderEditPage")?id=${row.id}`;
         });
         
+        $('#tbCheckListTemplateHeadersPage').on('click', '.clone-btn', function ()
+        {
+            const row = table.row($(this).closest('tr')).data();
+            const url = './CheckListTemplateHeaderPage?handler=CloneCheckListTemplateHeader';
+                showConfirmModal({
+                    title: 'Klónozás megerősítése',
+                    message: 'Biztosan klónozni szeretnéd ezt az elemet?',
+                    okText: 'Klónozás',
+                    cancelText: 'Mégsem'
+                }).then(function (result) {
+                    if (result === 'ok') {
+                        $.ajax({
+                            url: url,
+                            type: 'GET',
+                            data: { id: row.id },
+                            success: function (data) {
+                                if (data) {
+                                    showMessageModal({
+                                        title: 'Információ',
+                                        message: 'A klónozás sikerült!',
+                                        okText: 'Értettem'
+                                    });
+                                    table.ajax.reload();
+                                } else {
+                                    showMessageModal({
+                                        title: 'Hiba!',
+                                        message: 'A klónozás NEM sikerült!',
+                                        okText: 'Értettem'
+                                    });
+                                }
+                            },
+                            error: function (xhr, status, error) {
+                                showMessageModal({
+                                    title: 'Hiba!',
+                                    message: 'A klónozás NEM sikerült!',
+                                    okText: 'Értettem'
+                                });
+                            }
+                        });
+                    }
+                });
+        });
+
         $('#tbCheckListTemplateHeadersPage').on('click', '.delete-btn', function ()
         {
             const row = table.row($(this).closest('tr')).data();

src/WorkFlowCheck.Web/Pages/CheckListTemplate/CheckListTemplateHeader/CheckListTemplateHeaderPage.cshtml.cs

@@ -27,5 +27,10 @@ namespace WorkFlowCheck.Web.Pages.CheckListTemplate.CheckListTemplateHeader
             var isSuccess = await _checkListService.DeleteCheckListTemplateHeader(id);    
             return new JsonResult(new { result = isSuccess });
         }
+        public async Task<JsonResult> OnGetCloneCheckListTemplateHeader(int id)
+        {
+            var isSuccess = await _checkListService.CloneCheckListTemplateHeader(id);
+            return new JsonResult(new { result = isSuccess });
+        }
     }
 }

src/WorkFlowCheck.Web/Pages/Privacy.cshtml

@@ -1,8 +1,32 @@
 @page
 @model PrivacyModel
 @{
-    ViewData["Title"] = "Privacy Policy";
+    ViewData["Title"] = "Adatvédelmi tájékoztató";
 }
 <h1>@ViewData["Title"]</h1>
 
-<p>Use this page to detail your site's privacy policy.</p>
+<p>Ez az adatvédelmi tájékoztató bemutatja, hogy az oldal hogyan kezeli a felhasználók személyes adatait.</p>
+
+<h2>Gyűjtött adatok</h2>
+<ul>
+    <li>Felhasználó neve</li>
+    <li>Felhasználó e-mail címe</li>
+    <li>Bejelentkezési azonosító (JWT token a böngésző cookie-jában tárolva)</li>
+</ul>
+
+<h2>Adatok felhasználása</h2>
+<p>Az adatokat kizárólag a felhasználói fiók azonosítására és a szolgáltatás használatának biztosítására használjuk fel. Az e-mail címet például a fiók kezelésére, valamint a bejelentkezéshez és az azonosításhoz használjuk.</p>
+
+<h2>Adatok megőrzése</h2>
+<p>A személyes adatokat a fiók fennállásáig, illetve a törlési kérelem beérkezéséig tároljuk. A JWT token a cookie-ban tárolódik, és annak érvényességi ideje alatt használatos.</p>
+
+<h2>Adatok továbbítása</h2>
+<p>Az adatokat harmadik fél számára nem adjuk át, kivéve jogszabályi kötelezettség esetén.</p>
+
+<h2>Cookie-k</h2>
+<p>Oldalunk cookie-kat használ a bejelentkezési állapot megőrzése érdekében (JWT token). Ezek szükségesek a szolgáltatás megfelelő működéséhez. A cookie a böngésző bezárása után vagy a lejárati idő eltelte után automatikusan érvénytelenné válik.</p>
+
+<h2>Felhasználói jogok</h2>
+<p>A felhasználóknak joguk van tájékoztatást kérni a kezelt adataikról, kérhetik azok helyesbítését vagy törlését, valamint tiltakozhatnak az adatkezelés ellen a jogszabályi keretek között.</p>
+
+<p>Amennyiben kérdése van az adatkezeléssel kapcsolatban, kérjük, vegye fel velünk a kapcsolatot.</p>

src/WorkFlowCheck.Web/Pages/Shared/_Layout.cshtml

@@ -67,9 +67,7 @@
                                 <li><a class="dropdown-item" asp-area="" asp-page="/UserAndRole/RoleCheckPointsPage">Szabályok - Ellenőrzési pontok</a></li>
                             </ul>
                         </li>
-                        <li class="nav-item">
+                        
-                            <a class="nav-link text-dark" asp-area="" asp-page="/Privacy">Privacy</a>
-                        </li>
                     </ul>
                     <ul class="navbar-nav">
                         <li class="nav-item dropdown">
@@ -87,6 +85,10 @@
                                         Jelszó módosítása
                                     </a>
                                 </li>
+                                <li><hr class="dropdown-divider"></li> <!-- EZ AZ ELVÁLASZTÓ VONAL -->
+                                <li class="dropdown-item">
+                                    <a class="nav-link text-dark" asp-area="" asp-page="/Privacy">Adatvédelmi tájékoztatás</a>
+                                </li>
                             </ul>
                         </li>
 
@@ -182,7 +184,7 @@
 
     <footer class="border-top footer text-muted">
         <div class="container">
-            &copy; @(DateTime.Now.Year) - Workflow Check App - Version @(SystemHelper.ProgramVersion) (@(SystemHelper.DatabaseName))<a asp-area="" asp-page="/Privacy">Privacy</a>
+            &copy; @(DateTime.Now.Year) - Workflow Check App - Version @(SystemHelper.ProgramVersion) (@(SystemHelper.DatabaseName))<a asp-area="" asp-page="/Privacy"> Adatvédelmi tájékoztatás</a>
         </div>
     </footer>
 

src/WorkFlowCheck.Web/Services/CheckListService.cs

@@ -264,6 +264,27 @@ namespace WorkFlowCheck.Web.Services
             }
             return retVal;
         }
+        public async Task<bool> CloneCheckListTemplateHeader(int id)
+        {
+            string endpoint = $"{_httpClient.BaseAddress}api/CheckList/CloneCheckListTemplateHeader/{id}";
+            var retVal = false;
+            try
+            {
+                var response = await _httpClient.GetFromJsonAsync<ApiResponseDTO<bool>>(endpoint);
+                if (response != null)
+                {
+                    if (response.IsSuccess)
+                    {
+                        return response.Data;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex.Message);
+            }
+            return retVal;
+        }
 
 
         public async Task<CheckListTemplateRowDTO> GetCheckListTemplateRow(int id)

src/WorkFlowCheck.Web/Services/Interfaces/ICheckListService.cs

@@ -19,9 +19,11 @@ namespace WorkFlowCheck.Web.Services.Interfaces
         Task<List<CheckListTemplateHeaderDTO>> GetAllCheckListTemplateHeaderAsync();
         Task<ApiResponseDTO<CheckListTemplateHeaderDTO>> UpdateCheckListTemplateHeader(CheckListTemplateHeaderDTO checkListTemplateHeaderDTO);
         Task<bool> DeleteCheckListTemplateHeader(int id);
+        Task<bool> CloneCheckListTemplateHeader(int id);
 
         Task<CheckListTemplateRowDTO> GetCheckListTemplateRow(int id);
         Task<bool> DeleteCheckListTemplateRow(int id);
+
         Task<ApiResponseDTO<CheckListTemplateRowDTO>> UpdateCheckListTemplateRow(CheckListTemplateRowDTO checkListTemplateRowDTO);
 
 

src/WorkFlowCheck.Web/wwwroot/js/site.js

@@ -232,6 +232,19 @@ function renderActionButtonsforCheckListHeader(data, rowId) {
         //</button>`;
 
 }
+function renderActionButtonsforCheckListTemplateHeader(rowId) {
+    return `
+        <button class="btn btn-primary edit-btn btn-sm" data-id="${rowId}">
+            <i class="bi bi-pencil-fill"></i>
+        </button>
+        <button class="btn btn-danger delete-btn btn-sm" data-id="${rowId}">
+            <i class="bi bi-trash-fill"></i>
+        </button>
+        <button class="btn btn-primary clone-btn btn-sm" data-id="${rowId}">
+            <i class="bi bi bi-copy"></i>
+        </button>
+    `;
+}
 
 function renderCheckStatus(data) {
     //Open = 0,