.NET (Core and Framework)

I have created tables using ASP.NET Core Identity. I need to refer my `AspNetUser` table to my `Job` table. I have created a `CustomIdentity` class which inherits from `IdentityUser`.

This is my code:

    using Microsoft.AspNetCore.Identity;

    namespace InventoryManagement.Models
    {
        public class CustomIdentity :IdentityUser
        {
            public string  IsEngineer { get; set; }
            public string  authpassword { get; set; }
        }
    }

And this is my `DbContext` class for `IdentityDbContext`:

    using Microsoft.AspNetCore.Identity;
    using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
    using Microsoft.EntityFrameworkCore;

    namespace InventoryManagement.Models.Data
    {
        public class AuthDbContext : IdentityDbContext<CustomIdentity>
        {
            public AuthDbContext(DbContextOptions<AuthDbContext> options) :base(options)
            {
            }
        }
    }

`ASPNETUser` table got created and I am able to insert values into it using `UserManager` to register users. I need to refer this user in my Job table. And here is my code for `Jobdbcontext` where I declare all my other tables:

    using Microsoft.EntityFrameworkCore;

    namespace InventoryManagement.Models.Data
    {
        public class JobDBcontext : DbContext
        {
           public JobDBcontext(DbContextOptions<JobDBcontext> options) : base(options) 
           {
           }

           public DbSet<Job> Jobs { get; set; }
           public DbSet<Customer> Customers { get; set; }
           public DbSet<JobType> Jobtype { get; set; }
           public DbSet<ManufacturingBay> Manufacturingbay { get; set; }
           public DbSet<ProjectCategory> Projectcategory { get; set; }
           public DbSet<Currency> Currency { get; set; }
           public DbSet<Category> ItemCategory { get; set; }
           public DbSet<Budget> ItemBudget { get; set; }
           public DbSet<SubCategory> ItemSubcategory { get; set; }
           public DbSet<ItemMaster> ItemMaster { get; set; }
           public DbSet<Bom> Bom { get; set; }
           public DbSet<Test> Test { get; set; }
           public DbSet<UOM> UomMaster { get; set; }
           public DbSet<PR> PR { get; set; }
           public DbSet<PRDetails> PRDetails { get; set; }
           public DbSet<Supplier> Supplier { get; set; }
           public DbSet<Purchase> Purchase { get; set; }
           public DbSet<PurchaseDetails> PurchaseDetails { get; set; }

           protected override void OnModelCreating(ModelBuilder modelBuilder)
           {
                if (modelBuilder == null)
                {
                    throw new ArgumentNullException(nameof(modelBuilder));
                }

                modelBuilder.Entity<JobType>().HasKey(jt => jt.Jobtypeid);
                modelBuilder.Entity<ProjectCategory>().HasKey(jt => jt.Pid);
                modelBuilder.Entity<Currency>().HasKey(jt => jt.cid);
                modelBuilder.Entity<Bom>().HasKey(jt => jt.BID);

                modelBuilder.Entity<Budget>()
                            .HasKey(b => b.ID);

                modelBuilder.Entity<Category>()
                    .HasKey(c => c.CategoryId);
                modelBuilder.Entity<SubCategory>()
                    .HasKey(s => s.SubCategoryId);
                 modelBuilder.Entity<ItemMaster>()
                    .HasKey(i => i.itemid);
                modelBuilder.Entity<UOM>()
                  .HasKey(i => i.uid);
                // Configure relationships
                modelBuilder.Entity<Budget>()
              .HasMany(b => b.categories)
              .WithOne(c => c.Budget)
              .OnDelete(DeleteBehavior.Cascade);
                modelBuilder.Entity<Category>()
                    .HasMany(c => c.SubCategories)
                    .WithOne(i => i.category)
                     .OnDelete(DeleteBehavior.Cascade);

                //  modelBuilder.Entity<SubCategory>()
                //      .HasMany(s => s.ItemMasters)
                //      .WithOne(i => i.subcategory)
                //      .HasForeignKey(i => i.category)
                //      .OnDelete(DeleteBehavior.Cascade);

                // Other configurations for your entity can go here

                //modelBuilder.Entity<PR>()
                //              .HasKey(p => p.Prid);

                //modelBuilder.Entity<PRDetails>()
                //    .HasKey(d => d.Prtblid);

                //modelBuilder.Entity<PRDetails>()
                //    .Property(d => d.Prid);  // Ensure Prid property is properly configured, adjust as needed

                //modelBuilder.Entity<PRDetails>()
                //    .HasOne(d => d.PR)
                //    .WithMany(p => p.PRDetails)
                //    .HasForeignKey(d => d.Prid)
                //    .OnDelete(DeleteBehavior.Restrict); // or specify other actions as needed

                // Additional configurations for other entities and relationships

                modelBuilder.Entity<PR>()
                  .HasKey(p => p.Prid);

                modelBuilder.Entity<PRDetails>()
                    .HasKey(d => d.PrDetailId);

                modelBuilder.Entity<PRDetails>()
                    .HasOne(d => d.PR)
                    .WithMany(p => p.PRDetails)
                    .HasForeignKey(d => d.Prid)
                    .OnDelete(DeleteBehavior.NoAction); // Change this to NoAction or other options

                modelBuilder.Entity<PRDetails>()
                    .HasOne(d => d.Bom)
                    .WithMany() // Assuming Bom doesn't have a navigation property back to PRDetails
                    .HasForeignKey(d => d.Bomid)
                    .OnDelete(DeleteBehavior.Cascade);

                base.OnModelCreating(modelBuilder);

                modelBuilder.Entity<Purchase>()
                 .HasKey(p => p.POID);

                modelBuilder.Entity<PurchaseDetails>()
                    .HasKey(d => d.potblid);

                modelBuilder.Entity<PurchaseDetails>()
                    .HasOne(d => d.Purchase)
                    .WithMany(p => p.PurchaseDetails)
                    .HasForeignKey(d => d.POID)
                    .OnDelete(DeleteBehavior.NoAction); // Change this to NoAction or other options

                modelBuilder.Entity<PurchaseDetails>()
                    .HasOne(d => d.prdetails)
                    .WithMany() // Assuming Bom doesn't have a navigation property back to PRDetails
                    .HasForeignKey(d => d.PrDetailId)
                    .OnDelete(DeleteBehavior.Cascade);
                base.OnModelCreating(modelBuilder);
                modelBuilder.Entity<Job>()
               .HasOne(j => j.User)
               .WithMany()
               .HasForeignKey(j => j.UserId)
               .IsRequired();
            }
        }
    }

