diff --git a/Src/Asp.NetCore2/SqlSugar/Abstract/InsertableProvider/InsertableProvider.cs b/Src/Asp.NetCore2/SqlSugar/Abstract/InsertableProvider/InsertableProvider.cs index 0058a1973..5a308331e 100644 --- a/Src/Asp.NetCore2/SqlSugar/Abstract/InsertableProvider/InsertableProvider.cs +++ b/Src/Asp.NetCore2/SqlSugar/Abstract/InsertableProvider/InsertableProvider.cs @@ -320,6 +320,7 @@ namespace SqlSugar } public IInsertable IgnoreColumns(Expression> columns) { + if (columns == null) return this; var ignoreColumns = InsertBuilder.GetExpressionValue(columns, ResolveExpressType.ArraySingle).GetResultArray().Select(it => this.SqlBuilder.GetNoTranslationColumnName(it)).ToList(); this.InsertBuilder.DbColumnInfoList = this.InsertBuilder.DbColumnInfoList.Where(it => !ignoreColumns.Any(ig => ig.Equals(it.PropertyName, StringComparison.CurrentCultureIgnoreCase))).ToList(); this.InsertBuilder.DbColumnInfoList = this.InsertBuilder.DbColumnInfoList.Where(it => !ignoreColumns.Any(ig => ig.Equals(it.DbColumnName, StringComparison.CurrentCultureIgnoreCase))).ToList(); @@ -336,6 +337,7 @@ namespace SqlSugar public IInsertable InsertColumns(Expression> columns) { + if (columns == null) return this; var ignoreColumns = InsertBuilder.GetExpressionValue(columns, ResolveExpressType.ArraySingle).GetResultArray().Select(it => this.SqlBuilder.GetNoTranslationColumnName(it)).ToList(); this.InsertBuilder.DbColumnInfoList = this.InsertBuilder.DbColumnInfoList.Where(it => ignoreColumns.Any(ig => ig.Equals(it.PropertyName, StringComparison.CurrentCultureIgnoreCase)) || ignoreColumns.Any(ig => ig.Equals(it.DbColumnName, StringComparison.CurrentCultureIgnoreCase))).ToList(); return this; @@ -343,6 +345,7 @@ namespace SqlSugar public IInsertable InsertColumns(string[] columns) { + if (columns == null) return this; this.InsertBuilder.DbColumnInfoList = this.InsertBuilder.DbColumnInfoList.Where(it => columns.Any(ig => ig.Equals(it.PropertyName, StringComparison.CurrentCultureIgnoreCase))|| columns.Any(ig => ig.Equals(it.DbColumnName, StringComparison.CurrentCultureIgnoreCase))).ToList(); return this; } diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Entities/JsonDeleteResult.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Entities/JsonDeleteResult.cs new file mode 100644 index 000000000..0e2571d55 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Entities/JsonDeleteResult.cs @@ -0,0 +1,11 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public class JsonDeleteResult + { + public int UpdateRows { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Entities/JsonInsertResult.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Entities/JsonInsertResult.cs new file mode 100644 index 000000000..a512c313b --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Entities/JsonInsertResult.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public class JsonInsertResult + { + public int IdentityValue { get; set; } + public int InsertCount { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Entities/JsonQueryResult.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Entities/JsonQueryResult.cs new file mode 100644 index 000000000..093d9033c --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Entities/JsonQueryResult.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public class JsonQueryResult + { + public object Data { get; set; } + public Dictionary TableInfo{get;set;} + public int ToTalRows { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Entities/JsonTableConfig.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Entities/JsonTableConfig.cs new file mode 100644 index 000000000..b03e72a3a --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Entities/JsonTableConfig.cs @@ -0,0 +1,27 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + + public class JsonTableConfig + { + public string TableName { get; set; } + public string TableDescription { get; set; } + public List Conditionals { get; set; } + public bool? AllowQuery { get; set; } + public bool? AllowUpdate { get; set; } + public bool? AllowDelete { get; set; } + public bool? AllowInsert { get; set; } + public List Columns { get; set; } + } + public class JsonColumnConfig + { + public string Name { get; set; } + public string Description { get; set; } + public string ValidateMessage { get; set; } + public object Validate { get; set; } + bool? AllowEdit { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Entities/JsonUpdateResult.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Entities/JsonUpdateResult.cs new file mode 100644 index 000000000..0f52c423a --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Entities/JsonUpdateResult.cs @@ -0,0 +1,11 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public class JsonUpdateResult + { + public int UpdateRows { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Enums/Json2SqlType.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Enums/Json2SqlType.cs new file mode 100644 index 000000000..3529d4821 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Enums/Json2SqlType.cs @@ -0,0 +1,16 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public enum JsonProviderType + { + Queryable, + QueryableCount, + Insertable, + InsertableIdentity, + Updateable, + Deleteable + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IFuncModel.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IFuncModel.cs new file mode 100644 index 000000000..beb0b6b79 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IFuncModel.cs @@ -0,0 +1,10 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public interface IFuncModel + { + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonClient.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonClient.cs new file mode 100644 index 000000000..4f729ca29 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonClient.cs @@ -0,0 +1,15 @@ +using System.Collections.Generic; + +namespace SqlSugar +{ + public interface IJsonClient + { + ISqlSugarClient Context { get; set; } + + IJsonProvider Deleteable(string json); + List GetTableNameList(string json); + IJsonProvider Insertable(string json); + IJsonQueryableProvider Queryable(string json); + IJsonProvider Updateable(string json); + } +} \ No newline at end of file diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonDeleteableProvider.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonDeleteableProvider.cs new file mode 100644 index 000000000..1c1099884 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonDeleteableProvider.cs @@ -0,0 +1,11 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public interface IJsonDeleteableProvider : IJsonProvider + { + // IJsonQueryableProvider UpdateColumns(string tableName, string[] columns); + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonInsertableProvider.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonInsertableProvider.cs new file mode 100644 index 000000000..4a39a7afa --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonInsertableProvider.cs @@ -0,0 +1,11 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public interface IJsonInsertableProvider : IJsonProvider + { + // IJsonQueryableProvider UpdateColumns(string tableName, string[] columns); + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonProvider.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonProvider.cs new file mode 100644 index 000000000..54ec56052 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonProvider.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + + public interface IJsonProvider + { + List ToSqlList(); + SqlObjectResult ToSql(); + List ToSqlString(); + T ToResult(); + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonQueryableProvider.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonQueryableProvider.cs new file mode 100644 index 000000000..7bb1bdda6 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonQueryableProvider.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public interface IJsonQueryableProvider : IJsonProvider + { + IJsonQueryableProvider ShowDesciption(); + IJsonQueryableProvider UseAuthentication(JsonTableConfig config); + IJsonQueryableProvider UseAuthentication(List config); + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonToModel.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonToModel.cs new file mode 100644 index 000000000..03d3d5b65 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonToModel.cs @@ -0,0 +1,19 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + /// + /// Json to model + /// + public partial interface IContextMethods + { + List JsonToOrderByModels(string json); + List JsonToGroupByModels(string json); + List> JsonToColumnsModels(string json); + List JsonToSelectModels(string json); + IFuncModel JsonToSqlFuncModels(string json); + JoinModel JsonToJoinModels(string json); + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonUpdateableProvider.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonUpdateableProvider.cs new file mode 100644 index 000000000..95c64fd58 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IJsonUpdateableProvider.cs @@ -0,0 +1,11 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public interface IJsonUpdateableProvider : IJsonProvider + { + // IJsonQueryableProvider UpdateColumns(string tableName, string[] columns); + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IModelToSql.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IModelToSql.cs new file mode 100644 index 000000000..bbb06a974 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/IModelToSql.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + /// + /// Json Model to sql + /// + public partial interface ISqlBuilder + { + KeyValuePair OrderByModelToSql(List models); + KeyValuePair GroupByModelToSql(List models); + KeyValuePair SelectModelToSql(List models); + KeyValuePair FuncModelToSql(IFuncModel model); + } + +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/ISugarQueryable.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/ISugarQueryable.cs new file mode 100644 index 000000000..61995be57 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Interface/ISugarQueryable.cs @@ -0,0 +1,16 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public partial interface ISugarQueryable + { + ISugarQueryable Having(IFuncModel model); + ISugarQueryable OrderBy(List models); + ISugarQueryable GroupBy(List models); + ISugarQueryable Select(List models); + ISugarQueryable AS(string tableName, string shortName); + ISugarQueryable AddJoinInfo(string tableName, string shortName, IFuncModel models, JoinType type = JoinType.Left); + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/FuncModel.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/FuncModel.cs new file mode 100644 index 000000000..61be545b2 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/FuncModel.cs @@ -0,0 +1,17 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public class ObjectFuncModel: IFuncModel + { + public string FuncName { get; set; } + public List Parameters { get; set; } + } + public class ArrayFuncModel: IFuncModel + { + public List Objects { get; set; } + } + +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/GroupByModel.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/GroupByModel.cs new file mode 100644 index 000000000..01e625e75 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/GroupByModel.cs @@ -0,0 +1,11 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public class GroupByModel + { + public string FieldName { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/JoinModel.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/JoinModel.cs new file mode 100644 index 000000000..0bfad9994 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/JoinModel.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + + public class JoinModel + { + public string TableName { get; set; } + public string ShortName { get; set; } + public ObjectFuncModel OnWhereList { get; set; } + public JoinType JoinType { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/JsonQueryParameter.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/JsonQueryParameter.cs new file mode 100644 index 000000000..15b912e9f --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/JsonQueryParameter.cs @@ -0,0 +1,17 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + internal class JsonQueryParameter + { + public bool IsSelect { get; set; } + public bool IsJoin { get; set; } + public int? PageIndex { get; set; } + public int? PageSize { get; set; } = 20; + public bool JoinNoSelect { get { return IsJoin && !IsSelect; } } + + public bool IsPage { get { return PageIndex != null; } } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/JsonSqlModels.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/JsonSqlModels.cs new file mode 100644 index 000000000..a0af7eae2 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/JsonSqlModels.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public class SqlObjectResult + { + + + public SqlObjectResult(KeyValuePair> keyValuePair, JsonProviderType jsonSqlType) + { + this.Sql = keyValuePair.Key; + this.Parameters = keyValuePair.Value; + this.JsonSqlType = jsonSqlType; + } + + public JsonProviderType JsonSqlType { get; set; } + public string Sql { get; set; } + public List Parameters { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/JsonTableNameInfo.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/JsonTableNameInfo.cs new file mode 100644 index 000000000..aa16114b5 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/JsonTableNameInfo.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public class JsonTableNameInfo + { + public string TableName { get; set; } + public string ShortName { get; set; } + public string Scheme { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/OrderByModel.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/OrderByModel.cs new file mode 100644 index 000000000..30e4091a1 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/OrderByModel.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public class OrderByModel + { + public string FieldName { get; set; } + public OrderByType OrderByType { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/SelectFieldModel.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/SelectFieldModel.cs new file mode 100644 index 000000000..de8ba54f9 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonModels/SelectFieldModel.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public class SelectModel + { + public object FiledName { get; set; } + public string AsName { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/Helper.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/Helper.cs new file mode 100644 index 000000000..2e36caac6 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/Helper.cs @@ -0,0 +1,46 @@ +using Newtonsoft.Json.Linq; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace SqlSugar +{ + /// + /// SqlFunc to model + /// + public partial class ContextMethods : IContextMethods + { + private bool IsObjct(JToken sqlfunc) + { + return sqlfunc.Type == JTokenType.Object; + } + private bool IsArray(string sqlfunc) + { + return sqlfunc.StartsWith("["); + } + public static bool IsSqlFunc(JToken item, string fileName) + { + return item.Type == JTokenType.Object || fileName.ToLower().Contains("SqlFunc_"); + } + private bool IsObject(JToken parameters) + { + return parameters.Type == JTokenType.Object; + } + private bool IsArray(JToken parameters) + { + return parameters.Type == JTokenType.Array; + } + private bool IsString(JToken parameters) + { + return parameters.Type == JTokenType.String; + } + private bool IsFieldName(JToken item) + { + return item.ObjToString().ToLower().Contains("fieldname"); + } + private bool IsArraySingleItem(JToken item) + { + return IsArray(item) && item.Count() == 1; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonSqlFuncToModel.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonSqlFuncToModel.cs new file mode 100644 index 000000000..e6662f052 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonSqlFuncToModel.cs @@ -0,0 +1,86 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace SqlSugar +{ + /// + /// SqlFunc to model + /// + public partial class ContextMethods : IContextMethods + { + #region Root + public ObjectFuncModel JsonToSqlFuncModels(JToken sqlfunc) + { + var key = sqlfunc.First(); + if (IsObjct(sqlfunc)) + { + return GetFuncModelByObject(key); + } + else + { + return GetFuncModelByArray(sqlfunc); + } + } + public IFuncModel JsonToSqlFuncModels(string sqlfunc) + { + if (IsArray(sqlfunc)) + { + return GetFuncModelByArray(sqlfunc); + } + else + { + return GetFuncModelByObject(sqlfunc); + } + } + #endregion + + #region Level 1 + private ObjectFuncModel GetFuncModelByArray(JToken sqlfunc) + { + ObjectFuncModel result = new ObjectFuncModel(); + result.Parameters = new List(); + result.FuncName = "Sqlfunc_Format"; + StringBuilder sb = new StringBuilder(); + foreach (var item in sqlfunc) + { + result.Parameters.Add(GetParameter(item)); + } + return result; + } + private ObjectFuncModel GetFuncModelByObject(JToken key) + { + ObjectFuncModel result = new ObjectFuncModel(); + JProperty jProperty = key.ToObject(); + result.FuncName = jProperty.Name; + var parameters = jProperty.Value; + result.Parameters = GetParameter(parameters); + return result; + } + private IFuncModel GetFuncModelByObject(string sqlfunc) + { + var jObject = this.Context.Utilities.DeserializeObject(sqlfunc); + return JsonToSqlFuncModels(jObject); + } + private IFuncModel GetFuncModelByArray(string sqlfunc) + { + ObjectFuncModel result = new ObjectFuncModel(); + result.Parameters = new List(); + result.FuncName = "Sqlfunc_Format"; + var jArrary = this.Context.Utilities.DeserializeObject(sqlfunc); + StringBuilder sb = new StringBuilder(); + foreach (var item in jArrary) + { + result.Parameters.Add(GetParameter(item)); + } + return result; + } + + #endregion + + + + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonSqlFuncToParameters.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonSqlFuncToParameters.cs new file mode 100644 index 000000000..6186f689c --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonSqlFuncToParameters.cs @@ -0,0 +1,67 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; + +namespace SqlSugar +{ + public partial class ContextMethods : IContextMethods + { + #region Root + public List GetParameter(JToken parameters) + { + List result = new List(); + if (IsString(parameters)) + { + result.Add(GetStringParameters(parameters)); + } + else if (IsArray(parameters)) + { + result.AddRange(GetArrayParameters(parameters)); + } + else if (IsObject(parameters)) + { + result.Add(GetObjectParameters(parameters)); + } + else + { + result.Add(GetObjectErrorParameters(parameters)); + } + return result; + } + #endregion + + #region Level1 + private static List GetObjectErrorParameters(JToken parameters) + { + Check.Exception(true, ErrorMessage.GetThrowMessage($" {parameters.ToString()} format is error ", $" {parameters.ToString()} 格式错误")); + return null; + } + + public List GetArrayParameters(JToken parameters) + { + List result = new List(); + foreach (var item in parameters) + { + result.Add(GetParameter(item)); + } + return result; + } + + public object GetObjectParameters(JToken parameters) + { + return JsonToSqlFuncModels(parameters); + } + + public object GetStringParameters(JToken parameters) + { + return parameters.ObjToString(); + } + #endregion + + + + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonToColumnsModels.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonToColumnsModels.cs new file mode 100644 index 000000000..6004927a3 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonToColumnsModels.cs @@ -0,0 +1,63 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace SqlSugar +{ + public partial class ContextMethods : IContextMethods + { + public List> JsonToColumnsModels(string json) + { + List> result = new List>(); + List conditionalModels = new List(); + if (IsArray(json)) + { + return GetColumnsByArray(json); + } + else + { + return GetColumnsByObject(json); + } + } + private List> GetColumnsByObject(string json) + { + List> result = new List>(); + var dic = this.Context.Utilities.DeserializeObject>(json); + result.Add( GetColumns(dic)); + return result; + } + private List> GetColumnsByArray(string json) + { + List> result = new List>(); + var jarray = this.Context.Utilities.DeserializeObject>>(json); + foreach (var item in jarray) + { + result.Add(GetColumns(item)); + } + return result; + } + + private Dictionary GetColumns(Dictionary dictionary) + { + Dictionary result= new Dictionary(); + foreach (var item in dictionary) + { + var value = GetValue(item); + result.Add(item.Key, value); + } + return result; + } + + private static object GetValue(KeyValuePair item) + { + if (item.Value == null) + return null; + var valueString = item.Value.ToString(); + var vallue = Json2SqlHelper.GetValue(valueString); + var type = Json2SqlHelper.GetType(valueString); + return UtilMethods.ConvertDataByTypeName(type,vallue); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonToGroupByModels.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonToGroupByModels.cs new file mode 100644 index 000000000..4f0ccbbe8 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonToGroupByModels.cs @@ -0,0 +1,32 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; + +namespace SqlSugar +{ + public partial class ContextMethods : IContextMethods + { + public List JsonToGroupByModels(string json) + { + List conditionalModels = new List(); + var jarray = this.Context.Utilities.DeserializeObject(json); + foreach (var item in jarray) + { + if (item.ObjToString().ToLower().Contains("fieldname")) + { + var model = item.ToObject(); + conditionalModels.Add(model); + } + else + { + conditionalModels.Add(new GroupByModel() { FieldName = item.ObjToString() }); + } + } + return conditionalModels; + } + + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonToJoinModels.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonToJoinModels.cs new file mode 100644 index 000000000..7ebb17e1f --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonToJoinModels.cs @@ -0,0 +1,31 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; + +namespace SqlSugar +{ + /// + /// Json to model + /// + public partial class ContextMethods : IContextMethods + { + + public JoinModel JsonToJoinModels(string json) + { + JoinModel conditionalModels = new JoinModel(); + var array = JArray.Parse(json); + Check.Exception(array.Count != 3, json + " format error"); + var tableName = array[0]; + var shortName = array[1]; + var onWhere = array[2]; + JoinModel result = new JoinModel(); + result.TableName = tableName.ObjToString(); + result.ShortName = shortName.ObjToString(); + result.OnWhereList = JsonToSqlFuncModels(onWhere); + return result; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonToOrderByModels.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonToOrderByModels.cs new file mode 100644 index 000000000..d25f3f927 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonToOrderByModels.cs @@ -0,0 +1,39 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; + +namespace SqlSugar +{ + public partial class ContextMethods : IContextMethods + { + public List JsonToOrderByModels(string json) + { + List conditionalModels = new List(); + var jarray = this.Context.Utilities.DeserializeObject(json); + foreach (var item in jarray) + { + if (IsFieldName(item)) + { + var model = item.ToObject(); + conditionalModels.Add(model); + } + else if (item.Type == JTokenType.String) + { + conditionalModels.Add(new OrderByModel() { FieldName = item.ObjToString() }); + } + else if (item.Type == JTokenType.Array) + { + conditionalModels.Add(new OrderByModel() + { + FieldName = item[0].ObjToString(), + OrderByType = item[1].ObjToString().ToLower() == "desc" ? OrderByType.Desc : OrderByType.Asc + }); + } + } + return conditionalModels; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonToSelectModels.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonToSelectModels.cs new file mode 100644 index 000000000..b8a78db4e --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/JsonToModel/JsonToSelectModels.cs @@ -0,0 +1,70 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; + +namespace SqlSugar +{ + public partial class ContextMethods : IContextMethods + { + public List JsonToSelectModels(string json) + { + List conditionalModels = new List(); + var jarray = this.Context.Utilities.DeserializeObject(json); + foreach (var item in jarray) + { + if (IsFieldName(item)) + { + var model = item.ToObject(); + conditionalModels.Add(model); + } + else if (IsString(item)) + { + conditionalModels.Add(new SelectModel() { FiledName = item.ObjToString(), AsName = item.ObjToString().Replace(".", "_") }); + } + else if (IsArraySingleItem(item)) + { + object fileName = item[0].ObjToString(); + var asName = item[0].ObjToString().Replace(".", "_"); + if (IsSqlFunc(item[0], fileName.ObjToString())) + { + fileName = JsonToSqlFuncModels(item[0]); + } + conditionalModels.Add(new SelectModel() + { + FiledName = fileName, + AsName = asName + }); + + } + else if (IsArray(item)) + { + object fileName = item[0].ObjToString(); + var asName = item[1].ObjToString().Replace(".", "_"); + if (IsSqlFunc(item[0], fileName.ObjToString())) + { + fileName = JsonToSqlFuncModels(item[0]); + } + conditionalModels.Add(new SelectModel() + { + FiledName = fileName, + AsName = asName + }); + + } + else + { + conditionalModels.Add(new SelectModel() + { + FiledName = item.ObjToString().Trim(), + AsName = item.ObjToString().Trim() + }); + } + + } + return conditionalModels; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/ModelToSql/FuncModelToSql.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/ModelToSql/FuncModelToSql.cs new file mode 100644 index 000000000..0b43b6bec --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/ModelToSql/FuncModelToSql.cs @@ -0,0 +1,135 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; + +namespace SqlSugar +{ + /// + ///Json model to sql + /// + public abstract partial class SqlBuilderProvider : SqlBuilderAccessory, ISqlBuilder + { + #region Root + public KeyValuePair FuncModelToSql(IFuncModel model) + { + ObjectFuncModel data = model as ObjectFuncModel; + var name = data.FuncName; + var parameters = data.Parameters; + var dbMethods = this.Context.Queryable().QueryBuilder.LambdaExpressions.DbMehtods; + var methods = GetAllMethods(dbMethods); + var methodName = GetMethodName(name, methods); + var methodInfo = GetMethod(dbMethods, methodName); + var pars = methodInfo.GetParameters(); + + var resSql = ""; + var resPars = new List(); + resSql = GetSql(parameters, dbMethods, methodName, methodInfo, pars, resPars); + return new KeyValuePair(resSql, resPars.ToArray()); + } + #endregion + + #region Level2 + private string GetSql(List parameters, IDbMethods dbMethods, string methodName, System.Reflection.MethodInfo methodInfo, System.Reflection.ParameterInfo[] pars, List resPars) + { + string resSql; + if (IsNoParameter(pars)) + { + resSql = GetNoParameterMehtodSql(dbMethods, methodInfo); + } + else if (IsFormatMethod(methodName)) + { + resSql = GetFormatMethodSql(parameters, resPars); + } + else if (IsSqlFuncMethod(pars)) + { + resSql = GetSqlFuncSql(parameters, dbMethods, methodName, methodInfo, resPars); + } + else + { + resSql = GetNoSupportMethodSql(methodInfo); + } + + return resSql; + } + private static System.Reflection.MethodInfo GetMethod(IDbMethods dbMethods, string methodName) + { + return dbMethods.GetType().GetMethods() + .Where(it => it.Name == methodName) + .Where(it => it.Name != "Equals" || it.GetParameters().Length == 1 && it.GetParameters().First().ParameterType == typeof(MethodCallExpressionModel)) + .FirstOrDefault(); + } + private static string GetMethodName(string name, List methods) + { + var result = methods.FirstOrDefault(it => name.EqualCase("SqlFunc_" + it) || name.EqualCase(it)); + Check.Exception(result == null, $" { name } is error "); + return result; + } + private static List GetAllMethods(IDbMethods dbMethods) + { + return new ReflectionInoCacheService().GetOrCreate("Json2SqlGetFuncSql", () => + dbMethods.GetType() + .GetMethods().Where(it => it.Name != "GetHashCode").Select(it => it.Name).ToList()); + } + #endregion + + #region Level3 + private static string GetNoSupportMethodSql(System.Reflection.MethodInfo methodInfo) + { + throw new Exception(methodInfo.Name); + } + private string GetSqlFuncSql(List parameters, IDbMethods dbMethods, string methodName, System.Reflection.MethodInfo methodInfo, List resPars) + { + string resSql; + var args = new List(); + foreach (var item in parameters) + { + var value = GetSqlPart(item, resPars); + args.Add(new MethodCallExpressionArgs + { + MemberName = value, + MemberValue = value, + IsMember = true + }); + } + resSql = methodInfo.Invoke(dbMethods, new object[] { new MethodCallExpressionModel() { + Name=methodName, + Args=args + } }).ObjToString(); + return resSql; + } + private string GetFormatMethodSql(List parameters, List resPars) + { + string resSql; + var objects = new List(); + foreach (var item in parameters) + { + var value = GetSqlPart(item, resPars); + objects.Add(value.ObjToString()); + } + resSql = string.Join(" ", string.Join(" ", objects)); + return resSql; + } + private static string GetNoParameterMehtodSql(IDbMethods dbMethods, System.Reflection.MethodInfo methodInfo) + { + return methodInfo.Invoke(dbMethods, new object[] { }).ObjToString(); + } + #endregion + + #region Helper + private static bool IsSqlFuncMethod(System.Reflection.ParameterInfo[] pars) + { + return pars.First().ParameterType == typeof(MethodCallExpressionModel); + } + private static bool IsFormatMethod(string methodName) + { + return methodName.EqualCase("format"); + } + private static bool IsNoParameter(System.Reflection.ParameterInfo[] pars) + { + return pars.Length == 0; + } + #endregion + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/ModelToSql/GroupByModelToSql.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/ModelToSql/GroupByModelToSql.cs new file mode 100644 index 000000000..693143496 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/ModelToSql/GroupByModelToSql.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Text.RegularExpressions; +using System.Linq; +namespace SqlSugar +{ + public abstract partial class SqlBuilderProvider : SqlBuilderAccessory, ISqlBuilder + { + public KeyValuePair GroupByModelToSql(List models) + { + StringBuilder sql = new StringBuilder(""); + SugarParameter[] pars = new SugarParameter[] { }; + foreach (var item in models) + { + if (item is GroupByModel) + { + var orderByModel = item as GroupByModel; + sql.Append($" {this.GetTranslationColumnName(orderByModel.FieldName.ToSqlFilter())} ,"); + } + else + { + + } + + } + return new KeyValuePair(sql.ToString().TrimEnd(','), pars); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/ModelToSql/OrderByModelToSql.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/ModelToSql/OrderByModelToSql.cs new file mode 100644 index 000000000..728343f1c --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/ModelToSql/OrderByModelToSql.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Text.RegularExpressions; +using System.Linq; +namespace SqlSugar +{ + public abstract partial class SqlBuilderProvider : SqlBuilderAccessory, ISqlBuilder + { + public KeyValuePair OrderByModelToSql(List models) + { + StringBuilder sql = new StringBuilder(""); + SugarParameter[] pars = new SugarParameter[] { }; + foreach (var item in models) + { + if (item is OrderByModel) + { + var orderByModel = item as OrderByModel; + sql.Append($" {this.GetTranslationColumnName(orderByModel.FieldName.ToSqlFilter())} {orderByModel.OrderByType.ToString().ToUpper()} ,"); + } + else + { + + } + + } + return new KeyValuePair(sql.ToString().TrimEnd(','), pars); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/ModelToSql/SelectModelToSql.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/ModelToSql/SelectModelToSql.cs new file mode 100644 index 000000000..98b5427c0 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/ModelToSql/SelectModelToSql.cs @@ -0,0 +1,45 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Text.RegularExpressions; +using System.Linq; +namespace SqlSugar +{ + public abstract partial class SqlBuilderProvider : SqlBuilderAccessory, ISqlBuilder + { + public KeyValuePair SelectModelToSql(List models) + { + StringBuilder sql = new StringBuilder(""); + var pars = new List { }; + foreach (var item in models) + { + if (item is SelectModel) + { + var orderByModel = item as SelectModel; + orderByModel.AsName=GetAsName(orderByModel); + orderByModel.FiledName = GetSqlPart(orderByModel.FiledName, pars).ObjToString(); + AppendFiledName(sql, orderByModel); + } + else + { + + } + } + return new KeyValuePair(sql.ToString().TrimEnd(','), pars.ToArray()); + } + + private string GetAsName(SelectModel orderByModel) + { + if (orderByModel.AsName.IsNullOrEmpty()) + { + orderByModel.AsName = orderByModel.FiledName.ObjToString(); + } + return this.GetTranslationColumnName(orderByModel.AsName); + } + + private void AppendFiledName(StringBuilder sql, SelectModel orderByModel) + { + sql.Append($" {orderByModel.FiledName} AS {orderByModel.AsName} ,"); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/ModelToSql/SqlPart.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/ModelToSql/SqlPart.cs new file mode 100644 index 000000000..153ed3b09 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/ModelToSql/SqlPart.cs @@ -0,0 +1,146 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Text.RegularExpressions; +using System.Linq; +namespace SqlSugar +{ + public abstract partial class SqlBuilderProvider : SqlBuilderAccessory, ISqlBuilder + { + #region Variable + private string[] SqlSplicingOperator = new string[] { ">", ">=", "<", "<=", "(", ")", "=", "||", "&&","&","|" }; + #endregion + + #region Root + private string GetSqlPart(object value, List pars) + { + Check.Exception(value == null, $" FiledName is error "); + if (IsSqlSplicingOperator(value)) + { + return GetSqlSplicingOperator(value); + } + else if (IsString(value)) + { + return GetSqlPartByString(value, pars); + } + else if (IsListObject(value)) + { + return GetSqlPartByListObject(value, pars); + } + else if (IsObjectFunc(value)) + { + return GetSqlPartByObjectFuncModel(value, pars); + } + else + { + return GetSqlPartError(value); + } + } + + #endregion + + #region Level2 + + private static string GetSqlSplicingOperator(object value) + { + var result= value.ObjToString(); + if (result == "||") return "AND"; + else if (result == "&&") return "OR"; + return result; + } + private static string GetSqlPartError(object value) + { + Check.Exception(value == null, $" {value} is error "); + return null; + } + private string GetSqlPartByObjectFuncModel(object value, List pars) + { + var data = value as ObjectFuncModel; + var obj = FuncModelToSql(data); + pars.AddRange(obj.Value); + return obj.Key; + } + private string GetSqlPartByListObject(object value, List pars) + { + var list = (value as List); + if (list.Count == 1) + { + return GetSqlPart(list.First(), pars).ObjToString(); + } + else + { + Check.Exception(value == null, $" {value} is error "); + return null; + } + } + private string GetSqlPartByString(object value, List pars) + { + var valueString = value.ObjToString().Trim(); + if (Json2SqlHelper.IsSqlValue(valueString)) + { + return GetParameterName(pars, valueString); + } + else + { + return this.GetTranslationColumnName(value.ObjToString()); + } + } + #endregion + + #region Level3 + private string GetSplicingOperator(string valueString) + { + var parvalue = Regex.Match(valueString, @"\@s\:(.+)").Groups[1].Value; + if (parvalue == null) parvalue = ""; + parvalue = parvalue.Trim(); + if (parvalue.ToLower().IsIn(SqlSplicingOperator)) + { + return parvalue; + } + else + { + Check.ExceptionEasy($"{valueString} is error ", $"{valueString} 不是有效的拼接符号,拼接符号有:and、or、>=、<=、>、<、=、(、)"); + } + return parvalue; + } + private string GetParameterName(List pars, string valueString) + { + object parvalue = Json2SqlHelper.GetValue(valueString); + SugarParameter parameter = new SugarParameter("@p" + pars.Count(), parvalue); + var type = Json2SqlHelper.GetType(valueString); + parvalue = UtilMethods.ConvertDataByTypeName(type, parvalue.ObjToString()); + var parname = GetParameterName(pars, parvalue); + return parname; + } + + private static string GetParameterName(List pars, object parvalue) + { + var parname = "@p" + pars.Count(); + SugarParameter parameter = new SugarParameter(parname, parvalue); + pars.Add(parameter); + return parname; + } + #endregion + + #region Helper + + private static bool IsListObject(object value) + { + return value.GetType() == typeof(List); + } + private static bool IsString(object value) + { + return value.GetType() == typeof(string); + } + private static bool IsObjectFunc(object value) + { + return value is ObjectFuncModel; + } + private bool IsSqlSplicingOperator(object value) + { + return SqlSplicingOperator.Contains(value.ObjToString()); + } + #endregion + + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Common/JsonCommonProvider.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Common/JsonCommonProvider.cs new file mode 100644 index 000000000..abbf92fa8 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Common/JsonCommonProvider.cs @@ -0,0 +1,75 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; +namespace SqlSugar +{ + internal class JsonCommonProvider + { + public JsonCommonProvider(ISqlSugarClient context) + { + //this.context = context; + this.sqlBuilder = InstanceFactory.GetSqlbuilder(context.CurrentConnectionConfig); + this.sqlBuilder.Context = (context as SqlSugarClient).Context; + } + //public ISqlSugarClient context { get; set; } + public ISqlBuilder sqlBuilder { get; set; } + public JsonTableNameInfo GetTableName(JToken item) + { + JsonTableNameInfo jsonTableNameInfo = new JsonTableNameInfo(); + if (item.First().Type == JTokenType.Array && item.First.Count() == 2) + { + var tableName = item.First()[0].ObjToString(); + var shortName = item.First()[1].ObjToString(); + jsonTableNameInfo.ShortName = shortName; + jsonTableNameInfo.TableName = tableName; + + } + else + { + var value = item.First().ToString(); + jsonTableNameInfo.TableName = value; + } + return jsonTableNameInfo; + } + public KeyValuePair GetWhere(string item, SqlSugarProvider context) + { + + if (!IsConditionalModel(item)) + { + var obj = context.Utilities.JsonToSqlFuncModels(item); + var sqlobj = sqlBuilder.FuncModelToSql(obj); + return sqlobj; + } + else + { + var obj = context.Utilities.JsonToConditionalModels(item); + var sqlObj = sqlBuilder.ConditionalModelToSql(obj, 0); + return sqlObj; + } + } + public KeyValuePair GetWhere(JToken item,SqlSugarProvider context) + { + var value = item.First().ToString(); + Check.ExceptionEasy(item.First().Type != JTokenType.Array, "Where format error " + item, "Where格式错误" + item); + if (!IsConditionalModel(value)) + { + var obj = context.Utilities.JsonToSqlFuncModels(value); + var sqlobj = sqlBuilder.FuncModelToSql(obj); + return sqlobj; + } + else + { + var obj = context.Utilities.JsonToConditionalModels(value); + var sqlObj = sqlBuilder.ConditionalModelToSql(obj, 0); + return sqlObj; + } + } + + private static bool IsConditionalModel(string value) + { + return value.ToLower().Contains("fieldname"); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Deleteable/JsonDeleteableProvider.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Deleteable/JsonDeleteableProvider.cs new file mode 100644 index 000000000..ba074e47c --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Deleteable/JsonDeleteableProvider.cs @@ -0,0 +1,88 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace SqlSugar +{ + public class JsonDeleteableProvider : IJsonDeleteableProvider + { + private ISqlSugarClient context; + private JObject jObject; + private JsonCommonProvider jsonCommonProvider; + private IDeleteable sugarDeleteable=null; + public JsonDeleteableProvider(ISqlSugarClient context, JObject jObject) + { + this.jObject = jObject; + this.context = context; + this.jsonCommonProvider = new JsonCommonProvider(context); + } + public SqlObjectResult ToSql() + { + return this.ToSqlList().First(); + } + public List ToSqlList() + { + List result = new List(); + JsonQueryParameter jsonQueryParameter = new JsonQueryParameter(); + var appendTypeNames = this.jObject.AsJEnumerable().ToList(); + this.sugarDeleteable = this.context.Deleteable(); + foreach (JToken item in appendTypeNames) + { + AppendAll(jsonQueryParameter, item); + } + result.Add(new SqlObjectResult(this.sugarDeleteable.ToSql(),JsonProviderType.Deleteable)); + return result; + } + private void AppendAll(JsonQueryParameter jsonQueryParameter, JToken item) + { + var name = item.Path.ToLower(); + if (IsWhere(name)) + { + AppendWhere(item); + } + else if (IsTable(name)) + { + AppendTable(item); + } + } + private void AppendTable(JToken item) + { + var tableInfo = jsonCommonProvider.GetTableName(item); + var tableName = tableInfo.TableName; + if (tableInfo.ShortName.HasValue()) + { + tableName = tableInfo.ShortName + "." + tableInfo.TableName; + } + this.sugarDeleteable.AS(tableName); + } + private void AppendWhere(JToken item) + { + var sqlObj = jsonCommonProvider.GetWhere(item, sugarDeleteable.DeleteBuilder.Context); + sugarDeleteable.Where(sqlObj.Key, sqlObj.Value); + } + private static bool IsTable(string name) + { + return name == JsonProviderConfig.KeyDeleteable.Get().ToLower(); + } + private static bool IsWhere(string name) + { + return name == "Where".ToLower(); + } + public string ToSqlString() + { + throw new NotImplementedException(); + } + + public JsonDeleteResult ToResult() + { + throw new NotImplementedException(); + } + + List IJsonProvider.ToSqlString() + { + throw new NotImplementedException(); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/AppendIdentity.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/AppendIdentity.cs new file mode 100644 index 000000000..ed604069e --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/AppendIdentity.cs @@ -0,0 +1,16 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; +namespace SqlSugar +{ + public partial class JsonInsertableProvider : IJsonInsertableProvider + { + private void AppendIdentity(JToken item) + { + var tableInfo = jsonCommonProvider.GetTableName(item); + this.IdentityId = tableInfo.TableName; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/AppendName.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/AppendName.cs new file mode 100644 index 000000000..4e94e2bc9 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/AppendName.cs @@ -0,0 +1,20 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; +namespace SqlSugar +{ + public partial class JsonInsertableProvider : IJsonInsertableProvider + { + private void AppendName(JToken item) + { + var tableInfo = jsonCommonProvider.GetTableName(item); + this.TableName = tableInfo.TableName; + if (tableInfo.ShortName.HasValue()) + { + this.TableName = tableInfo.ShortName + "." + tableInfo.TableName; + } + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/AppendRow.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/AppendRow.cs new file mode 100644 index 000000000..f1029c76d --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/AppendRow.cs @@ -0,0 +1,17 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; +namespace SqlSugar +{ + public partial class JsonInsertableProvider : IJsonInsertableProvider + { + private void AppendRow(JToken item) + { + var value = item.First().ToString(); + var dics = context.Utilities.JsonToColumnsModels(value); + sugarInsertable =this.context.Insertable(dics).AS(this.TableName); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/Helper.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/Helper.cs new file mode 100644 index 000000000..561503f45 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/Helper.cs @@ -0,0 +1,46 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace SqlSugar +{ + public partial class JsonInsertableProvider : IJsonInsertableProvider + { + private static bool IsColumns(string name) + { + return name == "columns".ToLower(); + } + + private static bool IsName(string name) + { + return name == JsonProviderConfig.KeyInsertable.Get().ToLower(); + } + + private static bool IsIdentity(string name) + { + return name == "identity".ToLower(); + } + private List ToSqlHelper() + { + List result = new List(); + JsonQueryParameter jsonQueryParameter = new JsonQueryParameter(); + var appendTypeNames = this.jObject.AsJEnumerable().ToList(); + foreach (JToken item in appendTypeNames.OrderBy(it => it.Path.EqualCase(JsonProviderConfig.KeyInsertable.Get()) ? 0 : 1)) + { + AppendAll(jsonQueryParameter, item); + } + var addItem = this.sugarInsertable.ToSql(); + if (this.IdentityId.HasValue()) + { + result.Add(new SqlObjectResult(addItem, JsonProviderType.InsertableIdentity)); + } + else + { + result.Add(new SqlObjectResult(addItem, JsonProviderType.Insertable)); + } + return result; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/JsonInsertableProvider.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/JsonInsertableProvider.cs new file mode 100644 index 000000000..f1d85236a --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/JsonInsertableProvider.cs @@ -0,0 +1,64 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace SqlSugar +{ + public partial class JsonInsertableProvider : IJsonInsertableProvider + { + public SqlObjectResult ToSql() + { + return this.ToSqlList().First(); + } + public JsonInsertableProvider(ISqlSugarClient context, JObject jObject) + { + this.jObject = jObject; + this.context = context; + this.jsonCommonProvider = new JsonCommonProvider(context); + } + public JsonInsertResult ToResult() + { + var result=new JsonInsertResult(); + var sqlInfo = this.ToSqlList(); + var sqlInfoResult = sqlInfo.First(); + if (sqlInfoResult.JsonSqlType == JsonProviderType.InsertableIdentity) + { + result.InsertCount = this.context.Ado.ExecuteCommand(sqlInfoResult.Sql,sqlInfoResult.Parameters); + } + else + { + result.InsertCount = this.Count; + result.IdentityValue = this.context.Ado.GetInt(sqlInfoResult.Sql, sqlInfoResult.Parameters); + } + return result; + } + public List ToSqlList() + { + return ToSqlHelper(); + } + + private void AppendAll(JsonQueryParameter jsonQueryParameter, JToken item) + { + var name = item.Path.ToLower(); + if (IsName(name)) + { + AppendName(item); + } + else if (IsIdentity(name)) + { + AppendIdentity(item); + } + else if (IsColumns(name)) + { + AppendRow(item); + } + } + + public List ToSqlString() + { + throw new NotImplementedException(); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/PrivateProperty.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/PrivateProperty.cs new file mode 100644 index 000000000..3a20638b9 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Insertable/PrivateProperty.cs @@ -0,0 +1,20 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace SqlSugar +{ + public partial class JsonInsertableProvider : IJsonInsertableProvider + { + private ISqlSugarClient context; + private JObject jObject; + private JsonCommonProvider jsonCommonProvider; + private string TableName { get; set; } + private string IdentityId { get; set; } + private int Count { get; set; } + private IInsertable> sugarInsertable; + + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/ApendJoinLastAfter.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/ApendJoinLastAfter.cs new file mode 100644 index 000000000..8941dc69c --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/ApendJoinLastAfter.cs @@ -0,0 +1,47 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; +namespace SqlSugar +{ + /// + /// ApendJoinLastAfter + /// + public partial class JsonQueryableProvider : IJsonQueryableProvider + { + private void ApendJoinLastAfter(JToken item) + { + if (IsAppendSelect()) + { + JArray jArray = new JArray(); + var tableConfigs = this.jsonTableConfigs.GroupBy(it => it.TableName).Select(it => it.First()).ToList(); + var isJoinTable = IsAnyJoin(appendTypeNames); + foreach (var config in tableConfigs) + { + + if (isJoinTable) + { + + } + else + { + if (config.Columns.Any()) + { + foreach (var column in config.Columns.Select(it => it.Name).Distinct()) + { + jArray.Add(column); + } + } + } + } + this.AppendSelect(jArray); + } + } + + private bool IsAppendSelect() + { + return !IsAnySelect(appendTypeNames) && this.jsonTableConfigs.Any(); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendFrom.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendFrom.cs new file mode 100644 index 000000000..b42984391 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendFrom.cs @@ -0,0 +1,29 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; + +namespace SqlSugar +{ + /// + /// AppendFrom + /// + public partial class JsonQueryableProvider : IJsonQueryableProvider + { + + private void AppendFrom(JToken item) + { + var tableNameInfo=jsonCommonProvider.GetTableName(item); + AddMasterTableInfos(tableNameInfo); + if (tableNameInfo.ShortName.HasValue()) + { + this.sugarQueryable.AS(tableNameInfo.TableName, tableNameInfo.ShortName); + } + else + { + this.sugarQueryable.AS(tableNameInfo.TableName, tableNameInfo.ShortName); + } + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendGroupBy.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendGroupBy.cs new file mode 100644 index 000000000..e6b29e41f --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendGroupBy.cs @@ -0,0 +1,21 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; +namespace SqlSugar +{ + /// + /// AppendGroupBy + /// + public partial class JsonQueryableProvider : IJsonQueryableProvider + { + + private void AppendGroupBy(JToken item) + { + var value = item.First().ToString(); + var obj = context.Utilities.JsonToGroupByModels(value); + sugarQueryable.GroupBy(obj); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendHaving.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendHaving.cs new file mode 100644 index 000000000..2b19b24ca --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendHaving.cs @@ -0,0 +1,21 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; +namespace SqlSugar +{ + /// + /// AppendHaving + /// + public partial class JsonQueryableProvider : IJsonQueryableProvider + { + private void AppendHaving(JToken item) + { + var value = item.First().ToString(); + var obj = context.Utilities.JsonToSqlFuncModels(value); + sugarQueryable.Having(obj); + } + + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendJoin.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendJoin.cs new file mode 100644 index 000000000..be078497f --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendJoin.cs @@ -0,0 +1,35 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; +namespace SqlSugar +{ + /// + /// AppendJoin + /// + public partial class JsonQueryableProvider : IJsonQueryableProvider + { + private bool AppendJoin(JToken item) + { + BeforeJoin(); + bool isJoin = true; + var value = item.First().ToString(); + var obj = context.Utilities.JsonToJoinModels(value); + sugarQueryable.AddJoinInfo(obj.TableName, obj.ShortName, obj.OnWhereList, obj.JoinType); + AddTableInfos(obj.TableName,obj.ShortName); + AfterJoin(); + return isJoin; + } + + private void AfterJoin() + { + + } + + private void BeforeJoin() + { + + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendOrderBy.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendOrderBy.cs new file mode 100644 index 000000000..89524bf4a --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendOrderBy.cs @@ -0,0 +1,22 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; + +namespace SqlSugar +{ + /// + /// AppendOrderBy + /// + public partial class JsonQueryableProvider : IJsonQueryableProvider + { + private void AppendOrderBy(JToken item) + { + var value = item.First().ToString(); + var obj = context.Utilities.JsonToOrderByModels(value); + sugarQueryable.OrderBy(obj); + } + + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendPage.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendPage.cs new file mode 100644 index 000000000..460c3d7dd --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendPage.cs @@ -0,0 +1,28 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; +namespace SqlSugar +{ + /// + /// AppendPage + /// + public partial class JsonQueryableProvider : IJsonQueryableProvider + { + private int AppendPageSize(JToken item) + { + return Convert.ToInt32(item.First()); + } + + private int AppendPageNumber(JToken item) + { + var result= Convert.ToInt32(item.First()); + if (result == 0) + { + result = 1; + } + return result; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendSelect.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendSelect.cs new file mode 100644 index 000000000..c60ac9ceb --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendSelect.cs @@ -0,0 +1,83 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; +namespace SqlSugar +{ + + /// + /// AppendSelect + /// + public partial class JsonQueryableProvider : IJsonQueryableProvider + { + private bool AppendSelect(JToken item) + { + bool isSelect = true; + if (item.Type == JTokenType.Property) + { + var value = item.First().ToString(); + var obj = context.Utilities.JsonToSelectModels(value); + obj =FilterSelect(obj); + sugarQueryable.Select(obj); + } + else + { + var obj = context.Utilities.JsonToSelectModels(item.ToString()); + obj = FilterSelect(obj); + sugarQueryable.Select(obj); + } + return isSelect; + } + + private List FilterSelect(List obj) + { + if (!this.jsonTableConfigs.Any()) + { + return obj; + } + List result = new List(); + foreach (var item in obj) + { + if (item.FiledName is string) + { + var tableName = GetTableName(item.FiledName + ""); + var columnName = GetColumnName(item.FiledName + ""); + if (IsMyColums(tableName, columnName)) + { + result.Add(item); + } + } + else + { + result.Add(item); + } + } + return result; + } + + private bool IsMyColums(string tableName, string columnName) + { + return this.jsonTableConfigs.Any(it => it.TableName.EqualCase(tableName) + && it.Columns.Any(z => z.Name.EqualCase(columnName))); + } + + private string GetColumnName(string filedName) + { + return filedName.Split('.').Last(); + } + + private string GetTableName(string filedName) + { + if (!filedName.Contains(".")) + { + return TableInfos.First(it => it.IsMaster).Table; + } + else + { + var shortName=filedName.Split('.').First(); + return TableInfos.First(it => it.ShortName==shortName ).Table; + } + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendWhere.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendWhere.cs new file mode 100644 index 000000000..ac815618a --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/AppendWhere.cs @@ -0,0 +1,37 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; + +namespace SqlSugar +{ + + /// + /// AppendWhere + /// + public partial class JsonQueryableProvider : IJsonQueryableProvider + { + private void AppendWhere(JToken item) + { + BeforeWhere(); + var sqlObj = jsonCommonProvider.GetWhere(item, sugarQueryable.Context); + sugarQueryable.Where(sqlObj.Key, sqlObj.Value); + AfterWhere(); + } + + private void AfterWhere() + { + + } + + private void BeforeWhere() + { + if (!IsExecutedBeforeWhereFunc) + { + BeforeWhereFunc(); + IsExecutedBeforeWhereFunc = true; + } + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/Entities.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/Entities.cs new file mode 100644 index 000000000..68684a745 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/Entities.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + internal class JsonQueryableProvider_TableInfo + { + public string Table { get; set; } + public string ShortName { get; set; } + public bool IsMaster { get; set; } + public bool IsJoin { get; set; } + public int Index { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/Helper.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/Helper.cs new file mode 100644 index 000000000..aa548ba9e --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/Helper.cs @@ -0,0 +1,104 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; + +namespace SqlSugar +{ + /// + /// Helper + /// + public partial class JsonQueryableProvider : IJsonQueryableProvider + { + private static bool IsJoin(string name) + { + return name.StartsWith("LeftJoin".ToLower()) || name.StartsWith("RightJoin".ToLower()) || name.StartsWith("InnertJoin".ToLower()); + } + private static bool IsJoinLastAfter(string name) + { + return name== "joinlastafter"; + } + + private static bool IsPageSize(string name) + { + return name == "PageSize".ToLower(); + } + + private static bool IsPageNumber(string name) + { + return name == "PageNumber".ToLower(); + } + + private static bool IsSelect(string name) + { + return name == "Select".ToLower(); + } + + private static bool IsHaving(string name) + { + return name == "Having".ToLower(); + } + + private static bool IsGroupBy(string name) + { + return name == "GroupBy".ToLower(); + } + + private static bool IsOrderBy(string name) + { + return name == "OrderBy".ToLower(); + } + + private static bool IsWhere(string name) + { + return name == "Where".ToLower(); + } + + private static bool IsForm(string name) + { + return name == JsonProviderConfig.KeyQueryable.Get().ToLower(); + } + + private static bool IsAnySelect(List appendTypeNames) + { + return appendTypeNames.Any(it => IsSelect(it.Path.ToLower())); + } + private static bool IsAnyJoin(List appendTypeNames) + { + return appendTypeNames.Any(it => IsJoin(it.Path.ToLower())); + } + private int GetSort(string name) + { + if (IsForm(name)) + { + return 0; + } + else if (IsJoin(name)) + { + return 1; + } + else if (IsJoinLastAfter(name)) + { + return 2; + } + else + { + return 100; + } + } + private void AddMasterTableInfos(JsonTableNameInfo tableNameInfo) + { + AddTableInfos(tableNameInfo.TableName, tableNameInfo.ShortName,true); + } + private void AddTableInfos(string tableName,string shortName,bool isMaster=false) + { + UtilMethods.IsNullReturnNew(TableInfos); + TableInfos.Add(new JsonQueryableProvider_TableInfo() { Table = tableName, ShortName = shortName, IsMaster = true }); + } + private JsonQueryableProvider_TableInfo GetMasterTable() + { + return this.TableInfos.First(it => it.IsMaster); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/JsonQueryableProvider.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/JsonQueryableProvider.cs new file mode 100644 index 000000000..61a839357 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/JsonQueryableProvider.cs @@ -0,0 +1,112 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; + +namespace SqlSugar +{ + /// + /// JsonQueryableProvider + /// + public partial class JsonQueryableProvider : IJsonQueryableProvider + { + + public JsonQueryableProvider(ISqlSugarClient context, JObject jobject) + { + this.jobject = jobject; + this.context = context; + this.jsonCommonProvider = new JsonCommonProvider(context); + } + public IJsonQueryableProvider ShowDesciption() + { + this.IsDescription = true; + return this; + } + public IJsonQueryableProvider UseAuthentication(JsonTableConfig config) + { + if (config == null) + { + jsonTableConfigs =new List() { config }; + } + else + { + jsonTableConfigs.Add(config); + } + return this; + } + public IJsonQueryableProvider UseAuthentication(List configs) + { + foreach (JsonTableConfig config in configs) + { + UseAuthentication(config); + } + return this; + } + + public SqlObjectResult ToSql() + { + return this.ToSqlList().First(); + } + public JsonQueryResult ToResult() + { + return ToResultDefault(); + } + + public List ToSqlList() + { + var result = ToSqlDefault(); + return result; + } + + public List ToSqlString() + { + throw new NotImplementedException(); + } + + private void AppendQueryableAll(JsonQueryParameter jsonQueryParameter, JToken item) + { + var name = item.Path.ToLower(); + if (IsForm(name)) + { + AppendFrom(item); + } + else if (IsWhere(name)) + { + AppendWhere(item); + } + else if (IsOrderBy(name)) + { + AppendOrderBy(item); + } + else if (IsJoinLastAfter(name)) + { + ApendJoinLastAfter(item); + } + else if (IsGroupBy(name)) + { + AppendGroupBy(item); + } + else if (IsHaving(name)) + { + AppendHaving(item); + } + else if (IsSelect(name)) + { + jsonQueryParameter.IsSelect = AppendSelect(item); + } + else if (IsPageNumber(name)) + { + jsonQueryParameter.PageIndex = AppendPageNumber(item); + } + else if (IsPageSize(name)) + { + jsonQueryParameter.PageSize = AppendPageSize(item); + } + else if (IsJoin(name)) + { + jsonQueryParameter.IsSelect = AppendJoin(item); + } + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/Property.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/Property.cs new file mode 100644 index 000000000..24b7e0b4e --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/Property.cs @@ -0,0 +1,26 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace SqlSugar +{ + /// + /// Property + /// + public partial class JsonQueryableProvider : IJsonQueryableProvider + { + int appendIndex = 1000; + List appendTypeNames; + JObject jobject; + ISqlSugarClient context; + ISugarQueryable sugarQueryable; + JsonCommonProvider jsonCommonProvider; + List jsonTableConfigs = new List(); + bool IsDescription = false; + List TableInfos =new List (); + bool IsExecutedBeforeWhereFunc = false; + Action BeforeWhereFunc { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/RegisterAop.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/RegisterAop.cs new file mode 100644 index 000000000..bc769ff40 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/RegisterAop.cs @@ -0,0 +1,40 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; +namespace SqlSugar +{ + /// + /// RegisterAop + /// + public partial class JsonQueryableProvider : IJsonQueryableProvider + { + private void RegisterAop() + { + this.BeforeWhereFunc = () => + { + var masterTable = GetMasterTable(); + var masterFilters = this.jsonTableConfigs.Where(it => it.TableName.EqualCase(masterTable.Table)).ToList(); + if (masterFilters.Any()) + { + foreach (var filter in masterFilters) + { + var conditions = filter.Conditionals; + conditions=GetConvertConditions(conditions); + var p = this.sugarQueryable.SqlBuilder.ConditionalModelToSql(conditions); + var sql = p.Key; + sugarQueryable.SqlBuilder.RepairReplicationParameters(ref sql, p.Value, appendIndex); + appendIndex++; + sugarQueryable.Where(sql, p.Value); + }; + + } + }; + } + + private List GetConvertConditions(List conditions) + { + return conditions; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/ResultDefault.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/ResultDefault.cs new file mode 100644 index 000000000..a8188290d --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/ResultDefault.cs @@ -0,0 +1,49 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; +using Newtonsoft.Json.Linq; + +namespace SqlSugar +{ + + /// + /// ResultDefault + /// + public partial class JsonQueryableProvider : IJsonQueryableProvider + { + private List ToSqlDefault() + { + List result = new List(); + sugarQueryable = context.Queryable(); + appendTypeNames = GetTypeNames(); + JsonQueryParameter jsonQueryParameter = new JsonQueryParameter(); + RegisterAop(); + foreach (JToken item in appendTypeNames) + { + AppendQueryableAll(jsonQueryParameter, item); + } + return ToPageDefault(result, jsonQueryParameter); + } + + private List GetTypeNames() + { + var result= this.jobject.AsJEnumerable().ToList(); + result.Add(JToken.Parse("{JoinLastAfter:null}").First()); + result = result.OrderBy(it => GetSort(it.Path.ToLower())).ToList(); + return result; + } + + private JsonQueryResult ToResultDefault() + { + JsonQueryResult result = new JsonQueryResult(); + var toSqls = this.ToSqlList(); + var SqlCount = toSqls.FirstOrDefault(it => it.JsonSqlType == JsonProviderType.QueryableCount); + var SqlList = toSqls.FirstOrDefault(it => it.JsonSqlType == JsonProviderType.Queryable); + AddCount(result, SqlCount); + AddList(result, SqlList); + AddDescription(); + return result; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/ResultHelper.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/ResultHelper.cs new file mode 100644 index 000000000..c53444d07 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Queryable/ResultHelper.cs @@ -0,0 +1,66 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + /// + /// ResultHelper + /// + public partial class JsonQueryableProvider : IJsonQueryableProvider + { + #region SqlHelper + private List ToPageDefault(List result, JsonQueryParameter jsonQueryParameter) + { + if (jsonQueryParameter.IsPage) + { + AddPageSql(result, jsonQueryParameter); + } + else + { + AddDefaultSql(result); + } + Check.ExceptionEasy(jsonQueryParameter.JoinNoSelect, "join query need Select", "联表查询需要设置Select"); + return result; + } + + private void AddDefaultSql(List result) + { + result.Add(new SqlObjectResult(sugarQueryable.Clone().ToSql(), JsonProviderType.Queryable)); + } + + private void AddPageSql(List result, JsonQueryParameter jsonQueryParameter) + { + var skipValue = (jsonQueryParameter.PageIndex.Value - 1) * jsonQueryParameter.PageSize.Value; + var takeValue = jsonQueryParameter.PageSize.Value; + result.Add(new SqlObjectResult(sugarQueryable.Clone().Skip(skipValue).Take(takeValue).ToSql(), JsonProviderType.Queryable)); + result.Add(new SqlObjectResult(sugarQueryable.Select("COUNT(1)").ToSql(), JsonProviderType.QueryableCount)); + } + #endregion + + #region ObjectHeper + private void AddDescription() + { + if (this.IsDescription) + { + } + } + + private void AddList(JsonQueryResult result, SqlObjectResult SqlList) + { + if (SqlList != null) + { + result.Data = this.context.Ado.SqlQuery(SqlList.Sql, SqlList.Parameters); + } + } + + private void AddCount(JsonQueryResult result, SqlObjectResult SqlCount) + { + if (SqlCount != null) + { + result.ToTalRows = this.context.Ado.GetInt(SqlCount.Sql, SqlCount.Parameters); + } + } + #endregion + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/AppendRow.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/AppendRow.cs new file mode 100644 index 000000000..03aeeabbe --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/AppendRow.cs @@ -0,0 +1,25 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; +namespace SqlSugar +{ + public partial class JsonUpdateableProvider : IJsonUpdateableProvider + { + private void AppendRow(JToken item) + { + var itemFirst = item.First(); + var isObject = itemFirst.Type == JTokenType.Object; + var value = itemFirst.ToString(); + var dics = context.Utilities.JsonToColumnsModels(value); + if (isObject) + sugarUpdateable = this.context.Updateable(dics.First()).AS(this.TableName); + else + { + sugarUpdateable = this.context.Updateable(dics).AS(this.TableName); + isList = dics.Take(2).Count() > 0; + } + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/AppendTable.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/AppendTable.cs new file mode 100644 index 000000000..b4ee58609 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/AppendTable.cs @@ -0,0 +1,21 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; + +namespace SqlSugar +{ + public partial class JsonUpdateableProvider : IJsonUpdateableProvider + { + private void AppendTable(JToken item) + { + var tableInfo = jsonCommonProvider.GetTableName(item); + this.TableName = tableInfo.TableName; + if (tableInfo.ShortName.HasValue()) + { + this.TableName = tableInfo.ShortName + "." + tableInfo.TableName; + } + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/AppendWhere.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/AppendWhere.cs new file mode 100644 index 000000000..8c52dc479 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/AppendWhere.cs @@ -0,0 +1,19 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; + +namespace SqlSugar +{ + public partial class JsonUpdateableProvider : IJsonUpdateableProvider + { + private void AppendWhere(JToken item) + { + Check.Exception(isList, "Batch updates cannot use Where, only WhereColumns can set columns", "批量更新不能使用Where，只能通过WhereColumns设置列"); + var sqlObj = jsonCommonProvider.GetWhere(item, sugarUpdateable.UpdateBuilder.Context); + sugarUpdateable.Where(sqlObj.Key, sqlObj.Value); + } + + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/AppendWhereColumns.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/AppendWhereColumns.cs new file mode 100644 index 000000000..a4f90975e --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/AppendWhereColumns.cs @@ -0,0 +1,19 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; + +namespace SqlSugar +{ + public partial class JsonUpdateableProvider : IJsonUpdateableProvider + { + private void AppendWhereColumns(JToken item) + { + var columns = item.First().ToObject(); + Check.ExceptionEasy(columns.IsNullOrEmpty(), "need WhereColumns", "WhereColumns 需要设置列名"); + this.sugarUpdateable.WhereColumns(columns); + } + + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/Helpercs.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/Helpercs.cs new file mode 100644 index 000000000..9db462fb6 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/Helpercs.cs @@ -0,0 +1,31 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public partial class JsonUpdateableProvider : IJsonUpdateableProvider + { + + private static bool IsColumns(string name) + { + return name == "Columns".ToLower(); + } + + private static bool IsWhere(string name) + { + return name == "Where".ToLower(); + } + + private static bool IsWhereColumns(string name) + { + return name == "WhereColumns".ToLower(); + } + + private static bool IsTable(string name) + { + return name == JsonProviderConfig.KeyUpdateable.Get().ToLower(); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/JsonUpdateableProvider.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/JsonUpdateableProvider.cs new file mode 100644 index 000000000..6fcf92cc6 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Provider/Updateable/JsonUpdateableProvider.cs @@ -0,0 +1,82 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Linq; +namespace SqlSugar +{ + public partial class JsonUpdateableProvider : IJsonUpdateableProvider + { + private ISqlSugarClient context; + private JObject jObject; + private JsonCommonProvider jsonCommonProvider; + private string TableName { get; set; } + private bool isList { get; set; } + private IUpdateable> sugarUpdateable; + public JsonUpdateableProvider(ISqlSugarClient context, JObject jObject) + { + this.jObject = jObject; + this.context = context; + this.jsonCommonProvider = new JsonCommonProvider(context); + } + public JsonUpdateResult ToResult() + { + return null; + } + public SqlObjectResult ToSql() + { + return this.ToSqlList().First(); + } + public List ToSqlList() + { + List result = new List(); + JsonQueryParameter jsonQueryParameter = new JsonQueryParameter(); + List appendTypeNames = GetAppendTypes(); + foreach (JToken item in appendTypeNames) + { + AppendAll(jsonQueryParameter, item); + } + var addItem = this.sugarUpdateable.ToSql(); + result.Add(new SqlObjectResult(addItem,JsonProviderType.Updateable)); + return result; + } + + private List GetAppendTypes() + { + var appendTypeNames = this.jObject.AsJEnumerable().ToList(); + appendTypeNames = appendTypeNames.OrderBy(it => + { + if (it.Path.EqualCase(JsonProviderConfig.KeyUpdateable.Get())) return 0; + if (it.Path.EqualCase("Columns")) return 1; + else return 3; + + } ).ToList(); + return appendTypeNames; + } + + private void AppendAll(JsonQueryParameter jsonQueryParameter, JToken item) + { + var name = item.Path.ToLower(); + if (IsTable(name)) + { + AppendTable(item); + } + else if (IsWhereColumns(name)) + { + AppendWhereColumns(item); + } + else if (IsWhere(name)) + { + AppendWhere(item); + } + else if (IsColumns(name)) + { + AppendRow(item); + } + } + public List ToSqlString() + { + throw new NotImplementedException(); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Queryable/QueryableProvider.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Queryable/QueryableProvider.cs new file mode 100644 index 000000000..36c0b5f00 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Queryable/QueryableProvider.cs @@ -0,0 +1,49 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + + public partial class QueryableProvider : QueryableAccessory, ISugarQueryable + { + public ISugarQueryable AddJoinInfo(string tableName, string shortName, IFuncModel models, JoinType type = JoinType.Left) + { + var sqlobj = this.SqlBuilder.FuncModelToSql(models); + this.QueryBuilder.Parameters.AddRange(sqlobj.Value); + return this.AddJoinInfo(tableName, shortName, sqlobj.Key, type); + } + public ISugarQueryable AS(string tableName, string shortName) + { + return this.AS($"{this.SqlBuilder.GetTranslationTableName(tableName)} {shortName}"); + } + public ISugarQueryable OrderBy(List models) + { + var orderObj = this.SqlBuilder.OrderByModelToSql(models); + this.OrderBy(orderObj.Key); + this.QueryBuilder.Parameters.AddRange(orderObj.Value); + return this; + } + public ISugarQueryable GroupBy(List models) + { + var orderObj = this.SqlBuilder.GroupByModelToSql(models); + this.GroupBy(orderObj.Key); + this.QueryBuilder.Parameters.AddRange(orderObj.Value); + return this; + } + public ISugarQueryable Select(List models) + { + var orderObj = this.SqlBuilder.SelectModelToSql(models); + this.Select(orderObj.Key); + this.QueryBuilder.Parameters.AddRange(orderObj.Value); + return this; + } + public ISugarQueryable Having(IFuncModel model) + { + var orderObj = this.SqlBuilder.FuncModelToSql(model); + this.Having(orderObj.Key); + this.QueryBuilder.Parameters.AddRange(orderObj.Value); + return this; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Utils/Json2SqlConfig.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Utils/Json2SqlConfig.cs new file mode 100644 index 000000000..2b5a92361 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Utils/Json2SqlConfig.cs @@ -0,0 +1,35 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace SqlSugar +{ + public static class JsonProviderConfig + { + public const string KeyInsertable = "Insertable"; + public const string KeyUpdateable = "Updateable"; + public const string KeyQueryable = "Queryable"; + public const string KeyDeleteable = "Deleteable"; + + private static Dictionary words = new Dictionary() + { + { KeyInsertable,"Table"}, + { KeyUpdateable,"Table"}, + { KeyQueryable,"Table"}, + { KeyDeleteable,"Table"} + }; + public static string Rename(string key,string name) + { + return words[key]=name; + } + internal static string Get(this string value) + { + return words[value]; + } + internal static string GetWord(string key) + { + Check.ExceptionEasy(words.ContainsKey(key) == false, $"{key} is error", $"{key} 不存在 "); + return words[key]; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/Json2Sql/Utils/Json2SqlHelper.cs b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Utils/Json2SqlHelper.cs new file mode 100644 index 000000000..3d2448809 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/Json2Sql/Utils/Json2SqlHelper.cs @@ -0,0 +1,39 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Text; +using System.Text.RegularExpressions; +using System.Linq; +namespace SqlSugar +{ + internal class Json2SqlHelper + { + public static bool IsSqlValue(string valueString) + { + return Regex.IsMatch(valueString, @"^\{\w{1,10}\}\:"); + } + public static string GetType(string valueString) + { + return Regex.Match(valueString, @"^\{(\w+)\}\:").Groups[1].Value; + } + public static string GetValue(string valueString) + { + return Regex.Replace(valueString, @"^\{\w{1,10}\}\:", ""); + } + + public static List GetTableNames(string json) + { + List result = new List(); + var mainTable = JObject.Parse(json).AsJEnumerable().Where(it => + it.Path.ToLower().IsIn( + JsonProviderConfig.KeyInsertable.Get().ToLower(), + JsonProviderConfig.KeyUpdateable.Get().ToLower(), + JsonProviderConfig.KeyDeleteable.Get().ToLower(), + JsonProviderConfig.KeyQueryable.Get().ToLower() + )).FirstOrDefault(); + if (mainTable != null) + result.Add(mainTable.First().ToString()); + return result; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSugar/JsonClient.cs b/Src/Asp.NetCore2/SqlSugar/JsonClient.cs new file mode 100644 index 000000000..aee30582d --- /dev/null +++ b/Src/Asp.NetCore2/SqlSugar/JsonClient.cs @@ -0,0 +1,38 @@ +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using SqlSugar; +namespace SqlSugar +{ + public class JsonClient : IJsonClient + { + public ISqlSugarClient Context { get; set; } + + public IJsonQueryableProvider Queryable(string json) + { + var iJsonToSql = new JsonQueryableProvider(Context, JObject.Parse(json)); + return iJsonToSql; + } + public IJsonProvider Insertable(string json) + { + var iJsonToSql = new JsonInsertableProvider(Context, JObject.Parse(json)); + return iJsonToSql; + } + public IJsonProvider Updateable(string json) + { + var iJsonToSql = new JsonUpdateableProvider(Context, JObject.Parse(json)); + return iJsonToSql; + } + public IJsonProvider Deleteable(string json) + { + var iJsonToSql = new JsonDeleteableProvider(Context, JObject.Parse(json)); + return iJsonToSql; + } + public List GetTableNameList(string json) + { + List result = Json2SqlHelper.GetTableNames(json); + return result; + } + } +}