internal BeginsWithAndContains(CAML camlBuilder, Predicates predicate, Guid fieldId, string value)
{
if (predicate != Predicates.Contains || predicate != Predicates.BeginsWith)
throw new ArgumentException("contains");
_camlBuilder = camlBuilder;
_predicate = predicate;
_fieldId = fieldId;
_value = value;
}
public bool Contains(Predicate <T> item)
{
return(Predicates.Contains(item));
}
public void Add(Predicate <T> item)
{
Predicates.Add(item);
}
void Start()
{
GameObject bc = GameObject.Find ("BehaviorController");
preds = bc.GetComponent<Predicates> ();
eventManager = bc.GetComponent<EventManager> ();
macros = bc.GetComponent<Macros> ();
}
public void Bridge_Init()
{
p = new Predicates();
}
// 此方法 Runtime 時被觸發，使用此方法加入相關服務至容器
public void ConfigureServices(IServiceCollection services)
{
// 注入所需 Services
services.AddTransient <ICustomService, CustomService>();
services.AddTransient <IOtherService, OtherService>();
services.AddControllers();
// 設定動態代理
// https://github.com/dotnetcore/AspectCore-Framework
services.ConfigureDynamicProxy(config => { config.Interceptors.AddTyped <ServiceAopAttribute>(Predicates.ForMethod("Execute*")); });
}
/// <summary>
/// 退款
/// </summary>
/// <param name="refund"></param>
/// <returns></returns>
public OptResult Refound(RefundEntity refund)
{
OptResult rst = null;
var operation = CardOperation.Refund;
var optDesc = operation.GetDescription();
if (refund == null)
{
rst = OptResult.Build(ResultCode.ParamError, optDesc + "——参数不能为空！");
return(rst);
}
string msg = string.Empty;
if (!refund.Check(out msg))
{
rst = OptResult.Build(ResultCode.ParamError, string.Format("{0}——{1}！", optDesc, msg));
return(rst);
}
//1、账户是否存在（获取账户信息）
var card = GetByIdcard(refund.idcard);
if (card == null)
{
rst = OptResult.Build(ResultCode.DataNotFound, string.Format("{0}——指定身份证号{1}的账户不存在！", optDesc, refund.idcard));
return(rst);
}
//2、账户状态
if (card.State != CardState.Normal)
{
rst = OptResult.Build(ResultCode.Fail, string.Format("{0}——一卡通状态异常[{1}]！", optDesc, card.State.GetDescription()));
return(rst);
}
//3、指定订单是否已付款并且未退款（获取付款流水信息）
PredicateGroup pg = new PredicateGroup {
Operator = GroupOperator.And, Predicates = new List <IPredicate>()
};
pg.Predicates.Add(Predicates.Field <CardBill>(b => b.bill_idcard, Operator.Eq, card.card_idcard));
pg.Predicates.Add(Predicates.Field <CardBill>(b => b.bill_order, Operator.Eq, refund.order));
var payTypeWhere = Predicates.Field <CardBill>(b => b.bill_type, Operator.Eq, CardOperation.Pay.ToString());
pg.Predicates.Add(payTypeWhere);
var payBill = _cardBillRep.GetList(pg).FirstOrDefault();
if (payBill == null)
{
rst = OptResult.Build(ResultCode.DataNotFound, string.Format("{0}——指定身份证号{1}的订单{2}尚未支付！", optDesc, card.card_idcard, refund.order));
return(rst);
}
pg.Predicates.Remove(payTypeWhere);
pg.Predicates.Add(Predicates.Field <CardBill>(b => b.bill_type, Operator.Eq, "退款"));
var count = _cardBillRep.Count(pg);
if (count > 0)
{
rst = OptResult.Build(ResultCode.OptRepeat, string.Format("{0}——指定身份证号{1}的订单{2}已退款！", optDesc, card.card_idcard, refund.order));
return(rst);
}
//4、数据库操作
/*
* 退款流程
* 1）更新一卡通基本信息
* gov_new=gov_now+bill.gov_change,my_new=my_now+bill.my_change
* 2）新增操作记录，type：退款
* 3）新增流水记录，type：退款
*/
decimal govchanged = -payBill.bill_changegov; //求反
decimal mychanged = -payBill.bill_changemy; //求反
decimal govnew = card.card_govmoney + govchanged;
decimal mynew = card.card_mymoney + mychanged;
var rec_id = GuidExtension.GetOne();
var optTime = DateTime.Now;
var cardRecord = new CardRecord
{
rec_id = rec_id,
rec_number = card.card_number,
rec_idcard = card.card_idcard,
rec_type = operation.ToString(),
rec_time = optTime,
rec_username = card.card_username,
rec_remark = string.Format("退款金额：{0}", govchanged + mychanged),
rec_operator = refund.opt
};
var cardBill = new CardBill
{
bill_id = GuidExtension.GetOne(),
bill_number = card.card_number,
bill_idcard = card.card_idcard,
bill_agoall = card.card_govmoney + card.card_mymoney,
bill_agogov = card.card_govmoney,
bill_agomy = card.card_mymoney,
bill_changegov = govchanged,
bill_changemy = mychanged,
bill_nowall = govnew + mynew,
bill_nowgov = govnew,
bill_nowmy = mynew,
bill_type = operation.ToString(),
bill_time = optTime,
bill_order = refund.order,
bill_src = refund.src,
bill_record = rec_id,
bill_remark = refund.remark
};
//
var tran = base.Begin();
try
{
//
count = _cardInfoRep.UpdateBySqlName(SqlName_Update,
new { card_govmoney = govnew, card_mymoney = mynew, card_modifier = refund.opt, card_modifytime = optTime, card_idcard = refund.idcard },
new string[] { "card_govmoney", "card_mymoney", "card_modifier", "card_modifytime" },
tran);
if (count < 1)
{
tran.Rollback();
rst = OptResult.Build(ResultCode.Fail, optDesc + "——未知错误！");
return(rst);
}
//
_cardRecordRep.Insert(cardRecord);
//
_cardBillRep.Insert(cardBill);
tran.Commit();
rst = OptResult.Build(ResultCode.Success, string.Format("{0}——身份证号{1}，订单号{2}", optDesc, refund.idcard, refund.order));
}
catch (Exception ex)
{
LogHelper.LogError(optDesc, ex);
rst = OptResult.Build(ResultCode.DbError, optDesc);
}
return(rst);
}
/// <summary>Count how many predicates are true</summary>
public int CountTrue(T item)
{
return(Predicates.Count(predicate => predicate(item)));
}
public static IServiceCollection InstallRedisAOPCacheFilter(this IServiceCollection services, IConfiguration configuration)
{
var options = new FilterCachedConfiguration();
configuration.GetSection("MHCache:FilterCacheConfiguration").Bind(options);
services
.InstallMHRedisCache(configuration)
.GetConfigurationDataMHRedisCacheFilters(configuration)
.ConfigureDynamicProxy(config =>
{
if (options.RegisterCachedByOnlyTypeNames != null && options.RegisterCachedByOnlyTypeNames.Any())
{
config
.Interceptors
.AddTyped <CachedAOPByConfiguration>(options.RegisterCachedByOnlyTypes.Select(o => Predicates.Implement(o)).ToArray());
}
else
{
config
.Interceptors
.AddTyped <CachedAOPByConfiguration>();
}
if (options.RegisterCachedRemoveByOnlyTypeNames != null && options.RegisterCachedRemoveByOnlyTypeNames.Any())
{
config
.Interceptors
.AddTyped <CachedRemoveAOPByConfiguration>(options.RegisterCachedRemoveByOnlyTypes.Select(o => Predicates.Implement(o)).ToArray());
}
else
{
config
.Interceptors
.AddTyped <CachedRemoveAOPByConfiguration>();
}
});
return(services);
}
/// <param name="uri"> The uri to identify the component with. </param>
/// <param name="type"> The type to create the metadata for </param>
/// <param name="factory"> A reflection library to provide class construction and field get/set functionality </param>
/// <param name="copyStrategies"> A copy strategy library </param>
/// <exception cref="NoSuchMethodException"> If the component has no default constructor </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public ComponentMetadata(org.terasology.engine.SimpleUri uri, Class type, org.terasology.reflection.reflect.ReflectFactory factory, org.terasology.reflection.copy.CopyStrategyLibrary copyStrategies) throws NoSuchMethodException
public ComponentMetadata(SimpleUri uri, Type type, ReflectFactory factory, CopyStrategyLibrary copyStrategies) : base(uri, type, factory, copyStrategies, Predicates.alwaysTrue())
{
replicated = type.getAnnotation(typeof(Replicate)) != null;
blockLifecycleEventsRequired = type.getAnnotation(typeof(RequiresBlockLifecycleEvents)) != null;
ForceBlockActive forceBlockActiveAnnotation = type.getAnnotation(typeof(ForceBlockActive));
if (forceBlockActiveAnnotation != null)
{
forceBlockActive = true;
retainUnalteredOnBlockChange = forceBlockActiveAnnotation.retainUnalteredOnBlockChange();
}
//JAVA TO C# CONVERTER TODO TASK: Java wildcard generics are not converted to .NET:
//ORIGINAL LINE: for (ComponentFieldMetadata<T, ?> field : getFields())
foreach (ComponentFieldMetadata <T, ?> field in Fields)
{
if (field.Replicated)
{
replicated = true;
if (field.ReplicationInfo.value().ReplicateFromOwner)
{
replicatedFromOwner = true;
}
}
if (field.OwnedReference)
{
referenceOwner = true;
}
}
}
public Query <T> AddPredicate(Expression <Func <T, bool> > predicate)
{
Predicates.Add(predicate);
return(this);
}
public Query(Expression <Func <T, bool> > expression)
{
Predicates.Add(expression);
}
internal override bool TrueIn(uint aInterpretation, uint aKindOfWorld, Predicates aPredicates)
{
return(Left.TrueIn(aInterpretation, aKindOfWorld, aPredicates) == Right.TrueIn(aInterpretation, aKindOfWorld, aPredicates));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void returnsNullWhenEmpty()
public virtual void ReturnsNullWhenEmpty()
{
assertNull((new IndexSamplingJobQueue <>(Predicates.alwaysTrue())).poll());
}
/// <summary>Count how many predicates are false</summary>
public int CountFalse(T item)
{
return(Predicates.Count(predicate => !predicate(item)));
}
public CAML AddPredicateWithAutoFieldTypeCasting(Predicates predicate, Guid fieldId, object value)
{
SPFieldType fieldType = SPFieldType.Text;
if (value is DateTime)
fieldType = SPFieldType.DateTime;
if (value is int)
fieldType = SPFieldType.Integer;
return AddPredicate(predicate, fieldId, fieldType, value);
}
// Use this for initialization
void Start()
{
preds = gameObject.GetComponent<Predicates> ();
objSelector = GameObject.Find ("BlocksWorld").GetComponent<ObjectSelector> ();
}
/// <summary>
/// Search
/// </summary>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <param name="requestContentDto"></param>
public ContentResponse Search(int pageIndex, int pageSize, RequestContentDto requestContentDto)
{
var elasticsearchPage = new ElasticsearchPage <Content>("content_test")
{
PageIndex = pageIndex,
PageSize = pageSize
};
#region terms 分组
var terms = new List <IFieldTerms>();
var classificationGroupBy = "searchKey_classification";
var brandGroupBy = "searchKey_brand";
#endregion
var searchRequest = elasticsearchPage.InitSearchRequest();
var predicateList = new List <IPredicate>();
//分类ID
if (requestContentDto.CategoryId != null)
{
predicateList.Add(Predicates.Field <Content>(x => x.ClassificationCode, ExpressOperator.Like,
requestContentDto.CategoryId));
}
else
{
terms.Add(Predicates.FieldTerms <Content>(x => x.ClassificationGroupBy, classificationGroupBy, 200));
}
//品牌
if (string.IsNullOrWhiteSpace(requestContentDto.Brand))
{
terms.Add(Predicates.FieldTerms <Content>(x => x.BrandGroupBy, brandGroupBy, 200));
}
//供应商名称
if (!string.IsNullOrWhiteSpace(requestContentDto.BaseType))
{
predicateList.Add(Predicates.Field <Content>(x => x.BaseType, ExpressOperator.Like,
requestContentDto.BaseType));
}
//是否自营
if (requestContentDto.IsSelfSupport == 1)
{
predicateList.Add(Predicates.Field <Content>(x => x.IsSelfSupport, ExpressOperator.Eq,
requestContentDto.IsSelfSupport));
}
//最大价格
if (requestContentDto.MaxPrice != null)
{
predicateList.Add(Predicates.Field <Content>(x => x.UnitPrice, ExpressOperator.Le,
requestContentDto.MaxPrice));
}
//最小价格
if (requestContentDto.MinPrice != null)
{
predicateList.Add(Predicates.Field <Content>(x => x.UnitPrice, ExpressOperator.Ge,
requestContentDto.MinPrice));
}
//关键词
if (!string.IsNullOrWhiteSpace(requestContentDto.SearchKey))
{
predicateList.Add(Predicates.Field <Content>(x => x.Title, ExpressOperator.Like,
requestContentDto.SearchKey));
}
//规整排序
var sortConfig = SortOrderRule(requestContentDto.SortKey);
var sorts = new List <ISort>
{
Predicates.Sort <Content>(sortConfig.Key, sortConfig.SortOrder)
};
var predicate = Predicates.Group(GroupOperator.And, predicateList.ToArray());
//构建或查询
var predicateListOr = new List <IPredicate>();
if (!string.IsNullOrWhiteSpace(requestContentDto.Brand))
{
var array = requestContentDto.Brand.Split(',').ToList();
predicateListOr
.AddRange(array.Select
(item => Predicates.Field <Content>(x => x.Brand, ExpressOperator.Like, item)));
}
var predicateOr = Predicates.Group(GroupOperator.Or, predicateListOr.ToArray());
var predicatecCombination = new List <IPredicate> {
predicate, predicateOr
};
var pgCombination = Predicates.Group(GroupOperator.And, predicatecCombination.ToArray());
searchRequest.InitQueryContainer(pgCombination)
.InitSort(sorts)
.InitHighlight(requestContentDto.HighlightConfigEntity)
.InitGroupBy(terms);
var data = _searchProvider.SearchPage(searchRequest);
#region terms 分组赋值
var classificationResponses = requestContentDto.CategoryId != null
? null
: data.Aggregations.Terms(classificationGroupBy).Buckets
.Select(x => new ClassificationResponse
{
Key = x.Key.ToString(),
DocCount = x.DocCount
}).ToList();
var brandResponses = !string.IsNullOrWhiteSpace(requestContentDto.Brand)
? null
: data.Aggregations.Terms(brandGroupBy).Buckets
.Select(x => new BrandResponse
{
Key = x.Key.ToString(),
DocCount = x.DocCount
}).ToList();
#endregion
//初始化
#region 高亮
var titlePropertySearchName = (PropertySearchNameAttribute)
LoadAttributeHelper.LoadAttributeByType <Content, PropertySearchNameAttribute>(x => x.Title);
var list = data.Hits.Select(c => new Content
{
Key = c.Source.Key,
Title = (string)c.Highlights.Highlight(c.Source.Title, titlePropertySearchName.Name),
ImgUrl = c.Source.ImgUrl,
BaseType = c.Source.BaseType,
BelongMemberName = c.Source.BelongMemberName,
Brand = c.Source.Brand,
Code = c.Source.Code,
BrandFirstLetters = c.Source.BrandFirstLetters,
ClassificationName = c.Source.ClassificationName,
ResourceStatus = c.Source.ResourceStatus,
BrandGroupBy = c.Source.BrandGroupBy,
ClassificationGroupBy = c.Source.ClassificationGroupBy,
ClassificationCode = c.Source.ClassificationCode,
IsSelfSupport = c.Source.IsSelfSupport,
UnitPrice = c.Source.UnitPrice
}).ToList();
#endregion
var contentResponse = new ContentResponse
{
Records = (int)data.Total,
PageIndex = elasticsearchPage.PageIndex,
PageSize = elasticsearchPage.PageSize,
Contents = list,
BrandResponses = brandResponses,
ClassificationResponses = classificationResponses
};
return(contentResponse);
}
public Device GetDeviceByIMEI(string IMEI)
{
var equalPredicate = Predicates.Field <Device>(d => d.IMEI, Operator.Eq, IMEI);
return(connection.GetList <Device>(predicate: equalPredicate, transaction: transaction).FirstOrDefault());
}
public override object Execute(object argument, ValueEnvironment environment)
{
return(Predicates.IsFunction(argument));
}
/// <summary>
/// 付款
/// </summary>
/// <param name="pay"></param>
/// <returns></returns>
public OptResult Pay(PayEntity pay)
{
OptResult rst = null;
var operation = CardOperation.Pay;
var optDesc = operation.GetDescription();
if (pay == null)
{
rst = OptResult.Build(ResultCode.ParamError, optDesc + "——参数不能为空！");
return(rst);
}
string msg = string.Empty;
if (!pay.Check(out msg))
{
rst = OptResult.Build(ResultCode.ParamError, string.Format("{0}——{1}！", optDesc, msg));
return(rst);
}
//1、账户是否存在
var card = GetByIdcard(pay.idcard);
if (card == null)
{
rst = OptResult.Build(ResultCode.DataNotFound, string.Format("{0}——指定身份证号{1}的账户不存在！", optDesc, pay.idcard));
return(rst);
}
//2、如果一卡通号存在，看是否和身份证号对应
if (!string.IsNullOrEmpty(pay.number) && !string.Equals(card.card_number, pay.number))
{
rst = OptResult.Build(ResultCode.ParamError, string.Format("{0}——身份证号{1}与一卡通号{2}不匹配！", optDesc, pay.idcard, pay.number));
return(rst);
}
//3、一卡通状态是否正常
if (card.State != CardState.Normal)
{
rst = OptResult.Build(ResultCode.ParamError, string.Format("{0}——一卡通状态异常[{1}]！", optDesc, card.State.GetDescription()));
return(rst);
}
//4、余额是否充足
if (pay.amount > card.card_govmoney + card.card_mymoney)
{
rst = OptResult.Build(ResultCode.ParamError, string.Format("{0}——余额不足！", optDesc));
return(rst);
}
//5、是否已经支付过（该一卡通和订单号下，存在"支付"流水或"退款"流水)
var pg = new PredicateGroup {
Operator = GroupOperator.And, Predicates = new List <IPredicate>()
};
pg.Predicates.Add(Predicates.Field <CardBill>(b => b.bill_idcard, Operator.Eq, card.card_idcard));
pg.Predicates.Add(Predicates.Field <CardBill>(b => b.bill_order, Operator.Eq, pay.order));
pg.Predicates.Add(Predicates.Field <CardBill>(b => b.bill_type, Operator.Eq, new string[] { CardOperation.Pay.ToString(), CardOperation.Refund.ToString() }));
var count = _cardBillRep.Count(pg);
if (count > 0)
{
//已付款或退款
rst = OptResult.Build(ResultCode.OptRepeat, optDesc + "——已付款或退款，不能再次支付！");
return(rst);
}
//6、支付
/*
* 消费扣费逻辑：
* 优先扣除gov：if pay > govnow,govchanged=govnow,govnew=0;mychanged=pay-govnow,mynew=mynow-mychanged;
* else govchanged=pay,govnew=govnow-govchanged;mychanged=0,mynew=mynow;
* 优先扣除my： if pay > mynow, mychanged=mynow,mynew=0;govchanged=pay-mynow,govnew=govnow-govchanged;
* else mychanged=pay,mynew=mynow-mychanged;govchanged=0,govnew=govnow;
* 1）更新card_info，
* 2）新增操作记录，type：付款
* 3）新增一卡通流水，type：付款
* 注：扣费时，变动额为负数
*/
decimal govnew, govchanged, mynew, mychanged;
if (pay.priority == MoneyEnum.gov)
{
if (pay.amount > card.card_govmoney)
{
govchanged = -card.card_govmoney;
govnew = 0;
mychanged = -(pay.amount - card.card_govmoney);
mynew = card.card_mymoney + mychanged;//因为mychanged是负数
}
else
{
govchanged = -pay.amount;
govnew = card.card_govmoney - pay.amount;
mychanged = 0;
mynew = card.card_mymoney;
}
}
else
{
if (pay.amount > card.card_mymoney)
{
mychanged = -card.card_mymoney;
mynew = 0;
govchanged = -(pay.amount - card.card_mymoney);
govnew = card.card_govmoney + govchanged;//因为govchanged是负数
}
else
{
mychanged = -pay.amount;
mynew = card.card_mymoney - pay.amount;
govchanged = 0;
govnew = card.card_govmoney;
}
}
//
var rec_id = GuidExtension.GetOne();//操作记录id
DateTime optTime = DateTime.Now;
var cardRecord = new CardRecord
{
rec_id = rec_id,
rec_number = card.card_number,
rec_idcard = card.card_idcard,
rec_type = operation.ToString(),
rec_time = optTime,
rec_username = card.card_username,
rec_remark = string.Format("付款金额：{0}", pay.amount),
rec_operator = pay.opt
};
var cardBill = new CardBill
{
bill_id = GuidExtension.GetOne(),
bill_number = card.card_number,
bill_idcard = card.card_idcard,
bill_agoall = card.card_govmoney + card.card_mymoney,
bill_agogov = card.card_govmoney,
bill_agomy = card.card_mymoney,
bill_changegov = govchanged,
bill_changemy = mychanged,
bill_nowall = mynew + govnew,
bill_nowgov = govnew,
bill_nowmy = mynew,
bill_type = operation.ToString(),
bill_time = optTime,
bill_order = pay.order,
bill_src = pay.src,
bill_record = rec_id,
bill_remark = pay.remark
};
var tran = base.Begin();
try
{
//
count = _cardInfoRep.UpdateBySqlName(SqlName_Update,
new { card_govmoney = govnew, card_mymoney = mynew, card_modifier = pay.opt, card_modifytime = optTime, card_idcard = pay.idcard },
new string[] { "card_govmoney", "card_mymoney", "card_modifier", "card_modifytime" },
tran);
if (count < 1)
{
tran.Rollback();
rst = OptResult.Build(ResultCode.Fail, optDesc + "——未知错误！");
return(rst);
}
//
_cardRecordRep.Insert(cardRecord);
//
_cardBillRep.Insert(cardBill);
tran.Commit();
rst = OptResult.Build(ResultCode.Success, optDesc + "——idcard：" + pay.idcard);
}
catch (Exception ex)
{
LogHelper.LogError(optDesc, ex);
rst = OptResult.Build(ResultCode.DbError, optDesc);
}
return(rst);
}
/// <summary>
/// Adds a predicate to the stub
/// </summary>
/// <param name="predicate">The predicate object designating what the stub will match on</param>
/// <returns>The stub that the predicate was added to</returns>
public TcpStub On(PredicateBase predicate)
{
Predicates.Add(predicate);
return(this);
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new Configuration();
config.NetworkConfig.AddAddress("127.0.0.1");
config.SerializationConfig
.DataSerializableFactories.Add(EntryProcessorDataSerializableFactory.FactoryId,
new EntryProcessorDataSerializableFactory());
var client = HazelcastClient.NewHazelcastClient(config);
var map = client.GetMap <int, string>("entry-processor-example");
Console.WriteLine("Populating map");
for (int i = 0; i < 10; i++)
{
map.Put(i, "value" + i);
}
Console.WriteLine("Map size: " + map.Size());
var result = map.ExecuteOnEntries(new UpdateEntryProcessor("value-UPDATED"), Predicates.Sql("this==value5"));
Console.WriteLine("Updated value result: " + result[5]);
Console.WriteLine("The same value from the map: " + map.Get(5));
client.Shutdown();
}
/// <summary>
/// Add binary representation of predicate.
/// </summary>
/// <param name="predicate">The predicate.</param>
public void SatisfyExact(Packet predicate)
{
Condition.Requires(predicate, "predicate");
Predicates.Add(predicate);
}
public List <Domain.Modules> GetMenuModules(int menuId)
{
var p = Predicates.Field <Domain.Modules>(m => m.MenuId, Operator.Eq, menuId);
return(unitOfWork.Connection.GetList <Domain.Modules>(p, null, unitOfWork.Transaction).ToList());
}
// Use this for initialization
void Start()
{
recorder = gameObject.GetComponent <FlashbackRecorder>();
inputController = GameObject.Find("IOController").GetComponent <InputController>();
eventManager = GameObject.Find("BehaviorController").GetComponent <EventManager>();
objSelector = GameObject.Find("VoxWorld").GetComponent <ObjectSelector>();
commBridge = GameObject.Find("CommunicationsBridge").GetComponent <CommunicationsBridge>();
preds = GameObject.Find("BehaviorController").GetComponent <Predicates>();
captureVideo = (PlayerPrefs.GetInt("Capture Video") == 1);
captureParams = (PlayerPrefs.GetInt("Capture Params") == 1);
captureMode = (VideoCaptureMode)PlayerPrefs.GetInt("Video Capture Mode");
resetScene = (PlayerPrefs.GetInt("Reset Between Events") == 1);
eventResetCounter = PlayerPrefs.GetInt("Event Reset Counter");
filenameScheme = (VideoCaptureFilenameType)PlayerPrefs.GetInt("Video Capture Filename Type");
sortByEvent = (PlayerPrefs.GetInt("Sort By Event String") == 1);
filenamePrefix = PlayerPrefs.GetString("Custom Video Filename Prefix");
dbFile = PlayerPrefs.GetString("Video Capture DB");
inputFile = PlayerPrefs.GetString("Auto Events List");
eventIndex = PlayerPrefs.GetInt("Start Index");
videoDir = PlayerPrefs.GetString("Video Output Directory");
if ((!captureVideo) && (!captureParams))
{
return;
}
if (videoDir != string.Empty)
{
recorder.SetOutputDirectory(Path.GetFullPath(Application.dataPath + videoDir));
}
InitObjectDisabling();
eventObjs = new List <GameObject>();
if (captureMode == VideoCaptureMode.PerEvent)
{
commBridge.PortOpened += StartAutoInput;
inputController.InputReceived += PrepareScene;
inputController.InputReceived += InputStringReceived;
inputController.ParseComplete += ParseReceived;
eventManager.ObjectsResolved += ObjectsResolved;
eventManager.ObjectsResolved += FilterSpecifiedManner;
eventManager.ObjectsResolved += EnableAffectedObjects;
eventManager.ObjectsResolved += InsertWaitPeriod;
//eventManager.ObjectsResolved += StartCapture;
eventManager.SatisfactionCalculated += SatisfactionCalculated;
eventManager.SatisfactionCalculated += EnableAffectedObjects;
eventManager.SatisfactionCalculated += InsertWaitPeriod;
//eventManager.SatisfactionCalculated += StartCapture;
//eventManager.ExecuteEvent += EnableAffectedObjects;
//eventManager.EventInserted += EventInserted;
eventManager.ExecuteEvent += StartCapture;
eventManager.QueueEmpty += EventComplete;
preds.waitTimer.Elapsed += WaitComplete;
preds.PrepareLog += PrepareLog;
preds.ParamsCalculated += ParametersCalculated;
eventTimeoutTimer = new Timer(eventTimeoutTime);
eventTimeoutTimer.Enabled = false;
eventTimeoutTimer.Elapsed += EventTimedOut;
eventTimeoutTimer.Elapsed += StopCapture;
eventCompleteWaitTimer = new Timer(eventCompleteWaitTime);
eventCompleteWaitTimer.Enabled = false;
eventCompleteWaitTimer.Elapsed += StopCapture;
FileWritten += CaptureComplete;
}
}
public override IServiceCollection ConfigureServices(IServiceCollection service)
{
var typefinder = service.GetOrAddSingletonService <ITypeFinder, TypeFinder>();
typefinder.NotNull(nameof(typefinder));
var typs = typefinder.Find(o => o.IsClass && !o.IsAbstract && !o.IsInterface && o.IsSubclassOf(typeof(AbstractInterceptor)));
var InterceptorsModule = service.GetConfiguration()["SuktCore:InterceptorsModule"];
var IInterceptorsModule = service.GetConfiguration()["SuktCore:IInterceptorsModule"];
if (typs?.Length > 0)
{
List <Type> types = new List <Type>();
//types.Add(typeof(AopTran));
foreach (var item in typs)
{
//service.AddTransient(item);
service.ConfigureDynamicProxy(cof =>
{
var Enabled = service.GetConfiguration()[$"SuktCore:AopManager:{item.Name}:Enabled"].ObjToBool();
if (Enabled)
{
cof.Interceptors.AddTyped(item, Predicates.ForNameSpace(InterceptorsModule), Predicates.ForNameSpace(IInterceptorsModule));////这种是配置只需要代理的层, Predicates.ForNameSpace("Sukt.Core.Application.Contracts")
}
//config.NonAspectPredicates.AddService("IUnitofWork");//需要过滤掉不需要代理的服务层
});
}
}
return(service);
}
/// <summary>
/// Convert to a string
/// </summary>
public override string ToString()
{
return("(" + string.Join(Strings.OperatorOr, Predicates.Select(x => x.ToString()).ToArray()) + ")");
}
public void Clear()
{
Predicates.Clear();
}
/// <summary>
/// Evaluate this predicate for the given loc.
/// </summary>
public override bool Evaluate(ILoc loc)
{
return(Predicates.Any(x => x.Evaluate(loc)));
}
public CAML AddPredicate(Predicates predicate, Guid fieldId, SPFieldType fieldType, object value)
{
string filterExpression = string.Format(CultureInfo.InvariantCulture,
"<{0}><FieldRef ID='{1}'/><Value Type='{2}'>{3}</Value></{0}>"
, predicate, fieldId, fieldType, FormatValue(value));
AddFilter(new CAMLFilter { FilterExpression = filterExpression });
return this;
}
public int Delete(int id)
{
var predicate = Predicates.Field <T>(f => f.Id, Operator.Eq, id);
return(_dbConnection.Delete <T>(predicate)?1:0);
}
internal CAML AddDateTimeVarPredicate(Predicates predicate, Guid fieldId, DateTimeVariables variable)
{
string xmlVariable = string.Format("<{0}/>", variable);
return AddPredicate(predicate, fieldId, SPFieldType.DateTime, xmlVariable);
}
public async Task UpdateAsync(IdentityServer3.Core.Models.Consent consent)
{
var parameters = new Dictionary <string, object>();
var dynamicParameters = new DynamicParameters();
var pg = new PredicateGroup {
Operator = GroupOperator.And, Predicates = new List <IPredicate>()
};
pg.Predicates.Add(Predicates.Field <Consent>(t => t.Subject, Operator.Eq, consent.Subject));
pg.Predicates.Add(Predicates.Field <Consent>(t => t.ClientId, Operator.Eq, consent.ClientId));
var sql = options.SqlGenerator.Select(new ConsentMapper(options), pg, null, parameters);
dynamicParameters = new DynamicParameters();
foreach (var parameter in parameters)
{
dynamicParameters.Add(parameter.Key, parameter.Value);
}
var item = await options.Connection.QueryFirstOrDefaultAsync <Consent>(sql, dynamicParameters);
if (item == null)
{
if (consent.Scopes == null || !consent.Scopes.Any())
{
return;
}
item = new Entities.Consent
{
Subject = consent.Subject,
ClientId = consent.ClientId,
Scopes = StringifyScopes(consent.Scopes)
};
sql = options.SqlGenerator.Insert(new ConsentMapper(options));
await options.Connection.ExecuteAsync(sql, item);
}
else
{
if (consent.Scopes == null || !consent.Scopes.Any())
{
parameters = new Dictionary <string, object>();
sql = options.SqlGenerator.Delete(new ConsentMapper(options), pg, parameters);
dynamicParameters = new DynamicParameters();
foreach (var parameter in parameters)
{
dynamicParameters.Add(parameter.Key, parameter.Value);
}
await options.Connection.ExecuteAsync(sql, dynamicParameters);
}
else
{
item.Scopes = StringifyScopes(consent.Scopes);
parameters = new Dictionary <string, object>();
sql = options.SqlGenerator.Update(new ConsentMapper(options), pg, parameters, true);
dynamicParameters = new DynamicParameters();
foreach (var parameter in parameters)
{
dynamicParameters.Add(parameter.Key, parameter.Value);
}
dynamicParameters.Add("Scopes", item.Scopes);
await options.Connection.ExecuteAsync(sql, dynamicParameters);
}
}
}
public bool IsValid()
{
return Predicates.All(predicate => predicate.GetMissingVariableId() == null);
}
/// <summary>Check if all predicates are true</summary>
public bool CheckAll(T item)
{
return(Predicates.All(predicate => predicate(item)));
}
