public AddStrategyCommand(StrategyInfo info, SessionType sessionType)
{
if (info == null)
throw new ArgumentNullException(nameof(info));
Info = info;
SessionType = sessionType;
}
public CompileStrategyInfoCommand(StrategyInfo info, IEnumerable<CodeReference> references)
{
if (info == null)
throw new ArgumentNullException("info");
if (references == null)
throw new ArgumentNullException("references");
Info = info;
References = references;
}
public AddStrategyCommand(StrategyInfo info, StrategyContainer strategy, SessionType sessionType)
{
if (info == null)
throw new ArgumentNullException("info");
if (strategy == null)
throw new ArgumentNullException("strategy");
Info = info;
Strategy = strategy;
SessionType = sessionType;
}
/// <summary>
/// Disposes the provided strategies.
/// </summary>
public void Dispose(StrategyInfo[] strategies)
{
using (LogGroup logGroup = LogGroup.Start("Disposing the strategies.", NLog.LogLevel.Debug))
{
if (StrategyState.IsInitialized)
{
foreach (StrategyInfo strategy in strategies)
{
StrategyState.Strategies.Remove(
StrategyState.Strategies[strategy.TypeName]
);
}
}
}
}
private IStudioControl OpenControl(StrategyInfo info)
{
IStudioControl ctrl = null;
switch (StrategyInfo.Type)
{
case StrategyInfoTypes.SourceCode:
case StrategyInfoTypes.Analytics:
ctrl = OpenControl(info.Id.To <string>(), typeof(StrategyInfoCodeContent), info, () =>
{
var c = new StrategyInfoCodeContent {
StrategyInfo = info
};
ConfigManager
.GetService <IStudioCommandService>()
.Bind(info.GetKey(), c);
return(c);
});
break;
case StrategyInfoTypes.Diagram:
ctrl = OpenControl(info.Id.To <string>(), typeof(DiagramPanel), info, () =>
{
var c = new DiagramPanel {
StrategyInfo = info
};
ConfigManager
.GetService <IStudioCommandService>()
.Bind(info.GetKey(), c);
return(c);
});
break;
case StrategyInfoTypes.Assembly:
case StrategyInfoTypes.Terminal:
break;
default:
throw new ArgumentOutOfRangeException();
}
return(ctrl);
}
public void Test_Locate_Basic_MockEntity_PublicEntities_MockPublicEntity()
{
StrategyStateNameValueCollection strategies = new StrategyStateNameValueCollection();
strategies.Clear();
strategies.Add(typeof(AuthoriseReferenceMockPublicEntityStrategy));
AuthoriseReferenceStrategyLocator locator = new AuthoriseReferenceStrategyLocator(strategies);
StrategyInfo strategy = locator.Locate("MockEntity", "PublicEntities", "MockPublicEntity", String.Empty);
Assert.IsNotNull(strategy, "No strategy found.");
string expectedType = typeof(AuthoriseReferenceMockPublicEntityStrategy).FullName + ", " + typeof(AuthoriseReferenceMockPublicEntityStrategy).Assembly.GetName().Name;
Assert.AreEqual(expectedType, strategy.StrategyType, "Wrong strategy info located.");
}
private static void SetStrategyInfo(MultiTenantContext multiTenantContext, IMultiTenantStrategy strategy)
{
var strategyInfo = new StrategyInfo();
strategyInfo.MultiTenantContext = multiTenantContext;
strategyInfo.Strategy = strategy;
if (strategy.GetType().IsGenericType&&
strategy.GetType().GetGenericTypeDefinition() == typeof(MultiTenantStrategyWrapper <>))
{
strategyInfo.StrategyType = strategy.GetType().GetGenericArguments().First();
}
else
{
strategyInfo.StrategyType = strategy.GetType();
}
multiTenantContext.StrategyInfo = strategyInfo;
}
public override void Assign(StrategyBase from)
{
base.Assign(from);
CustomTickerStrategy st = from as CustomTickerStrategy;
if (st == null)
{
return;
}
StrategyInfo.Assign(st.StrategyInfo);
Indicators.Clear();
foreach (IndicatorBase indicator in st.Indicators)
{
Indicators.Add(indicator.Clone());
}
}
void PickStrategy(ref StrategyInfo info)
{
var newStrategy = info.strategyPicker.Pick();
if (ReferenceEquals(newStrategy, info.strategy))
{
return;
}
if (info.strategy != null)
{
info.strategy.OnDeactivate();
}
if (newStrategy != null)
{
newStrategy.OnActivate();
}
info.strategy = newStrategy;
}
public void Test_Initialize_StrategiesProvided()
{
IStrategy strategy = new MockRetrieveTestUserStrategy();
StrategyInfo info = StrategyInfo.ExtractInfo(strategy.GetType())[0];
StrategyInfo[] strategies = new StrategyInfo[]{info};
StrategyInitializer initializer = new StrategyInitializer();
initializer.Initialize(strategies);
Assert.IsTrue(StrategyState.IsInitialized, "Strategies weren't initialized or initialization wasn't detected.");
Assert.Greater(StrategyState.Strategies.Count, 0, "Invalid number of strategies initialized.");
StrategyInfo foundInfo = StrategyState.Strategies[info.Action, info.TypeName];
Assert.IsNotNull(foundInfo, "The module info wasn't found.");
}
public void Test_ExtractInfo_AuthoriseReferenceStrategy()
{
AuthoriseReferenceMockPublicEntityStrategy strategy = new AuthoriseReferenceMockPublicEntityStrategy();
StrategyInfo info = StrategyInfo.ExtractInfo(strategy.GetType())[0];
Assert.IsTrue(info is AuthoriseReferenceStrategyInfo, "Should have returned an AuthoriseReferenceStrategyInfo object.");
AuthoriseReferenceStrategyInfo authoriseStrategyInfo = (AuthoriseReferenceStrategyInfo)info;
Assert.AreEqual("MockEntity", authoriseStrategyInfo.TypeName, "Type name doesn't match what's expected.");
Assert.AreEqual("MockPublicEntity", authoriseStrategyInfo.ReferencedTypeName, "Type name doesn't match what's expected.");
Assert.AreEqual("AuthoriseReference", authoriseStrategyInfo.Action, "Action doesn't match what's expected.");
Assert.AreEqual("PublicEntities", authoriseStrategyInfo.ReferenceProperty, "Reference property doesn't match what's expected.");
Assert.AreEqual("", authoriseStrategyInfo.MirrorProperty, "Mirror property doesn't match what's expected.");
Assert.AreEqual(strategy.GetType().FullName + ", " + strategy.GetType().Assembly.GetName().Name, info.StrategyType, "Strategy type doesn't match what's expected.");
}
public void Test_Initialize_StrategiesProvided()
{
IStrategy strategy = new MockRetrieveTestUserStrategy();
StrategyInfo info = StrategyInfo.ExtractInfo(strategy.GetType())[0];
StrategyInfo[] strategies = new StrategyInfo[] { info };
StrategyInitializer initializer = new StrategyInitializer();
initializer.Initialize(strategies);
Assert.IsTrue(StrategyState.IsInitialized, "Strategies weren't initialized or initialization wasn't detected.");
Assert.Greater(StrategyState.Strategies.Count, 0, "Invalid number of strategies initialized.");
StrategyInfo foundInfo = StrategyState.Strategies[info.Action, info.TypeName];
Assert.IsNotNull(foundInfo, "The module info wasn't found.");
}
//确定选出的战略
void CheckVoteStatus()
{
List <StrategyInfo> TempStrInfos = new List <StrategyInfo>();
for (int i = 0; i < VoteStrs.Count; i++)
{
VoteStrs[i].Active = false;//先重置状态
VoteStrs[i].ActiveMarker.SetActive(false);
}
for (int i = 0; i < StrLimitNum[VoteSeqNum]; i++)
{
if (VoteStrs.Count > 0)
{
StrategyInfo TStr = VoteStrs[0];
for (int j = 0; j < VoteStrs.Count; j++)
{
//相等的话取靠前的
if (TStr.VoteNum < VoteStrs[j].VoteNum)
{
TStr = VoteStrs[j];
}
if (j == VoteStrs.Count - 1 && TStr.VoteNum != 0)
{
TempStrInfos.Add(TStr);
TStr.Active = true;
TStr.ActiveMarker.SetActive(true);
VoteStrs.Remove(TStr);
//暂时移除被选中的战略，防止下一轮循环被拿来比较
}
}
}
else
{
break;
}
}
for (int i = 0; i < TempStrInfos.Count; i++)
{
VoteStrs.Add(TempStrInfos[i]);//重新将被选中的战略放回
}
}
private static void StrategyUpdate(StrategyInfo strategyInfo)
{
var incomingStrategyNode = ConvertByteArrayToConfigNode(strategyInfo.Data, strategyInfo.NumBytes);
if (incomingStrategyNode == null)
{
return;
}
var incomingStrategyFactor = float.Parse(incomingStrategyNode.GetValue("factor"));
var incomingStrategyIsActive = bool.Parse(incomingStrategyNode.GetValue("isActive"));
//Don't listen to these events for the time this message is processing.
System.StartIgnoringEvents();
ShareFundsSystem.Singleton.StartIgnoringEvents();
ShareScienceSystem.Singleton.StartIgnoringEvents();
ShareReputationSystem.Singleton.StartIgnoringEvents();
var strategyIndex = StrategySystem.Instance.Strategies.FindIndex(s => s.Config.Name == strategyInfo.Name);
if (strategyIndex != -1)
{
if (incomingStrategyIsActive)
{
StrategySystem.Instance.Strategies[strategyIndex].Factor = incomingStrategyFactor;
StrategySystem.Instance.Strategies[strategyIndex].Activate(); //could somehow throw an exception if the player was not yet in the strategy building.
LunaLog.Log($"StrategyUpdate received - strategy activated: {strategyInfo.Name} - with factor: {incomingStrategyFactor}");
}
else
{
StrategySystem.Instance.Strategies[strategyIndex].Factor = incomingStrategyFactor;
StrategySystem.Instance.Strategies[strategyIndex].Deactivate(); //could somehow throw an exception if the player was not yet in the strategy building.
LunaLog.Log($"StrategyUpdate received - strategy deactivated: {strategyInfo.Name} - with factor: {incomingStrategyFactor}");
}
}
Administration.Instance?.RedrawPanels();
//Listen to the events again. Restore funds, science and reputation in case the contract action changed some of that.
ShareFundsSystem.Singleton.StopIgnoringEvents(true);
ShareScienceSystem.Singleton.StopIgnoringEvents(true);
ShareReputationSystem.Singleton.StopIgnoringEvents(true);
GameEvents.Contract.onContractsListChanged.Fire();
System.StopIgnoringEvents();
}
private void GetAllowConditions()
{
mListAllStrategy.Clear();
string datatarget = "1";//1：录音记录
WebRequest webRequest = new WebRequest();
webRequest.Session = mParent.CurrentApp.Session;
webRequest.Code = (int)S2101Codes.GetAllowConditions;
webRequest.ListData.Add(datatarget);
//Service21011Client client = new Service21011Client();
Service21011Client client = new Service21011Client(WebHelper.CreateBasicHttpBinding(mParent.CurrentApp.Session), WebHelper.CreateEndpointAddress(mParent.CurrentApp.Session.AppServerInfo, "Service21011"));
WebReturn webReturn = client.DoOperation(webRequest);
client.Close();
if (!webReturn.Result)
{
mParent.CurrentApp.ShowExceptionMessage(string.Format("Fail.\t{0}\t{1}", webReturn.Code, webReturn.Message));
return;
}
if (webReturn.ListData.Count <= 0)
{
return;
}
for (int i = 0; i < webReturn.ListData.Count; i++)
{
OperationReturn optReturn = XMLHelper.DeserializeObject <StrategyInfo>(webReturn.ListData[i]);
if (!optReturn.Result)
{
mParent.CurrentApp.ShowExceptionMessage(string.Format("Fail.\t{0}\t{1}", optReturn.Code, optReturn.Message));
continue;
}
StrategyInfo strategyinfo = optReturn.Data as StrategyInfo;
if (strategyinfo == null)
{
return;
}
string tempTableName = strategyinfo.StrategyType == 1 ? "T_21_001" : "";
//strategyinfo.ConditionName = tempTableName + "." + strategyinfo.FieldName;
strategyinfo.ConditionName = strategyinfo.FieldName;
strategyinfo.Display = mParent.CurrentApp.GetLanguageInfo(("2101T0" + strategyinfo.FieldName).ToUpper(), strategyinfo.FieldName.ToUpper());
mListAllStrategy.Add(strategyinfo);
}
}
/// <summary>
/// Saves the provided strategies to file.
/// </summary>
/// <param name="strategies">An array of the strategies to save to file.</param>
public void SaveToFile(StrategyInfo[] strategies)
{
// Logging disabled to boost performance
//using (LogGroup logGroup = LogGroup.StartDebug("Saving the provided strategies to XML file."))
//{
string path = FileNamer.StrategiesInfoFilePath;
//LogWriter.Debug("Path : " + path);
if (!Directory.Exists(Path.GetDirectoryName(path)))
Directory.CreateDirectory(Path.GetDirectoryName(path));
using (StreamWriter writer = File.CreateText(path))
{
XmlSerializer serializer = new XmlSerializer(strategies.GetType());
serializer.Serialize(writer, strategies);
writer.Close();
}
//}
}
void UseStrategy(ref StrategyInfo info)
{
if (info.strategy == null)
{
if (info.lastControl != Control.None)
{
inputManager.Release(info.lastControl);
info.lastControl = Control.None;
}
return;
}
int control = info.strategy.GetControl();
if (control != info.lastControl)
{
inputManager.Release(info.lastControl);
inputManager.Press(control);
}
info.lastControl = control;
}
void StartVote()
{
if (canChangeCulture == true)
{
VoteSeqNum = 3;
canChangeCulture = false;
CultureTimeLeft = -1;
}
if (StrLimitNum[VoteSeqNum] > 0)
{
int typenum = 0;
for (int i = 0; i < StrInfos.Count; i++)
{
if (VoteSeqNum == (int)StrInfos[i].Str.Type)
{
//还要写一些选择相关的功能
StrategyInfo newStr = Instantiate(VotePrefab, VoteContent);
newStr.SC = this;
newStr.Str = StrInfos[i].Str;
newStr.TargetStr = StrInfos[i];
newStr.VoteNum = Random.Range(1, GC.CurrentEmployees.Count + 1);//+1代表CEO也会投票,同时避免(1,0)的情况
newStr.UpdateUI();
VoteStrs.Add(newStr);
typenum += 1;
}
}
if (typenum == 0)
{
NextVote();
}
else
{
CheckVoteStatus();
}
}
else
{
NextVote();
}
}
public void HandleMessage(IServerMessageBase msg)
{
if (!(msg.Data is ShareProgressBaseMsgData msgData))
{
return;
}
if (msgData.ShareProgressMessageType != ShareProgressMessageType.StrategyUpdate)
{
return;
}
if (msgData is ShareProgressStrategyMsgData data)
{
var strategy = new StrategyInfo(data.Strategy); //create a copy of the strategyInfo object so it will not change in the future.
LunaLog.Log($"Queue StrategyUpdate with: {strategy.Name}");
System.QueueAction(() =>
{
StrategyUpdate(strategy);
});
}
}
public void ProcessRequest(HttpContext context)
{
bool result = false;
context.Response.ContentType = "text/html";
string key = context.Request.QueryString["key"];
string type = context.Request.QueryString["type"];
if (!String.IsNullOrEmpty(key))
{
if (type == "1")
{
StrategyInfo info = StrategyConfigs.Instance[key];
result = info == null ? false : true;
}
else
{
result = StrategyConfigs.Instance.ContainsName(key.Trim());
}
}
context.Response.Write(result.ToString().ToLower());
}
public void Test_Locate_CustomOverride()
{
string type = "Widget";
string action = "Index";
StrategyStateNameValueCollection strategies = new StrategyStateNameValueCollection();
strategies.Add(typeof(IndexStrategy));
strategies.Add(typeof(MockIndexWidgetStrategy));
StrategyLocator locator = new StrategyLocator(strategies);
StrategyInfo info = locator.Locate(action, type);
Assert.IsNotNull(info, "No strategy info found.");
Type mockStrategyType = new MockIndexWidgetStrategy().GetType();
string expected = mockStrategyType.FullName + ", " + mockStrategyType.Assembly.GetName().Name;
Assert.AreEqual(expected, info.StrategyType, "Wrong strategy type selected.");
}
private static void ReloadAssemblyType(this StrategyInfo info)
{
if (info.Path.IsEmpty())
{
return;
}
var tuple = info.Path.LoadAssembly();
if (tuple == null)
{
throw new InvalidOperationException(LocalizedStrings.Str3607Params.Put(info.Path));
}
if (info.StrategyType != null && info.Assembly != null && tuple.Item1.SequenceEqual(info.Assembly))
{
return;
}
info.Assembly = tuple.Item1;
info.StrategyType = tuple.Item2.GetType(info.StrategyTypeName.Split(',')[0]);
}
public static StrategyContainer CreateStrategy(this StrategyInfo info, SessionType sessionType)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
var registry = ConfigManager.GetService <IStudioEntityRegistry>();
var security = "RI".GetFortsJumps(DateTime.Today, DateTime.Today.AddMonths(3), code => registry.Securities.LookupById(code + "@" + ExchangeBoard.Forts.Code)).Last();
var container = new StrategyContainer
{
StrategyInfo = info,
Portfolio = GetDefaultPortfolio(sessionType),
Security = security,
MarketDataSettings = ConfigManager.GetService <MarketDataSettingsCache>().Settings.First(s => s.Id != Guid.Empty),
SessionType = sessionType
};
container.InitStrategy();
return(container);
}
public void SkillStrSelect(StrategyInfo sStr, bool add)
{
if (add == true)
{
VoteSelectStrs.Add(sStr);
if (VoteSelectStrs.Count >= StrSelectNum)
{
for (int i = 0; i < VoteStrs.Count; i++)
{
VoteStrs[i].StrSelectToggle.interactable = false;
}
}
}
else
{
if (VoteSelectStrs.Contains(sStr))
{
VoteSelectStrs.Remove(sStr);
}
if (VoteSelectStrs.Count >= StrSelectNum)
{
for (int i = 0; i < VoteStrs.Count; i++)
{
VoteStrs[i].StrSelectToggle.interactable = true;
}
}
}
if (VoteSelectStrs.Count > 0)
{
SkillConfirmButton.SetActive(true);
}
else
{
SkillConfirmButton.SetActive(false);
}
}
public OpenStrategyInfoCommand(StrategyInfo info)
{
Info = info;
}
private void UnSubscribeStrategiesCollectionChanged(StrategyInfo info)
{
info.Strategies.Added -= StrategyAdded;
info.Strategies.Removed -= StrategyRemoved;
info.Strategies.Cleared -= StrategiesCollectionChanged;
}
public override void Strategy(StrategyInfo info)
{
}
public AddStrategyInfoCommand(StrategyInfo info)
{
Info = info;
}
/// <summary>
/// Loads all the strategies found in the strategies directory.
/// </summary>
/// <param name="includeDisabled"></param>
/// <returns>An array of the the strategies found in the directory.</returns>
public StrategyInfo[] LoadInfoFromDirectory(bool includeDisabled)
{
// Logging disabled to boost performance
//using (LogGroup logGroup = LogGroup.StartDebug("Loading the strategies from the XML file."))
//{
if (Strategies == null)
{
List<StrategyInfo> validStrategies = new List<StrategyInfo>();
StrategyInfo[] strategies = new StrategyInfo[]{};
using (StreamReader reader = new StreamReader(File.OpenRead(FileNamer.StrategiesInfoFilePath)))
{
XmlSerializer serializer = new XmlSerializer(typeof(StrategyInfo[]));
strategies = (StrategyInfo[])serializer.Deserialize(reader);
}
foreach (StrategyInfo strategy in strategies)
if (strategy.Enabled || includeDisabled)
validStrategies.Add(strategy);
Strategies = validStrategies.ToArray();
}
//}
return Strategies;
}
public AddStrategyInfoCommand(StrategyInfo info)
{
Info = info;
}
public static Tuple <StrategyInfo, StrategyInfoTypes> GetKey(this StrategyInfo info)
{
return(Tuple.Create(info, info.Type));
}
public RemoveStrategyInfoCommand(StrategyInfo info)
{
Info = info;
}
private void RunStrategy(StrategyInfo strategyInfo)
{
IStrategy strategy = strategyInfo.CreateStrategy().Strategy;
RunStrategy(strategy);
}
private OperationReturn GetAllowConditions(SessionInfo session, List <string> listParams)
{
OperationReturn optReturn = new OperationReturn();
optReturn.Result = true;
optReturn.Code = 0;
try
{
//ListParam
//0 查询语句
if (listParams == null || listParams.Count < 1)
{
optReturn.Result = false;
optReturn.Code = Defines.RET_PARAM_INVALID;
optReturn.Message = string.Format("Request param is null or count invalid");
return(optReturn);
}
string targettype = listParams[0];
DataSet objDataSet;
switch (session.DBType)
{
case 2:
optReturn = MssqlOperation.GetDataSet(session.DBConnectionString, "SELECT * FROM T_00_201");
if (!optReturn.Result)
{
return(optReturn);
}
objDataSet = optReturn.Data as DataSet;
break;
case 3:
optReturn = OracleOperation.GetDataSet(session.DBConnectionString, "SELECT * FROM T_00_201");
if (!optReturn.Result)
{
return(optReturn);
}
objDataSet = optReturn.Data as DataSet;
break;
default:
optReturn.Result = false;
optReturn.Code = Defines.RET_PARAM_INVALID;
optReturn.Message = string.Format("Database type not surpport.\t{0}", session.DBType);
return(optReturn);
}
if (objDataSet == null)
{
optReturn.Result = false;
optReturn.Code = Defines.RET_OBJECT_NULL;
optReturn.Message = string.Format("DataSet is null");
return(optReturn);
}
List <string> listReturn = new List <string>();
for (int i = 0; i < objDataSet.Tables[0].Rows.Count; i++)
{
DataRow dr = objDataSet.Tables[0].Rows[i];
StrategyInfo item = new StrategyInfo();
item.StrategyType = Convert.ToInt32(dr["C001"]);
item.ID = Convert.ToInt32(dr["C002"]);
item.FieldName = dr["C003"].ToString();
item.FieldType = Convert.ToInt32(dr["C004"]);
item.AllowCondition = dr["C011"].ToString();
optReturn = XMLHelper.SeriallizeObject(item);
if (!optReturn.Result)
{
return(optReturn);
}
listReturn.Add(optReturn.Data.ToString());
}
optReturn.Data = listReturn;
}
catch (Exception ex)
{
optReturn.Result = false;
optReturn.Code = Defines.RET_FAIL;
optReturn.Message = ex.Message;
return(optReturn);
}
return(optReturn);
}
public override void Strategy(StrategyInfo oInfo)
{
StringBuilder sb = new StringBuilder();
oInfo.Dump(sb);
Console.Out.Write(sb);
}
/// <summary>
/// Initializes the strategies and loads all strategies to state. Note: Skips initialization if already initialized.
/// </summary>
public void Initialize(bool includeTestStrategies)
{
using (LogGroup logGroup = LogGroup.StartDebug("Initializing the business strategies."))
{
if (!StrategyState.IsInitialized)
{
StrategyInfo[] strategies = new StrategyInfo[]{};
if (IsCached)
{
LogWriter.Debug("Is cached. Loading from XML.");
strategies = LoadStrategies();
}
else
{
LogWriter.Debug("Is not cached. Scanning from type attributes.");
strategies = FindStrategies(includeTestStrategies);
Saver.SaveToFile(strategies);
}
Initialize(strategies);
}
else
LogWriter.Debug("Already initialized.");
}
}
public static bool IsAnalytics(this StrategyInfo info)
{
return(info != null && info.Type == StrategyInfoTypes.Analytics);
}
/// <summary>
/// Initializes the strategies and loads all strategies to state.
/// </summary>
/// <param name="strategies">The strategies to initialize.</param>
public void Initialize(StrategyInfo[] strategies)
{
StrategyState.Strategies = new StrategyStateNameValueCollection(strategies);
}
public static bool IsStrategy(this StrategyInfo info)
{
return(info != null && (info.Type == StrategyInfoTypes.Assembly || info.Type == StrategyInfoTypes.Diagram || info.Type == StrategyInfoTypes.SourceCode));
}
public void Test_Found_ForIEntityInterface()
{
StrategyInfo strategy = StrategyState.Strategies["Save", "IEntity"];
Assert.IsNotNull(strategy);
}
public static bool IsTerminal(this StrategyInfo info)
{
return(info != null && info.Type == StrategyInfoTypes.Terminal);
}
/* ----------------------------------------------------------- */
public override void Strategy(StrategyInfo oInfo)
{
StringBuilder sb = new StringBuilder();
oInfo.Dump(sb);
debug(sb);
}
public async Task Invoke(HttpContext context)
{
// Set the initial multitenant context into the Items collections.
if (!context.Items.ContainsKey(Constants.HttpContextMultiTenantContext))
{
var multiTenantContext = new MultiTenantContext();
var store = context.RequestServices.GetRequiredService <IMultiTenantStore>();
var storeInfo = new StoreInfo();
storeInfo.MultiTenantContext = multiTenantContext;
storeInfo.Store = store;
if (store.GetType().IsGenericType&&
store.GetType().GetGenericTypeDefinition() == typeof(MultiTenantStoreWrapper <>))
{
storeInfo.StoreType = store.GetType().GetGenericArguments().First();
}
else
{
storeInfo.StoreType = store.GetType();
}
multiTenantContext.StoreInfo = storeInfo;
var strategy = context.RequestServices.GetRequiredService <IMultiTenantStrategy>();
var strategyInfo = new StrategyInfo();
strategyInfo.MultiTenantContext = multiTenantContext;
strategyInfo.Strategy = strategy;
if (strategy.GetType().IsGenericType&&
strategy.GetType().GetGenericTypeDefinition() == typeof(MultiTenantStrategyWrapper <>))
{
strategyInfo.StrategyType = strategy.GetType().GetGenericArguments().First();
}
else
{
strategyInfo.StrategyType = strategy.GetType();
}
multiTenantContext.StrategyInfo = strategyInfo;
context.Items.Add(Constants.HttpContextMultiTenantContext, multiTenantContext);
// Try the registered strategy.
var identifier = await strategy.GetIdentifierAsync(context).ConfigureAwait(false);
TenantInfo tenantInfo = null;
if (identifier != null)
{
tenantInfo = await store.TryGetByIdentifierAsync(identifier);
}
// Resolve for remote authentication callbacks if applicable.
if (tenantInfo == null &&
context.RequestServices.GetService <IAuthenticationSchemeProvider>() is MultiTenantAuthenticationSchemeProvider)
{
strategy = (IMultiTenantStrategy)context.RequestServices.GetRequiredService <IRemoteAuthenticationStrategy>();
// Adjust the strategy info in the multitenant context.
strategyInfo.Strategy = strategy;
strategyInfo.StrategyType = strategy.GetType();
identifier = await strategy.GetIdentifierAsync(context).ConfigureAwait(false);
if (identifier != null)
{
tenantInfo = await store.TryGetByIdentifierAsync(identifier);
}
}
// Set the tenant info in the multitenant context if applicable.
if (tenantInfo != null)
{
multiTenantContext.TenantInfo = tenantInfo;
tenantInfo.MultiTenantContext = multiTenantContext;
}
}
if (next != null)
{
await next(context);
}
}
public override void Strategy(StrategyInfo oInfo)
{
}
public RemoveStrategyInfoCommand(StrategyInfo info)
{
Info = info;
}
