/// <summary>
/// Modify
/// </summary>
/// <param name="modifyExpression">Modify expression</param>
/// <param name="query">Query object</param>
/// <returns>Return the activation record</returns>
public IActivationRecord Modify(IModify modifyExpression, IQuery query, ActivationOption activationOption = null)
{
WarehouseManager.Modify <TEntity>(modifyExpression, query);
var record = DefaultActivationRecord <TEntity, TDataAccess> .CreateModifyRecord(modifyExpression, query, activationOption);
return(record);
}
/// <summary>
/// create a new IModify object
/// </summary>
/// <typeparam name="T">Model Type</typeparam>
/// <param name="fields">fields</param>
/// <returns>IModify object</returns>
public static IModify Create <T>(params Expression <Func <T, dynamic> >[] fields)
{
IModify modify = Create();
modify.Set <T>(fields);
return(modify);
}
/// <summary>
/// modify
/// </summary>
/// <param name="modifyExpression">modify expression</param>
/// <param name="query">query</param>
/// <returns></returns>
public async Task <IActivationRecord> ModifyAsync(IModify modifyExpression, IQuery query)
{
await WarehouseManager.ModifyAsync <ET>(modifyExpression, query);
var record = DefaultActivationRecord <ET, DAI> .CreateModifyRecord(modifyExpression, query);
return(record);
}
/// <summary>
/// create modify record
/// </summary>
/// <param name="modify">modify expression</param>
/// <param name="query">query object</param>
/// <param name="activationOption">activation option</param>
/// <returns></returns>
public static DefaultActivationRecord <ET, DAI> CreateModifyRecord(IModify modify, IQuery query, ActivationOption activationOption)
{
var record = CreateRecord(ActivationOperation.ModifyByExpression, null, activationOption);
record.ModifyExpression = modify;
record.Query = query;
return(record);
}
public void Do(IModify modify)
{
modify.Execute();
unDoModifies.Add(modify);
if (unDoModifies.Count > 100)
{
unDoModifies.RemoveAt(0);
}
}
/// <summary>
/// Execute
/// </summary>
/// <param name="modify">Modeify expression</param>
/// <param name="query">Query object</param>
/// <param name="activationOption">Activation option</param>
/// <returns>Return repository event execute result</returns>
public IRepositoryEventExecuteResult Execute(IModify modify, IQuery query, ActivationOption activationOption = null)
{
if (modify == null || Operation == null)
{
return(DataOperationEventExecuteResult.Empty);
}
Operation(modify, query, activationOption);
return(DataOperationEventExecuteResult.Empty);
}
/// <summary>
/// execute
/// </summary>
/// <returns></returns>
public IRepositoryEventHandleResult Execute(IModify modify, IQuery query)
{
if (modify == null || Operation == null)
{
return(DataOperationEventResult.Empty);
}
Operation(modify, query);
return(DataOperationEventResult.Empty);
}
/// <summary>
/// Modify data
/// </summary>
/// <param name="modifyExpression">Modify expression</param>
/// <param name="query">Query condition</param>
/// <returns>Return a ICommand object</returns>
public virtual ICommand Modify(IModify modifyExpression, IQuery query)
{
return(dataCacheProvider.Modify <TEntity>(new ModifyByConditionCacheCommand <TEntity>()
{
Query = query,
Modify = modifyExpression,
ModifyDatabaseDataProxy = databaseAccess.Modify,
GetDataListProxy = databaseAccess.GetList
}));
}
public Set(IDbConnection connection, ISQLConfiguration configuration, Assembly assembly, Contracts.IQuery <T> query, IPersist <T> persist, IModify <T> modify, IDelete <T> delete)
{
this.connection = connection;
this.configuration = configuration;
this.assembly = assembly;
Query = query;
Persist = persist;
Modify = modify;
Delete = delete;
}
/// <summary>
/// Modify
/// </summary>
/// <typeparam name="TEntity">Entity type</typeparam>
/// <param name="modifyExpression">Modify expression</param>
/// <param name="query">Query object</param>
/// <returns></returns>
public static void Modify <TEntity>(IModify modifyExpression, IQuery query) where TEntity : BaseEntity <TEntity>, new()
{
var warehouse = GetWarehouse <TEntity>();
if (warehouse == null)
{
throw NotInitUnitWork();
}
warehouse.Modify(modifyExpression, query);
}
/// <summary>
/// Modify Object
/// </summary>
/// <param name="expression">modify expression</param>
/// <param name="query">query model</param>
public sealed override async Task ModifyAsync(IModify expression, IQuery query)
{
var record = await ExecuteModifyAsync(expression, query).ConfigureAwait(false);
if (record == null)
{
return;
}
RepositoryEventBus.PublishModify <DT>(GetType(), expression, query);
WorkFactory.RegisterActivationRecord(record);
}
/// <summary>
/// modify
/// </summary>
/// <typeparam name="ET"></typeparam>
/// <param name="modifyExpression">modify expression</param>
/// <param name="query">query</param>
/// <returns></returns>
public static async Task ModifyAsync <ET>(IModify modifyExpression, IQuery query) where ET : BaseEntity <ET>
{
var warehouse = GetWarehouse <ET>();
if (warehouse == null)
{
throw NotInitUnitWork();
}
warehouse.Modify(modifyExpression, query);
await Task.CompletedTask;
}
protected override async Task <IActivationRecord> ExecuteModifyAsync(IModify expression, IQuery query)
{
var repository = GetRepositoryByQuery(query);
if (repository == null)
{
return(null);
}
await repository.ModifyAsync(expression, query).ConfigureAwait(false);
return(EmptyActivationRecord.Default);
}
/// <summary>
/// Modify data
/// </summary>
/// <param name="expression">Modify expression</param>
/// <param name="query">Query object</param>
/// <param name="activationOption">Activation option</param>
public sealed override void Modify(IModify expression, IQuery query, ActivationOption activationOption = null)
{
var newQuery = RepositoryManager.HandleQueryObjectBeforeExecute(query, QueryUsageScene.Modify, AppendModifyCondition);
var record = ExecuteModify(expression, newQuery, activationOption);
if (record != null)
{
RepositoryEventBus.PublishModify <TModel>(GetType(), expression, newQuery, activationOption);
WorkManager.RegisterActivationRecord(record);
RepositoryManager.HandleQueryObjectAfterExecute(query, newQuery, QueryUsageScene.Modify);
}
}
/// <summary>
/// modify data
/// </summary>
/// <param name="expression">modify expression</param>
/// <param name="query">query object</param>
/// <param name="activationOption">activation option</param>
public sealed override async Task ModifyAsync(IModify expression, IQuery query, ActivationOption activationOption = null)
{
//append condition
query = AppendModifyCondition(query);
var record = await ExecuteModifyAsync(expression, query, activationOption).ConfigureAwait(false);
if (record == null)
{
return;
}
RepositoryEventBus.PublishModify <T>(GetType(), expression, query, activationOption);
WorkFactory.RegisterActivationRecord(record);
}
/// <summary>
/// 修改排序
/// </summary>
/// <param name="newSort">新排序,排序编号必须大于0</param>
public void ModifySort(int newSort)
{
if (newSort <= 0)
{
throw new Exception("请填写正确的角色排序");
}
sort = newSort;
//其它角色顺延
IQuery sortQuery = QueryFactory.Create <RoleQuery>(r => r.Parent == (parent.CurrentValue == null ? 0 : parent.CurrentValue.SysNo) && r.Sort >= newSort);
IModify modifyExpression = ModifyFactory.Create();
modifyExpression.Add <RoleQuery>(r => r.Sort, 1);
repository.Modify(modifyExpression, sortQuery);
}
/// <summary>
/// 修改排序
/// </summary>
/// <param name="newSort">新排序,排序编号必须大于0</param>
public void ModifySort(int newSort)
{
if (newSort <= 0)
{
throw new Exception("请填写正确的排序编号");
}
Sort = newSort;
//其它分组顺延
IQuery sortQuery = QueryManager.Create <AuthorityGroupQuery>(r => r.Parent == (parent.CurrentValue == null ? 0 : parent.CurrentValue.SysNo) && r.Sort >= newSort);
IModify modifyExpression = ModifyFactory.Create();
modifyExpression.Add <AuthorityGroupQuery>(r => r.Sort, 1);
repository.Modify(modifyExpression, sortQuery);
}
/// <summary>
/// 修改排序
/// </summary>
/// <param name="newSortIndex">新排序,排序编号必须大于0</param>
public void ModifySortIndex(int newSortIndex)
{
if (newSortIndex <= 0)
{
throw new Exception("请填写正确的角色排序");
}
_sortIndex = newSortIndex;
//其它角色顺延
IQuery sortQuery = QueryFactory.Create <RoleQuery>(r => r.Parent == (_parent.CurrentValue == null ? 0 : _parent.CurrentValue.SysNo) && r.SortIndex >= newSortIndex);
IModify modifyExpression = ModifyFactory.Create();
modifyExpression.Add <RoleQuery>(r => r.SortIndex, 1);
roleRepository.Modify(modifyExpression, sortQuery);
}
/// <summary>
/// 修改排序
/// </summary>
/// <param name="newSort">新排序,排序编号必须大于0</param>
public void ModifySort(int newSort)
{
if (newSort < 1)
{
throw new Exception("请填写正确的排序号");
}
Sort = newSort;
//同级后面的数据排序顺延
var parentId = parent.CurrentValue?.Id ?? 0;
IQuery sortQuery = QueryManager.Create <OperationGroupEntity>(r => r.Parent == parentId && r.Sort >= newSort);
IModify modifyExpression = ModifyFactory.Create();
modifyExpression.Add <OperationGroupEntity>(r => r.Sort, 1);
repository.Modify(modifyExpression, sortQuery);
}
public IModify Undo()
{
if (unDoModifies.Count > 0)
{
IModify modify = unDoModifies[unDoModifies.Count - 1];
unDoModifies.Remove(modify);
modify.UnDo();
reDoModifies.Add(modify);
if (reDoModifies.Count > 100)
{
reDoModifies.RemoveAt(0);
}
return(modify);
}
return(null);
}
/// <summary>
/// display NPC dialog
/// </summary>
/// <param name="npc"></param>
public void DisplayTalkTo(NPC npc)
{
ISpeak speakingNpc = npc as ISpeak;
IModify modifyingNpc = npc as IModify;
string message = speakingNpc.Speak();
if (message == "")
{
message = "It appears this character has nothing to say. Please try agian.";
}
DisplayGamePlayScreen("Speak to Character", message, ActionMenu.NpcMenu, "");
_gamePlayer.Health += modifyingNpc.HealthModifier;
}
public IModify ReDo()
{
if (reDoModifies.Count > 0)
{
IModify modify = reDoModifies[reDoModifies.Count - 1];
reDoModifies.Remove(modify);
modify.Execute();
unDoModifies.Add(modify);
if (unDoModifies.Count > 100)
{
unDoModifies.RemoveAt(0);
}
return(modify);
}
return(null);
}
/// <summary>
/// modify
/// </summary>
/// <param name="modifyExpression">modify expression</param>
/// <param name="query">query</param>
public void Modify(IModify modifyExpression, IQuery query)
{
if (modifyExpression == null)
{
return;
}
modifyExpressions.Add(new Tuple <IModify, IQuery>(modifyExpression, query));
var queryFunc = query?.GetQueryExpression <T>();
foreach (var item in Datas)
{
if (queryFunc?.Invoke(item.Value.WarehouseData) ?? true)
{
item.Value?.Modify(modifyExpression);
}
}
}
/// <summary>
/// Publish modify event
/// </summary>
/// <param name="eventSource">Event source type</param>
/// <param name="eventType">Event type</param>
/// <param name="query">Query</param>
/// <param name="activationOptions">Activation options</param>
/// <param name="callback">Callback</param>
public static void PublishModify <TObject>(Type eventSource, IModify modify, IQuery query, ActivationOptions activationOptions = null, RepositoryEventCallback callback = null)
{
var eventHandlers = GetEventHandlers(eventSource, EventType.ModifyExpression, typeof(TObject));
if (!eventHandlers.IsNullOrEmpty())
{
foreach (var handler in eventHandlers)
{
ModifyEventHandler eventHandler = handler as ModifyEventHandler;
if (eventHandler == null)
{
continue;
}
eventHandler.Execute(modify, query, activationOptions);
}
}
callback?.Invoke(DataOperationEventExecuteResult.Empty);
}
/// <summary>
/// edit data with expression
/// </summary>
/// <param name="modifyExpression">modify expression</param>
/// <param name="query">Query object</param>
/// <returns>ICommand object</returns>
public ICommand Modify(IModify modifyExpression, IQuery query)
{
Dictionary <string, IModifyValue> fieldAndValues = modifyExpression.GetModifyValues();
if (fieldAndValues == null || fieldAndValues.Count <= 0)
{
return(null);
}
#region control version
string versionFieldName = EntityManager.GetVersionField(typeof(TEntity));
if (!string.IsNullOrWhiteSpace(versionFieldName))
{
if (!fieldAndValues.ContainsKey(versionFieldName))
{
fieldAndValues.Add(versionFieldName, new CalculateModifyValue(CalculateOperator.Add, 1));
}
}
#endregion
#region update date
string refreshFieldName = EntityManager.GetRefreshDateField(typeof(TEntity));
if (!string.IsNullOrWhiteSpace(refreshFieldName))
{
if (!fieldAndValues.ContainsKey(refreshFieldName))
{
fieldAndValues.Add(refreshFieldName, new FixedModifyValue(DateTimeOffset.Now));
}
}
#endregion
var command = ExecuteModifyExpression(fieldAndValues, query);
//publish modify expression event
DataAccessEventBus.PublishModifyExpressionEvent <TEntity>(fieldAndValues, query);
return(command);
}
/// <summary>
/// Modify data
/// </summary>
/// <param name="data">Data</param>
/// <param name="modify">Modify expression</param>
void ModifyData(TEntity data, IModify modify)
{
if (data == null || modify == null)
{
return;
}
var modifyValues = modify.GetModifyValues() ?? new Dictionary <string, IModifyValue>(0);
if (modifyValues.Count < 1)
{
return;
}
foreach (var mv in modifyValues)
{
var nowValue = data.GetPropertyValue(mv.Key);
var modifyValue = mv.Value;
var newValue = modifyValue.GetModifyValue(nowValue);
data.SetPropertyValue(mv.Key, newValue);
}
}
/// <summary>
/// edit data with expression
/// </summary>
/// <param name="modifyExpression">modify expression</param>
/// <param name="query">query object</param>
/// <returns>ICommand object</returns>
public virtual async Task <ICommand> ModifyAsync(IModify modifyExpression, IQuery query)
{
Dictionary <string, dynamic> fieldAndValues = modifyExpression.GetModifyValues();
if (fieldAndValues == null || fieldAndValues.Count <= 0)
{
return(null);
}
#region control version
string versionFieldName = QueryConfig.GetVersionField(typeof(T));
if (!string.IsNullOrWhiteSpace(versionFieldName))
{
if (!fieldAndValues.ContainsKey(versionFieldName))
{
fieldAndValues.Add(versionFieldName, new CalculateModify()
{
Calculate = CalculateOperator.Add,
Value = 1
});
}
}
#endregion
#region update date
string refreshFieldName = QueryConfig.GetRefreshDateField(typeof(T));
if (!string.IsNullOrWhiteSpace(refreshFieldName))
{
if (!fieldAndValues.ContainsKey(refreshFieldName))
{
fieldAndValues.Add(refreshFieldName, DateTime.Now);
}
}
#endregion
return(await UpdateAsync(fieldAndValues.Keys, fieldAndValues, query).ConfigureAwait(false));
}
/// <summary>
/// edit data with expression
/// </summary>
/// <param name="modifyExpression">modify expression</param>
/// <param name="query">query object</param>
/// <returns>ICommand object</returns>
public virtual ICommand Modify(IModify modifyExpression, IQuery query)
{
Dictionary <string, dynamic> fieldAndValues = modifyExpression.GetModifyValues();
if (fieldAndValues == null || fieldAndValues.Count <= 0)
{
return(null);
}
#region 版本控制
string versionFieldName = QueryConfig.GetVersionField(typeof(T));
if (!string.IsNullOrWhiteSpace(versionFieldName))
{
if (!fieldAndValues.ContainsKey(versionFieldName))
{
fieldAndValues.Add(versionFieldName, new CalculateModify()
{
Calculate = CalculateOperator.Add,
Value = 1
});
}
}
#endregion
#region 更新时间
string refreshFieldName = QueryConfig.GetRefreshDateField(typeof(T));
if (!string.IsNullOrWhiteSpace(refreshFieldName))
{
if (!fieldAndValues.ContainsKey(refreshFieldName))
{
fieldAndValues.Add(refreshFieldName, DateTime.Now);
}
}
#endregion
return(Update(fieldAndValues.Keys, fieldAndValues, query));
}
/// <summary>
/// Modify
/// </summary>
/// <param name="modify">Modify expression</param>
public void Modify(IModify modify)
{
if (modify == null)
{
return;
}
if (Operate == WarehouseDataOperate.Remove)
{
return;
}
if (WarehouseData != null)
{
ModifyData(WarehouseData, modify);
}
if (LifeSource == DataLifeSource.DataSource) // modify data source value
{
if (PersistentData != null)
{
ModifyData(PersistentData, modify);
}
ComparisonData();
}
}
/// <summary>
/// Prints the SPARQL translation for MODIFY commands.
/// </summary>
/// <param name="command">a IModify instance</param>
public virtual void PrintEnhancedSPARQL(IModify command)
{
print("INSERT {");
println(1);
CurrentSparqlContext = SparqlContext.DeleteTemplateContext;
PrintEnhancedSPARQL(command.getResource(SP.PropertyDeletePattern));
CurrentSparqlContext = SparqlContext.InsertTemplateContext;
PrintEnhancedSPARQL(command.getResource(SP.PropertyInsertPattern));
print("}");
println(-1);
print("@USING_DEFAULT\n");
print("@USING_NAMED\n");
print("WHERE {");
println(1);
CurrentSparqlContext = SparqlContext.QueryContext;
PrintEnhancedSPARQL(command.getResource(SP.PropertyWhere));
print("}");
println(-1);
}
