< Summary

Information
Class: LGDXRobotCloud.Data.DbContexts.UtcValueConverter
Assembly: LGDXRobotCloud.Data
File(s): /builds/yukaitung/lgdxrobot2-cloud/LGDXRobotCloud.Data/DbContexts/LgdxContext.cs
Line coverage
100%
Covered lines: 1
Uncovered lines: 0
Coverable lines: 1
Total lines: 225
Line coverage: 100%
Branch coverage
N/A
Covered branches: 0
Total branches: 0
Branch coverage: N/A
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor()100%11100%

File(s)

/builds/yukaitung/lgdxrobot2-cloud/LGDXRobotCloud.Data/DbContexts/LgdxContext.cs

#LineLine coverage
 1using LGDXRobotCloud.Data.Entities;
 2using LGDXRobotCloud.Utilities.Enums;
 3using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
 4using Microsoft.EntityFrameworkCore;
 5using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 6
 7namespace LGDXRobotCloud.Data.DbContexts;
 8
 9public class LgdxContext(DbContextOptions<LgdxContext> options) : IdentityDbContext<LgdxUser, LgdxRole, string>(options)
 10{
 11  // Administration
 12  public virtual DbSet<ApiKey> ApiKeys { get; set; }
 13
 14  // Automation
 15  public virtual DbSet<AutoTask> AutoTasks { get; set; }
 16  public virtual DbSet<AutoTaskDetail> AutoTasksDetail { get; set; }
 17  public virtual DbSet<AutoTaskJourney> AutoTasksJourney { get; set; }
 18  public virtual DbSet<Flow> Flows { get; set; }
 19  public virtual DbSet<FlowDetail> FlowDetails { get; set; }
 20  public virtual DbSet<Progress> Progresses { get; set; }
 21  public virtual DbSet<Trigger> Triggers { get; set; }
 22  public virtual DbSet<TriggerRetry> TriggerRetries { get; set; }
 23
 24  // Navigation
 25  public virtual DbSet<Realm> Realms { get; set; }
 26  public virtual DbSet<Robot> Robots { get; set; }
 27  public virtual DbSet<RobotCertificate> RobotCertificates { get; set; }
 28  public virtual DbSet<RobotChassisInfo> RobotChassisInfos { get; set; }
 29  public virtual DbSet<RobotSystemInfo> RobotSystemInfos { get; set; }
 30  public virtual DbSet<Waypoint> Waypoints { get; set; }
 31  public virtual DbSet<WaypointTraffic> WaypointTraffics { get; set; }
 32
 33  protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
 34  {
 35    configurationBuilder
 36      .Properties<DateTime>()
 37      .HaveConversion(typeof(UtcValueConverter));
 38  }
 39
 40  protected override void OnModelCreating(ModelBuilder modelBuilder)
 41  {
 42    foreach (var relationship in modelBuilder.Model.GetEntityTypes().SelectMany(e => e.GetForeignKeys()))
 43    {
 44      relationship.DeleteBehavior = DeleteBehavior.Restrict;
 45    }
 46
 47    // Automation.AutoTasks
 48    modelBuilder.Entity<AutoTask>()
 49      .HasMany(e => e.AutoTaskDetails)
 50      .WithOne(e => e.AutoTask)
 51      .HasForeignKey(e => e.AutoTaskId)
 52      .OnDelete(DeleteBehavior.Cascade)
 53      .IsRequired();
 54    modelBuilder.Entity<AutoTask>()
 55      .HasOne(e => e.Realm)
 56      .WithMany()
 57      .OnDelete(DeleteBehavior.Cascade)
 58      .IsRequired();
 59    modelBuilder.Entity<AutoTask>()
 60      .HasOne(e => e.AssignedRobot)
 61      .WithMany(e => e.AssignedTasks)
 62      .HasForeignKey(e => e.AssignedRobotId)
 63      .IsRequired(false)
 64      .OnDelete(DeleteBehavior.SetNull);
 65    modelBuilder.Entity<AutoTask>()
 66      .HasOne(e => e.Flow)
 67      .WithMany()
 68      .HasForeignKey(e => e.FlowId)
 69      .IsRequired(false)
 70      .OnDelete(DeleteBehavior.SetNull);
 71    modelBuilder.Entity<AutoTaskDetail>()
 72      .HasOne(e => e.Waypoint)
 73      .WithMany()
 74      .HasForeignKey(e => e.WaypointId)
 75      .OnDelete(DeleteBehavior.SetNull)
 76      .IsRequired(false);
 77    modelBuilder.Entity<AutoTaskJourney>()
 78      .HasOne(e => e.CurrentProgress)
 79      .WithMany()
 80      .HasForeignKey(e => e.CurrentProgressId)
 81      .OnDelete(DeleteBehavior.SetNull)
 82      .IsRequired(false);
 83    // Automation.FlowDetails
 84    modelBuilder.Entity<Flow>()
 85      .HasMany(e => e.FlowDetails)
 86      .WithOne(e => e.Flow)
 87      .HasForeignKey(e => e.FlowId)
 88      .OnDelete(DeleteBehavior.Cascade)
 89      .IsRequired();
 90    // Automation.TriggerRetries
 91    modelBuilder.Entity<TriggerRetry>()
 92      .HasOne(e => e.Trigger)
 93      .WithMany()
 94      .HasForeignKey(e => e.TriggerId)
 95      .IsRequired(true)
 96      .OnDelete(DeleteBehavior.Cascade);
 97    modelBuilder.Entity<TriggerRetry>()
 98      .HasOne(e => e.AutoTask)
 99      .WithMany()
 100      .HasForeignKey(e => e.AutoTaskId)
 101      .IsRequired(true)
 102      .OnDelete(DeleteBehavior.Cascade);
 103    // Automation.Triggers
 104    modelBuilder.Entity<Trigger>()
 105      .HasOne(e => e.ApiKey)
 106      .WithMany()
 107      .HasForeignKey(e => e.ApiKeyId)
 108      .IsRequired(false)
 109      .OnDelete(DeleteBehavior.SetNull);
 110
 111    // Navigation.Robots
 112    modelBuilder.Entity<Robot>()
 113      .HasOne(e => e.RobotSystemInfo)
 114      .WithOne(e => e.Robot)
 115      .HasForeignKey<RobotSystemInfo>(e => e.RobotId)
 116      .IsRequired(false)
 117      .OnDelete(DeleteBehavior.Cascade);
 118    modelBuilder.Entity<Robot>()
 119      .HasOne(e => e.RobotChassisInfo)
 120      .WithOne(e => e.Robot)
 121      .HasForeignKey<RobotChassisInfo>(e => e.RobotId)
 122      .IsRequired(false)
 123      .OnDelete(DeleteBehavior.Cascade);
 124    modelBuilder.Entity<Robot>()
 125      .HasOne(e => e.RobotCertificate)
 126      .WithOne(e => e.Robot)
 127      .HasForeignKey<RobotCertificate>(e => e.RobotId)
 128      .IsRequired()
 129      .OnDelete(DeleteBehavior.Cascade);
 130
 131    modelBuilder.Entity<Realm>().HasData(
 132      new Realm
 133      {
 134        Id = 1,
 135        Name = "First Realm",
 136        Description = "Please update this realm",
 137        Image = [],
 138        Resolution = 0,
 139        OriginX = 0,
 140        OriginY = 0,
 141        OriginRotation = 0,
 142      }
 143    );
 144
 145    modelBuilder.Entity<Progress>().HasData(
 146      new Progress
 147      {
 148        Id = (int)ProgressState.Template,
 149        Name = "Template",
 150        System = true,
 151        Reserved = true
 152      },
 153      new Progress
 154      {
 155        Id = (int)ProgressState.Waiting,
 156        Name = "Waiting",
 157        System = true,
 158        Reserved = true
 159      },
 160      new Progress
 161      {
 162        Id = (int)ProgressState.Completed,
 163        Name = "Completed",
 164        System = true,
 165        Reserved = true
 166      },
 167      new Progress
 168      {
 169        Id = (int)ProgressState.Aborted,
 170        Name = "Aborted",
 171        System = true,
 172        Reserved = true
 173      },
 174      new Progress
 175      {
 176        Id = (int)ProgressState.Starting,
 177        Name = "Starting",
 178        System = true
 179      },
 180      new Progress
 181      {
 182        Id = (int)ProgressState.Loading,
 183        Name = "Loading",
 184        System = true
 185      },
 186      new Progress
 187      {
 188        Id = (int)ProgressState.PreMoving,
 189        Name = "PreMoving",
 190        System = true
 191      },
 192      new Progress
 193      {
 194        Id = (int)ProgressState.Moving,
 195        Name = "Moving",
 196        System = true
 197      },
 198      new Progress
 199      {
 200        Id = (int)ProgressState.Unloading,
 201        Name = "Unloading",
 202        System = true
 203      },
 204      new Progress
 205      {
 206        Id = (int)ProgressState.Completing,
 207        Name = "Completing",
 208        System = true
 209      },
 210      new Progress
 211      {
 212        Id = (int)ProgressState.Reserved,
 213        Name = "Reserved",
 214        System = true,
 215        Reserved = true
 216      }
 217    );
 218    base.OnModelCreating(modelBuilder);
 219  }
 220}
 221
 222class UtcValueConverter : ValueConverter<DateTime, DateTime>
 223{
 12224  public UtcValueConverter() : base(v => v, v => DateTime.SpecifyKind(v, DateTimeKind.Utc)) {}
 225}

Methods/Properties

.ctor()