datatables / editor-net Goto Github PK

.Field(new Field("InventoryServer.UpdatedByDisplayName")
    .Set(Field.SetType.Create | Field.SetType.Edit) // <--------------------
    .SetValue("TODO"))

var response = new Editor(db, "users")
    .Model<UploadManyModel>()
    .Where("site", "1", "=")

var editor = new Editor(db, "FieldDefinition", "Id")
    .ValidatorAsync(async (editor, action, data) =>
    {
        // ...
        var hasPermission = await policyServerRuntimeClient.HasPermissionAsync(this.User, "WriteInventory");
    })

      .Field(new Field("users.site")
          .Options(new Options()
              .Table("sites")
              .Value("id")
              .Label("name")
          )
      )
      .Field(new Field("sites.name")
          .SearchBuilderOptions(new SearchBuilderOptions()
              .Label("sites.name")
              .Value("sites.name")
              .LeftJoin("sites", "sites.id", "=", "users.site")
          )
      )
    .LeftJoin("sites", "sites.id", "=", "users.site")
    .LeftJoin("user_dept", "users.id", "=", "user_dept.user_id")

// The entire purpose of this validator is to check if the FieldDefinition already exists associated to the same entities
// For example a field definition for Name cannot exist twice both added to InventoryServers
.Validator((editor, action, data) =>
{
    if (action == DtRequest.RequestTypes.DataTablesGet)
    {
        return string.Empty;
    }

    foreach (var pair in data.Data)
    {
        var values = pair.Value as Dictionary<string, object>;

        if (!values.TryGetValue("FieldDefinition", out var fieldDefinitionData))
        {
            // DUPLICATED FIELD VALIDATOR
            return string.Empty;
        }
        else
        {
            if (action is DtRequest.RequestTypes.EditorEdit
                or DtRequest.RequestTypes.EditorCreate)
            {
                var fieldDefinitionDictionary = fieldDefinitionData as Dictionary<string, object>;
                if (!fieldDefinitionDictionary.TryGetValue("Name", out var fieldDefinitionNameData))
                {
                    // DUPLICATED FIELD VALIDATOR
                    // An edit does not have to result in a name change (they didnt send Name field).
                    // A create Name is required, so another validator will catch this
                    return string.Empty;
                }

                var fieldDefinitionName = fieldDefinitionNameData.ToString();
                if (string.IsNullOrWhiteSpace(fieldDefinitionName))
                {
                    // DUPLICATED FIELD VALIDATOR
                    // Field validator will catch it
                    return string.Empty;
                }

                if (!values.TryGetValue("FieldDefinitionEntity", out var entities))
                {
                    // DUPLICATED FIELD VALIDATOR
                    return string.Empty;
                }

                if (action is DtRequest.RequestTypes.EditorEdit)
                {
                    var existingFieldDefinition = context.WuitFieldDefinition
                        .Include(x => x.Entities)
                        .FirstOrDefault(x => x.Id == Convert.ToInt32(pair.Key, CultureInfo.InvariantCulture));
                    if (fieldDefinitionName == existingFieldDefinition.Name)
                    {
                        // Name did not change, no need to check if it exists
                        continue;
                    }
                }

                var entitiesDict = entities as Dictionary<string, object>;
                var entityIds = entitiesDict.Values
                    .Select(x => x as Dictionary<string, object>)
                    .Select(x => (int)x["Id"])
                    .ToArray();

                if (entityIds.Count == 0)
                {
                    // DUPLICATED FIELD VALIDATOR
                    // Field validator for the MJoin below will check that they provided a min of 1
                    return string.Empty;
                }

                var existingRecord = IsFieldDefinitionInUse(fieldDefinitionName, entityIds);

                if (existingRecord is null)
                {
                    return string.Empty;
                }

                return $"Field Definition already exists for field name {fieldDefinitionName} ({existingRecord.Id}) on entities {string.Join(", ", existingRecord.Entities.Select(x => x.Name))}";
            }
        }
    }

    return string.Empty;
})

.Validator((editor, action, data) =>
{
    if (action == DtRequest.RequestTypes.DataTablesGet)
    {
        return string.Empty;
    }

    // Create/Edit can accept multiple records at once
    foreach (var pair in data.Data)
    {
        var values = pair.Value as Dictionary<string, object>;

        if (!values.TryGetValue("FieldDefinition", out var fieldDefinitionData))
        {
            return string.Empty;
        }
        else
        {
            if (action is DtRequest.RequestTypes.EditorEdit or DtRequest.RequestTypes.EditorCreate)
            {
                var fieldDefinitionDictionary = fieldDefinitionData as Dictionary<string, object>;
                var fieldDefinitionName = fieldDefinitionDictionary["Name"].ToString();
                var entities = values["FieldDefinitionEntity"] as Dictionary<string, object>;
                var entityIds = entities.Values
                    .Select(x => x as Dictionary<string, object>)
                    .Select(x => (int)x["Id"])
                    .ToArray();

                var existingFieldDefinition = context.WuitFieldDefinition
                    .Include(x => x.Entities)
                    .FirstOrDefault(x => x.Id == Convert.ToInt32(pair.Key, CultureInfo.InvariantCulture) &&
                    x.Name == fieldDefinitionName);

                if (existingFieldDefinition is not null)
                {
                    // Name did not change, no need for further checks
                    continue;
                }

                var existingRecord = IsFieldDefinitionInUse(fieldDefinitionName, entityIds);
                if (existingRecord is null)
                {
                    return string.Empty;
                }

                return $"Field Definition already exists for field name {fieldDefinitionName} ({existingRecord.Id}) on entities {string.Join(", ", existingRecord.Entities.Select(x => x.Name))}";
            }
        }
    }

    return string.Empty;
})

// ...
  .MJoin(new MJoin("InventoryServerWarranty")
      .Set(false)
      .Link("InventoryServer.Id", "InventoryServerInventoryServerWarrantyLine.InventoryServerId")
      .Link("InventoryServerWarranty.Id", "InventoryServerInventoryServerWarrantyLine.InventoryServerWarrantyId")
      .Order("InventoryServerWarranty.CertificateNumber")
      .Model<Warranty>()
      .LeftJoin("InventoryServerWarrantyProvider", "InventoryServerWarrantyProvider.Id", "=", "InventoryServerWarranty.InventoryServerWarrantyProviderId")
  )
// ...

    /// This example shows a very simple join using the `LeftJoin` method.
    /// Of particular note in this example is that the `JoinModel` defines two
    /// nested classes that obtain the data required from the two tables

using DataTables;

namespace EditorNetCoreDemo.Models
{
    public class JoinModelUsers
    {
        public string first_name { get; set; }

        public string last_name { get; set; }

        public string phone { get; set; }

        public int site { get; set; }

        public int manager { get; set; }
    }

    public class JoinModelSites
    {
        public string name { get; set; }
    }
}

.MJoin(new MJoin("InventoryServerWarranty")
    .Model<InventoryServerWarranty>()
    .Field(new Field("InventoryServerWarrantyProvider.Name"))
    .Field(new Field("InventoryServerWarrantyProvider.Description"))

.Field(new Field("sites.name")
    .SearchBuilderOptions(new SearchBuilderOptions()
        .Value("sites.id")
        .Label("sites.name")
        .LeftJoin("sites", "sites.id", "=", "users.site")
    )
)

.Field(new Field("sites.name")
    .SearchBuilderOptions(new SearchBuilderOptions()
        .Value("sites.id")
        .Label("MAX(sites.name)")
        .LeftJoin("sites", "sites.id", "=", "users.site")
    )
)