About the many to many cascading insertion of sqlsugar (the ID of the collection attribute cannot be obtained, so the intermediate table cannot be maintained)

Find the problem ：

I have nothing to do today , Think of using .Net Core WebApi Write a RBAC Small Demo,
Demo It's simple , Mainly Role and Permission,User and Role Two many to many relationships , It's just 5 About the watch .
Intended use ORM To simplify operations , Therefore, using SqlSugar To help develop . But there seems to be some problems with cascading inserts .

Existing models , And the generated table is as follows

[SugarTable(tableName:"t_permisssion")]
 public class Permission
 {
    
     [SugarColumn(IsPrimaryKey =true,IsIdentity =true)]
     public long Id {
     get; set; }

     [SugarColumn(SerializeDateTimeFormat = "yyyy-mm-dd hh:mm:ss")]
     public DateTime Create_Time {
     get; set; }

     public string Name {
     get; set; }

     public string Desc {
     get; set; }

     public string Type {
     get; set; }

     public string Create_Emp {
     get; set; }

     [Navigate(typeof(Role_Permisssion),nameof(Role_Permisssion.Permission_Id),nameof(Role_Permisssion.Role_Id))]
     public List<Role> roles {
     get; set; }

 }
[SugarTable(tableName:"t_roles")]
public class Role
  {
    
      [SugarColumn(IsPrimaryKey =true,IsIdentity =true)]
      public long Id {
     get; set; }


      public string Name {
     get; set; }

      public string Desc {
     get; set; }

      [SugarColumn(SerializeDateTimeFormat = "yyyy-mm-dd hh:mm:ss")]

      public string Create_Time {
     get; set; }

      public string Create_Emp {
    get;set;}

      
      [Navigate(typeof(Role_Permisssion),nameof(Role_Permisssion.Role_Id),nameof(Role_Permisssion.Permission_Id))]
      public List<Permission> permissions {
     get; set; }
  }
[SugarTable(tableName:"t_role_permission")]
public class Role_Permisssion
{
    
    [SugarColumn(IsPrimaryKey =true)]
    public long Role_Id {
     get; set; }

    [SugarColumn(IsPrimaryKey = true)]
    public long Permission_Id {
     get; set; }
}

Let's write a method to test

 [HttpPost]
        public StandResult<object> Create_Role([FromBody]Role role)
        {
    
            SqlSugar.ISubInsertable<Role> res = scoper.GetTool().ScopedContext.Insertable(role).AddSubList(it => it.permissions);

            int count = (int)res.ExecuteCommand();
            //SqlSugar I don't seem to be able to maintain the intermediate table automatically , Therefore, we should gain self growth by ourselves ID To maintain intermediate tables 
            List<Role_Permisssion> list = new List<Role_Permisssion>();

            role.permissions.ForEach(item =>
            {
    
            	// In the test Role.Id The generated auto increment can be obtained correctly ID, And one of the Permission Autoincrement of set ID But I can't get 
                list.Add(new Role_Permisssion() {
     Role_Id = role.Id, Permission_Id = item.Id });
            });

            scoper.GetTool().Insertable(list).ExecuteCommand();

            if (count >= 1)
                return new StandResult<object>() {
     data = count,Status = 1,Message = " Insert the success "};

            return new StandResult<object>() {
     data = count, Status = 0, Message = " Insert the failure " };
        }

stay swagger Test insert ,（ Parameters here id It's no use , What they actually generate is self increment ）


There is still a problem with this , General ORM The intermediate table should be maintained automatically . Therefore, many to many cascading operation is still very important , After all, it can simplify the development process .

Current alternatives

Of course , The above problems can be avoided , It's just to split the insertion of objects , Respectively to obtain its self increment
The code is as follows ：

 public StandResult<object> Create_Role([FromBody]Role role)
{
    
    var res = scoper.GetTool().ScopedContext.Insertable(role);
	// First insert Role, Get self increasing Id
    long count = res.ExecuteReturnBigIdentity();

    List<Role_Permisssion> list = new List<Role_Permisssion>();
    // Insert again role Medium permission aggregate , Loop insert to get self increment , And maintain a collection of intermediate classes 
    role.permissions.ForEach(item => {
    
        var res2 = scoper.GetTool().ScopedContext.Insertable(item).ExecuteReturnBigIdentity();
        list.Add(new Role_Permisssion() {
     Role_Id = count, Permission_Id = res2 });
    });
    // Finally, insert the collection of intermediate classes 
    scoper.GetTool().Insertable(list).ExecuteCommand();

    if (count >= 1)
        return new StandResult<object>() {
     data = count,Status = 1,Message = " Insert the success "};

    return new StandResult<object>() {
     data = count, Status = 0, Message = " Insert the failure " };
}

The effect is as follows ：

All in all , Want to update cascading inserts , Automatically maintain intermediate tables .