This is my `Job` model where I am referencing my CustomIdentity.

    namespace InventoryManagement.Models
    {
        public class Job
        {
            public int Jobsequenceno { get; set; }
            public int JobId { get; set; }

            public string JobName { get; set; } 
      
            public int Qty { get; set; }
            public Customer Customer { get; set; }

            public DateTime JobDate { get; set; }
            public JobType JobType { get; set; }

            public ManufacturingBay ManufacturingBay { get; set; }
            public ProjectCategory Projectcategory { get; set; }
            public Currency currency { get; set; }
            public Double JobRate { get; set; }
            public Double Ordervalue { get; set; }
            public Double Ordervalueinbasecurrency { get; set; }

            public string  JobDescription { get; set; }
            public string Paymentterms { get; set; }
            public string Deliveryterms { get; set; }

            public string UserId { get; set; }
            public CustomIdentity User { get; set; }
        }
    }

Upon running migrations of 2 `DbContext` tables are created ..but upon running migration of JobDBcontext another class called customidentity is created which has exactly same column like my ASPNetUser and my job table is referring to that class.

    ALTER TABLE [dbo].[Jobs] WITH CHECK 
        ADD CONSTRAINT [FK_Jobs_CustomIdentity_UserId] 
            FOREIGN KEY([UserId]) REFERENCES [dbo].[CustomIdentity] ([Id])
            ON DELETE CASCADE  

I want the Job  table to refer to the `ASPNETUSER` table which is having value instead of this CustomIdentity table.... I am able to insert user data to Job table.but upon listing job I am referring to `CustomIdentity` which is showing null..

     [HttpGet("List")]
     public async Task<IActionResult> List()
     {
         // use dbContext to read the tags
         var Joblist = await jobdbcontext.Jobs.Include(j => j.Customer).Include(j => j.JobType).Include(j => j.ManufacturingBay).
             Include(j => j.Projectcategory).
              Include(j => j.CustomIdentity).
              Include(j => j.currency).
         Include(j =>j.User).
             ToListAsync();
         return View(Joblist);
     }

