public static MsgModel <dynamic> EditRetUpdateForm(IDbBuilder dbb)
{
return(EditRetUpdateForm(new List <IDbBuilder>()
{
dbb
}));
}
public DapperDbContext(IDbBuilder dbBuilder, ICommandBuilder commandBuilder, string conStr)
{
_dbBuilder = dbBuilder;
CommandBuilder = commandBuilder;
ConnectionString = conStr;
ObjectCollection = new ObjectContextCollection();
}
public static IServiceCollection AddMySql(this IDbBuilder builder, string connectString)
{
return(builder.AddMySql(testc =>
{
testc.ConnectionString = connectString;
}));
}
void ParseChild(IDbBuilder parent, SqlConfig sqlSetting, JObject jobj)
{
JArray jArray = null;
var data = (JObject)jobj[sqlSetting.JsonName.Trim()];
if (data == null)
{
return;
}
if (data["inserted"] != null && data["inserted"].HasValues)
{
jArray = data["inserted"] as JArray;
PopulateParaList(sqlSetting, jArray, OperateType.Insert, parent);
}
if (data["updated"] != null && data["updated"].HasValues)
{
jArray = data["updated"] as JArray;
PopulateParaList(sqlSetting, jArray, OperateType.Update, parent);
}
if (data["deleted"] != null && data["deleted"].HasValues)
{
jArray = data["deleted"] as JArray;
PopulateParaList(sqlSetting, jArray, OperateType.Delete, parent);
}
if (data["na"] != null && data["na"].HasValues)
{
jArray = data["na"] as JArray;
PopulateParaList(sqlSetting, jArray, OperateType.NA, parent);
}
}
public static bool Unique(IDbContext db, IDbBuilder dbb, out List <DbField> fields)
{
var data = dbb.Data;
fields = new List <DbField>();
string sql = "select count(0) from " + data.TableName + " where 1=1 ";
var paras = new List <object>();
if (data.Operator == OperateType.Update)
{
int i = 0;
foreach (var field in data.AllFields.Where(x => x.IsPk))
{
sql += " And " + field.Name + " <> @" + i++;
paras.Add(field.Value);
}
}
foreach (var f in data.AllFields.Where(x => x.IsUnique))
{
var builder = db.Sql(sql + " And " + f.Name + " = @" + f.Name, paras.ToArray()).Parameter(f.Name, f.Value);
var isUnique = builder.QuerySingle <int>() == 0;
if (!isUnique)
{
fields.Add(f);
}
}
return(!fields.Any());
}
public static int Update(IDbBuilder dbb, IDbContext db)
{
var data = dbb.Data;
if (!data.Fields.Any())
{
return(0);
}
if (string.IsNullOrEmpty(data.TableName))
{
throw new Exception("Table cannot be empty or nothing");
}
if (db == null)
{
db = Db;
}
var builder = db.Update(data.TableName);
if (data.Wheres.Any())
{
data.Wheres.ForEach(x =>
{
builder.AddWhere(string.Format(" {0} {1} = @{2}", x.LogicalKey, x.DbName, x.ParamName));
});
}
if (!string.IsNullOrEmpty(data.Where))
{
builder.AddWhere(data.Where);
}
data.Fields.ForEach(x =>
{
if (x.IsId)
{
return;
}
if (x.Value + "" == "")
{
x.Value = DBNull.Value;
}
builder.Column(x.DbName, x.Value);
});
if (data.Params.Any())
{
data.Params.ForEach(x =>
{
if (!builder.Data.Columns.Any(o => o.ParameterName == x.ParamName))
{
builder.AddWhereParam(x.ParamName, x.Value);
}
});
}
return(builder.Execute());
}
public static void Insert(IDbBuilder dbb, IDbContext db)
{
if (db == null)
{
db = Db;
}
var data = dbb.Data;
// update dependency filed value
if (data.Parent != null)
{
data.AllFields.ForEach(x =>
{
if (x.DependencyField != null)
{
x.Value = x.DependencyField.Value;
}
});
}
var ib = db.Insert(data.TableName);
data.Fields.ForEach(x =>
{
if (x.IsId)
{
return;
}
if (!string.IsNullOrEmpty(x.DbName) && !string.IsNullOrEmpty(x.Value + ""))
{
ib.Column(x.DbName, x.Value);
}
});
var idField = data.AllFields.FirstOrDefault(x => x.IsId);
if (idField == null)
{
idField = data.Fields.FirstOrDefault(x => x.IsId);
}
if (idField != null)
{
// update id field for later using
idField.Value = ib.ExecuteReturnLastId <string>();
}
else
{
ib.Execute();
}
}
void InitSystemField(IDbBuilder builder)
{
var fields = builder.Data.AllFields;
//created user id
var f = fields.FirstOrDefault(x => x.DbName.EndsWith("CreatedUserId"));
if (f != null)
{
f.Value = this.Data.ProxyData.SystemUserId;
}
//created date
f = fields.FirstOrDefault(x => x.DbName.EndsWith("CreatedDate"));
if (f != null)
{
f.Value = this.Data.ProxyData.SystemDateTime;
}
//updated user id
f = fields.FirstOrDefault(x => x.DbName.EndsWith("UpdatedUserId"));
if (f != null)
{
f.Value = this.Data.ProxyData.SystemUserId;
}
//updated date
f = fields.FirstOrDefault(x => x.DbName.EndsWith("UpdatedDate"));
if (f != null)
{
f.Value = this.Data.ProxyData.SystemDateTime;
}
//if (builder.Data.Operator == OperateType.Insert)
//{
// //updated user id
// f = fields.FirstOrDefault(x => x.DbName.EndsWith("creater"));
// if (f != null)
// f.Value = this.Data.ProxyData.SystemUserId;
// //updated date
// f = fields.FirstOrDefault(x => x.DbName.EndsWith("createtime"));
// if (f != null)
// f.Value = this.Data.ProxyData.SystemDateTime;
//}
//updated user id
//f = fields.FirstOrDefault(x => x.DbName.EndsWith("updater"));
//if (f != null)
// f.Value = this.Data.ProxyData.SystemUserId;
////updated date
//f = fields.FirstOrDefault(x => x.DbName.EndsWith("updatetime"));
//if (f != null)
// f.Value = this.Data.ProxyData.SystemDateTime;
}
public static void CheckUnique(IDbContext db, IDbBuilder dbb)
{
string fieldStr = "";
var data = dbb.Data;
List <DbField> chkUinqueFailedFields = new List <DbField>();
if (!Unique(db, dbb, out chkUinqueFailedFields))
{
chkUinqueFailedFields.ForEach(x =>
{
fieldStr += x.Name + ",";
});
throw new UniqueException("验证唯一性失败：" + fieldStr.TrimEnd(','));
}
}
public static void CheckUnique(IDbContext db, IDbBuilder dbb)
{
string fieldStr = "";
var data = dbb.Data;
List <DbField> chkUinqueFailedFields = new List <DbField>();
if (!Unique(db, dbb, out chkUinqueFailedFields))
{
chkUinqueFailedFields.ForEach(x =>
{
fieldStr += x.Name + ",";
});
throw new Exception("{\"status\":false,\"msg_code\":\"__unique_error\",\"right_msg\":\"" + fieldStr.TrimEnd(',') + "\"}");
}
}
void PopulateParaList(SqlConfig setting, JArray dataArray, OperateType type, IDbBuilder parent)
{
dataArray.ToList().ForEach(x =>
{
var parserData = new ParserData(this.Data, (JObject)x["data"], setting, type, parent);
IDbBuilder builder = new Parser(parserData, GetSystemFieldValue).ToBuilder();
InitSystemField(builder);
if (setting.Children != null && setting.Children.Any() && (JObject)x["children"] != null)
{
foreach (var sqlSetting in setting.Children)
{
ParseChild(builder, sqlSetting, (JObject)x["children"]);
}
}
});
}
public static int Delete(IDbBuilder dbb)
{
using (var db = Db.UseTransaction(true))
{
try
{
var count = Delete(dbb, db);
db.Commit();
return(count);
}
catch (Exception ex)
{
db.Rollback();
throw ex;
}
}
}
public static int StatusDelete(IDbBuilder dbb, IDbContext db)
{
var builder = db.Update(dbb.Data.TableName);
var data = dbb.Data;
//builder.Column("is_deleted", true);
builder.Column("IsDeleted", true);
if (data.Wheres.Any())
{
foreach (var ws in data.Wheres)
{
builder.AddWhere(string.Format(" {0} {1} = @{2} ", ws.LogicalKey.ToString(), ws.DbName, ws.ParamName));
}
data.Params.ForEach(x =>
{
builder.AddWhereParam(x.ParamName, x.Value);
});
}
return(builder.Execute());
}
/// <summary>
/// Adds the my sql.
/// </summary>
/// <param name="builder"></param>
/// <param name="action">The action.</param>
/// <returns>An IServiceCollection.</returns>
public static IServiceCollection AddMySql(this IDbBuilder builder, Action <MySqlOption> action = null)
{
var services = builder.Service;
services.TryAddScoped <DbDatabase, MySqlDbDatabase>();
services.TryAddScoped <DbData, MySqlDbData>();
services.TryAddScoped <DbTable, MySqlDbTable>();
services.TryAddScoped <DbIndex, MySqlDbIndex>();
services.TryAddScoped <DbColumns, MySqlDbColumns>();
services.TryAddScoped <IDbProvider, MySqlDbProvider>();
services.TryAddSingleton <DbOption>(t =>
{
var option = new MySqlOption();
action?.Invoke(option);
return(option);
});
services.TryAddScoped <ISqlBuilder, MySqlSqlBuilder>();
services.TryAddScoped <ITransactionManager, MySqlTransactionManager>();
services.TryAddScoped <DbContext, MySqlDbContext>();
services.AddSingleton <TypeMap, MySqlTypeMap>();
return(services);
}
private async Task <IMongoDatabase> GetDatabase(IDbBuilder builder)
{
IMongoClient client = new MongoClient(await builder.GetConnectionString());
return(client.GetDatabase(await builder.GetDatabaseName()));
}
public ParserData(StrategyData <JObject> sd, JObject rawData, SqlConfig setting, OperateType operateType, IDbBuilder parent)
{
this.StrategyData = sd;
this.RawData = rawData;
this.Builder = new DbBuilder(setting);
Builder.Data.Operator = operateType;
parent.AddChild(this.Builder);
}
public IDbBuilder AddChild(IDbBuilder child)
{
child.Data.Parent = this;
this.Data.Children.Add(child);
return(this);
}
public static void Edit(IDbBuilder dbb, IDbContext db)
{
var data = dbb.Data;
switch (data.Operator)
{
case OperateType.Insert:
CheckUnique(db, dbb);
Insert(dbb, db);
break;
case OperateType.Update:
CheckUnique(db, dbb);
Update(dbb, db);
break;
case OperateType.Delete:
Delete(dbb, db);
break;
default:
break;
}
if (data.Setting != null && data.Setting.Children.Where(x => x.DeleteAnyway).Any())
{
// delete children
// 任何情况下都对子表进行删除操作
data.Setting.Children.Where(x => x.DeleteAnyway).ToList().ForEach(c =>
{
if (!c.Dependency.Fields.Any())
{
return;
}
var dependencyFields = new List <DbField>();
c.Dependency.Fields.ForEach(df =>
{
dependencyFields.Add(new DbField {
DbName = df.DbName, DependencyField = data.AllFields.FirstOrDefault(x => x.DbName == df.DependencyName)
});
});
DeleteChildrenBySetting(db, c, dependencyFields);
});
}
// all delete operation has been excute iterally in DeleteCheck method
// 只是在进行 插入和更新操作时，对子表进行删除操作
if (data.Operator != OperateType.Delete && data.Children != null && data.Children.Count > 0)
{
if (data.Children[0].Data.DeleteAnyway && data.Children[0].Data.Operator != OperateType.Delete)
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat("delete from {0} ", data.Children[0].Data.TableName);
var depFields = data.Children[0].Data.AllFields.Where(x => x.DependencyField != null);
var para = new List <DbField>();
if (depFields.Count() > 0)
{
sb.Append(" where 1=1 ");
int i = 0;
foreach (var field in depFields)
{
sb.AppendFormat(" And {0} = @__p{1} ", field.DbName, ++i);
para.Add(new DbField {
ParamName = "__p" + i, Value = field.DependencyField.Value
});
}
ExecuteSql(db, sb.ToString(), para.ToArray());
}
}
foreach (var paramBase in data.Children.ToList().OrderByDescending(x => x.Data.Operator))
{
Edit(paramBase, db);
}
}
}
public BaseContext(IDbBuilder builder)
{
this.builder = builder;
}
public OriginalBaseRepository(IDbBuilder builder)
{
DbBuilder = builder;
Initialize();
}
protected BaseContext(IDbBuilder builder)
{
_database = GetDatabase(builder).GetAwaiter().GetResult();
}
public OriginalBaseRepository(IDbBuilder dbBuilder, IMongoDatabase mongoDatabase)
{
this.DbBuilder = dbBuilder;
this.MongoDatabase = mongoDatabase;
}
public static int Delete(IDbBuilder dbb, IDbContext db)
{
if (db == null)
{
db = Db;
}
var data = dbb.Data;
if (!data.DeleteAnyway)
{
return(StatusDelete(dbb, db));
}
// delete children
if (data.Setting != null && data.Setting.Children.Any())
{
data.Setting.Children.ForEach(c =>
{
if (!c.Dependency.Fields.Any())
{
return;
}
var dependencyFields = new List <DbField>();
c.Dependency.Fields.ForEach(df =>
{
//dependencyFields.Add(new DbField { DbName = df.DbName, DependencyField = data.AllFields.FirstOrDefault(x => x.DbName == df.DependencyName) });
//var child = data.Children.FirstOrDefault(o => o.Data.TableName == c.Table);
var pdf = data.AllFields.FirstOrDefault(x => x.DbName == df.DependencyName);
if (pdf == null)
{
pdf = data.Fields.FirstOrDefault(x => x.DbName == df.DependencyName);
}
if (pdf == null)
{
pdf = data.Parent.Data.AllFields.FirstOrDefault(m => m.Name == df.DependencyName);
}
dependencyFields.Add(new DbField {
DbName = df.DbName, DependencyField = pdf
});
});
DeleteChildrenBySetting(db, c, dependencyFields);
});
}
var buider = db.Delete(data.TableName);
if (data.Wheres.Any())
{
foreach (var ws in data.Wheres)
{
buider.AddWhere(string.Format(" {0} {1} = @{2} ", ws.LogicalKey.ToString(), ws.DbName, ws.ParamName));
}
data.Params.ForEach(x =>
{
buider.AddWhereParam(x.ParamName, x.Value);
});
}
if (!string.IsNullOrEmpty(data.Where))
{
buider.AddWhere(data.Where);
}
return(buider.Execute());
}
private void Init()
{
// prevent design time error in xaml designer
if (System.ComponentModel.DesignerProperties.GetIsInDesignMode(new DependencyObject()))
{
_contextProvider = new FakeDataContextProvider();
}
else
{
_contextProvider = new GameDataContextProvider();
}
_tpApiWrapper = new TradingPostApiWrapper(new ApiAccessor(new WebClientProvider()));
_dataUpdater = new ApiDataUpdater(_tpApiWrapper);
_dbBuilder = new DbBuilder(_tpApiWrapper, _contextProvider);
_dbBuilder.BuildDatabase();
using (var context = _contextProvider.GetContext())
{
_sharedItems = context.GameItems.ToList();
}
_sharedItemDictionary = _sharedItems.ToDictionary(item => item.ItemId, item => item);
Task.Run(() => _dataUpdater.UpdatePricesParallel(_sharedItems));
}
public static int Update(IDbBuilder dbb)
{
return(Update(dbb, null));
}
public MongoRepository(IDbBuilder dbBuilder, IMongoDatabase mongoDatabase)
{
this.DbBuilder = dbBuilder;
this.MongoDatabase = mongoDatabase;
}
public UsersDB(IDbBuilder dbBuilder)
{
_db = dbBuilder.GetDB();
}
public BaseRepository(IDbBuilder builder)
{
DbBuilder = builder;
Task.WaitAll(Initialize());
}
public SettingsViewModel(IDbBuilder dbBuilder)
{
ViewModelName = "Settings";
_dbBuilder = dbBuilder;
}
public MongoRepository(IDbBuilder builder)
{
DbBuilder = builder;
Initialize();
}