How to resolve this?so that my Job table will refer ASPNetUser table which is having value instead of CustomIdentity table.CustomIdentity model is created to add extra columns in my ASPNetUser table.I am new to this ..can anyone help on this ?

Private Sub tmr_Worktimer_Tick(sender As Object, e As EventArgs) Handles tmr_Worktimer.Tick
        If IsKeyPressed(Keys.VK_SHIFT) Then
            Dim aPoint As New POINTAPI
            GetCursorPos(aPoint)
            Dim hWnd As IntPtr = WindowFromPoint(aPoint.x, aPoint.y)
            SetForegroundWindow(hWnd)
            SetWindowTextUnicode(hWnd, WM_SETTEXT, IntPtr.Zero, "Test")
        End If
    End Sub

Public Structure Keys
        Const VK_BACK As Short = &H8  ' Backspace key
        Const VK_TAB As Short = &H9  ' Tab key
        Const VK_RETURN As Short = &HD  ' Enter key
        Const VK_SHIFT As Short = &H10  ' Shift key
        Const VK_CONTROL As Short = &H11  ' STRG key
        Const VK_MENU As Short = &H12  ' Alt key
        Const VK_CAPITAL As Short = &H14  ' Caps Lock
        Const VK_ESCAPE As Short = &H1B  ' Escape
        Const VK_SPACE As Short = &H20  ' Space
        Const VK_PRIOR As Short = &H21  ' PageUp
        Const VK_NEXT As Short = &H22  ' PageDown
End Structure

 <DllImport("user32.dll", SetLastError:=True, CharSet:=CharSet.Auto)>
    Public Function GetAsyncKeyState(ByVal vKey As Int32) As Short
    End Function

 Public Function IsKeyPressed(ByVal KeyToCheck As Short) As Boolean
        Dim res As Short
        res = GetAsyncKeyState(KeyToCheck)
        If res < 0 Then ' -32768 Then
            IsKeyPressed = True
        Else
            IsKeyPressed = False
        End If
    End Function
	
	    <System.Runtime.InteropServices.StructLayout(Runtime.InteropServices.LayoutKind.Sequential)>
    Public Structure POINTAPI
        Dim x As Integer
        Dim y As Integer
    End Structure
	
	    <DllImport("user32.dll", ExactSpelling:=True, SetLastError:=True)>
    Public Function GetCursorPos(ByRef lpPoint As POINTAPI) As <MarshalAs(UnmanagedType.Bool)> Boolean
    End Function
	
	    <DllImport("user32.dll")>
    Public Function WindowFromPoint(xPoint As Integer, yPoint As Integer) As IntPtr
    End Function
	
	    <DllImport("user32.dll")>
    Public Function SetForegroundWindow(hWnd As IntPtr) As Boolean
    End Function
	
	    Friend Const WM_SETTEXT As Integer = 12

    <DllImport("user32.dll", EntryPoint:="SendMessageW", CharSet:=CharSet.Unicode)>
    Public Function SetWindowTextUnicode(ByVal hWnd As IntPtr, ByVal Msg As Integer, ByVal wParam As IntPtr, ByVal lParam As String) As IntPtr
    End Function

Hello everyone,
I have a case with vlc on my ubuntu container. Indeed, my c# method :

<pre lang="C#">if (File.Exists(video.Path))
{
using (var libVLC = new LibVLC(enableDebugLogs: true))
{
this.logger.LogInformation($"ImageDetectionWorker.StartFramesPredictionVLC : VLC lib initialized")

if (Directory.Exists("/shared-volume/vlc" == false))
{
Directory.CreateDirectory("/shared-volume/vlc")
}

libVLC.SetLogFile($"/shared-volume/vlc/vlc.log";)

var absoluteVideoPath = new FileInfo(video.Path.FullName)

using (var media = new Media(libVLC, absoluteVideoPath, options: "--no-audio --no-xlib --no-sout-audio"))
{
this.logger.LogInformation($"ImageDetectionWorker.StartFramesPredictionVLC : VLC media initialized")

using (var mediaPlayer = new MediaPlayer(media))
{
this.logger.LogInformation($"ImageDetectionWorker.StartFramesPredictionVLC : VLC media player initialized")

mediaPlayer.ToggleMute()