public IPromise <ExplicitHashCredentials> HashCredentials(ICredentials credentials, bool async)
{
var explicitCred = credentials as ExplicitCredentials;
var hashCred = credentials as ExplicitHashCredentials;
if (explicitCred != null)
{
return(Promises.Resolved(new ExplicitHashCredentials(explicitCred.Database, explicitCred.Username, ElementFactory.Local.CalcMd5(explicitCred.Password))));
}
else if (hashCred != null)
{
return(Promises.Resolved(hashCred));
}
else
{
throw new NotSupportedException("This connection implementation does not support the specified credential type");
}
}
private void LoadOuter()
{
this.ReflectionHelpers = new ReflectionHelpers();
this.DataStore = new DataStore();
this.Promises = new Promises();
this.LoadHelpers = new LoadHelpers();
this.Timers = new Timers();
this.LogHelpers = new LogHelpers();
this.ModFeaturesHelpers = new ModFeaturesHelpers();
this.PacketProtocolMngr = new PacketProtocolManager();
this.BuffHelpers = new BuffHelpers();
this.NetHelpers = new NetHelpers();
this.ItemIdentityHelpers = new ItemIdentityHelpers();
this.NPCIdentityHelpers = new NPCIdentityHelpers();
this.ProjectileIdentityHelpers = new ProjectileIdentityHelpers();
this.BuffIdentityHelpers = new BuffIdentityHelpers();
this.NPCBannerHelpers = new NPCBannerHelpers();
this.RecipeIdentityHelpers = new RecipeIdentityHelpers();
this.RecipeGroupHelpers = new RecipeGroupHelpers();
this.PlayerHooks = new ExtendedPlayerHooks();
this.WorldStateHelpers = new WorldStateHelpers();
this.ControlPanel = new UIControlPanel();
this.ModLock = new ModLockService();
this.EntityGroups = new EntityGroups();
this.PlayerMessages = new PlayerMessages();
this.Inbox = new InboxControl();
this.GetModInfo = new GetModInfo();
this.GetModTags = new GetModTags();
this.MenuItemMngr = new MenuItemManager();
this.MenuContextMngr = new MenuContextServiceManager();
this.MusicHelpers = new MusicHelpers();
this.PlayerIdentityHelpers = new PlayerIdentityHelpers();
this.CustomEntMngr = new CustomEntityManager();
this.CustomHotkeys = new CustomHotkeys();
this.XnaHelpers = new XnaHelpers();
this.ServerInfo = new ServerInfo();
//this.PlayerDataMngr = new PlayerDataManager();
this.SupportInfo = new SupportInfoDisplay();
this.RecipeHack = new RecipeHack();
this.ModListHelpers = new ModListHelpers();
}
public static IPromise <IEditorProxy> FromConn(ConnectionData conn)
{
Func <ConnectionData, IPromise <IEditorProxy> > factory;
if (_factories.TryGetValue(conn.Type, out factory))
{
return(factory.Invoke(conn));
}
else
{
switch (conn.Type)
{
case ConnectionType.Innovator:
return(conn.ArasLogin(true)
.Convert(c => (IEditorProxy) new Editor.ArasEditorProxy(c, conn)));
}
return(Promises.Rejected <IEditorProxy>(new NotSupportedException("Unsupported connection type")));
}
}
internal CustomEntityManager()
{
this.InitializeUpdate();
this.InitializeEntityTypes();
this.InitializeComponentTypes();
this.InitializeDrawingLayer();
// Reset any data from previous games
Promises.AddPostWorldUnloadEachPromise(() => {
lock (CustomEntityManager.MyLock) {
this.WorldEntitiesByIndexes.Clear();
this.WorldEntitiesByComponentType.Clear();
}
});
// Bind 'data dump' hotkey
DataDumper.SetDumpSource("CustomEntityList", () => {
lock (CustomEntityManager.MyLock) {
return(string.Join("\n ", this.WorldEntitiesByIndexes.OrderBy(kv => kv.Key)
.SafeSelect(kv => kv.Key + ": " + kv.Value?.ToString() ?? "null")));
}
});
// Refresh entity owners on player connect and sync entities to player
if (Main.netMode == 2)
{
Promises.AddValidatedPromise <PlayerLogicPromiseArguments>(PlayerLogic.ServerConnectValidator, (args) => {
if (this.WorldEntitiesByIndexes.Count == 0)
{
return(true);
}
foreach (var ent in this.WorldEntitiesByIndexes.Values)
{
ent.RefreshOwnerWho();
}
PacketProtocolSendToClient.QuickSend <CustomEntityAllProtocol>(args.Who, -1);
return(true);
});
}
}
public override void SetDefaults()
{
this.DisplayName.SetDefault("Train");
this.Description.SetDefault("Your home away from home.");
Main.buffNoTimeDisplay[this.Type] = true;
Main.buffNoSave[this.Type] = true;
if (!OnARailMod.Instance.HasBuffPromise)
{
OnARailMod.Instance.HasBuffPromise = true;
Promises.AddValidatedPromise <PlayerPromiseArguments>(OnARailPlayer.PlayerFuncsValidator, (args) => {
var mybuff = OnARailMod.Instance.GetBuff <TrainMountBuff>();
mybuff.RunUpdateForPlayer(Main.player[args.Who]);
return(true);
});
}
}
private async Task <IEnumerable <ICompletionData> > Columns(SqlTableInfo info, bool includeAlias = true)
{
var result = new List <ICompletionData>();
var alias = info.Alias;
if (this._tableNameColumnPrefix && info.Name != null)
{
alias = "[" + info.Name.Name + "]";
}
if (!includeAlias)
{
alias = null;
}
if (info.Columns == null && info.AdditionalColumns == null)
{
var allProps = await _provider.GetColumnNames(info.Name.FullName).ToTask();
result.AddRange(new PropertyCompletionFactory().GetCompletions(allProps, alias));
}
else
{
if (info.Columns != null)
{
result.AddRange(info.Columns
.Select(c => ColumnCompletion(c, alias)));
}
if (info.AdditionalColumns != null)
{
var properties = (await Promises.All(info.AdditionalColumns
.Select(i => _provider.GetColumnNames(i.Name.FullName)).ToArray())
.ToTask()).OfType <IEnumerable <IListValue> >();
var allProps = properties.SelectMany(p => p);
result.AddRange(new PropertyCompletionFactory().GetCompletions(allProps, alias));
}
}
return(result);
}
public void ExceptionThrownInDoneShouldBeReportedToSinkExceptionHandler()
{
Promises.ResetSinkExceptionHandler(e => exceptions.Add(e));
var source = new Deferred <TWrapper <int> > ();
source.Done(_ => {
throw new Exception();
});
source.Done(_ => {
throw new Exception();
});
source.Resolve(1.Wrap());
source.Done(_ => {
throw new Exception();
});
source.Done(_ => {
throw new Exception();
});
Assert.That(exceptions.Count, Is.EqualTo(4));
}
private void UpdatePlayerState()
{
if (this.player.dead)
{
return;
}
this.IsInInitLockdown = !LoadHelpers.IsWorldSafelyBeingPlayed();
if (this.IsInInitLockdown)
{
PlayerHelpers.LockdownPlayerPerTick(this.player);
}
var args = new PlayerPromiseArguments {
Who = this.player.whoAmI
};
Promises.TriggerValidatedPromise(OnARailPlayer.PlayerFuncsValidator, OnARailPlayer.MyValidatorKey, args);
}
public static IPromise <IEditorProxy> FromConn(ConnectionData conn)
{
Func <ConnectionData, IPromise <IEditorProxy> > factory;
if (_factories.TryGetValue(conn.Type, out factory))
{
return(factory.Invoke(conn));
}
else
{
switch (conn.Type)
{
case ConnectionType.Innovator:
return(conn.ArasLogin(true)
.Convert(c => (IEditorProxy) new Editor.ArasEditorProxy(c, conn)));
case ConnectionType.Soap:
var http = new HttpClient();
return(http.GetStreamAsync(conn.Url).ToPromise()
.Convert(r =>
{
ServiceDescription descrip;
using (var reader = new StreamReader(r))
using (var xml = XmlReader.Create(reader))
{
descrip = ServiceDescription.Read(xml);
}
return (IEditorProxy) new Editor.SoapEditorProxy(conn, descrip
, Editor.XmlSchemas.SchemasFromDescrip(descrip));
}));
case ConnectionType.SqlServer:
return(Promises.Resolved <IEditorProxy>(new Editor.SqlEditorProxy(conn)));
case ConnectionType.Sharepoint:
return(new Editor.SharepointEditorProxy(conn).Initialize().ToPromise());
}
return(Promises.Rejected <IEditorProxy>(new NotSupportedException("Unsupported connection type")));
}
}
public Promise <T[]> Create(List <Promise <T> > promises)
{
this.promises = promises;
resolvedCount = 0;
if (promises.Count == 0)
{
return(Promises.Resolved(new T[0]));
}
size = promises.Count;
deferred = new Deferred <T[]>();
result = new T[size];
for (int i = 0; i < size; i++)
{
ObservePromise(i);
}
;
return(deferred);
}
public static void IsListModProperlyPresented(string modName, Action <bool> callback)
{
Promises.AddValidatedPromise <ModInfoListPromiseArguments>(GetModInfo.ModInfoListPromiseValidator, (args) => {
if (args.Found && args.ModInfo.ContainsKey(modName))
{
BasicModInfoEntry modInfo = args.ModInfo[modName];
bool isProper = ModIdentityHelpers.IsProperlyPresented(modInfo);
callback(isProper);
}
else
{
if (ModHelpersMod.Instance.Config.DebugModeNetInfo)
{
LogHelpers.Log("Error retrieving mod data for '" + modName + "'"); //+ "': " + reason );
}
}
return(false);
});
}
////////////////
public override void Load(TagCompound tags)
{
//DataStore.Add( DebugHelpers.GetCurrentContext()+"_"+this.player.name+":"+this.player.whoAmI+"_A", 1 );
try {
//PlayerData.LoadAll( this.player.whoAmI, tags );
this.Logic.Load(tags);
var args = new PlayerPromiseArguments {
Who = this.player.whoAmI
};
Promises.TriggerValidatedPromise(ModHelpersPlayer.LoadValidator, ModHelpersPlayer.MyValidatorKey, args);
} catch (Exception e) {
if (!(e is HamstarException))
{
//throw new HamstarException( "!ModHelpers.ModHelpersPlayer.Load - " + e.ToString() );
throw new HamstarException(e.ToString());
}
}
//DataStore.Add( DebugHelpers.GetCurrentContext()+"_"+this.player.name+":"+this.player.whoAmI+"_B", 1 );
}
/// <summary>
/// Calls a SOAP action asynchronously
/// </summary>
/// <param name="request">Request AML and possibly files <see cref="UploadCommand" /></param>
/// <param name="async">Whether to perform this action asynchronously</param>
/// <returns>
/// A promise to return an XML SOAP response as a string
/// </returns>
public IPromise <Stream> Process(Command request, bool async)
{
var upload = request as UploadCommand;
if (upload == null)
{
if (request.Action == CommandAction.DownloadFile)
{
return(_vaultConn.Download(request, async));
}
var input = new XmlDocument();
input.LoadXml(request.ToNormalizedAml(AmlContext.LocalizationContext));
var output = new XmlDocument();
using (new LogData(4
, "Innovator: Execute query"
, request.LogListener ?? Factory.LogListener
, request.Parameters)
{
{ "database", _httpDatabase },
{ "query", request.Aml },
{ "soap_action", request.ActionString },
{ "url", _requestUrl },
{ "user_name", _httpUsername },
{ "user_id", UserId },
{ "version", Version }
})
{
_callAction(request.ActionString, input, output);
}
return(Promises.Resolved <Stream>(new XmlStream(() => new XmlNodeReader(output))));
}
// Files need to be uploaded, so build the vault request
return(_vaultConn.Upload(upload, async));
}
public IPromise <IEnumerable <ListValue> > ListValues(string id)
{
IEnumerable <ListValue> result;
if (_listValues.TryGetValue(id, out result))
{
return(Promises.Resolved(result));
}
return(_conn.ApplyAsync("<Item type='List' action='get' id='@0' select='id,description,name,label'><Relationships><Item type='Value' action='get' select='label,value' /><Item type='Filter Value' action='get' select='label,value,filter' /></Relationships></Item>"
, true, false, id)
.Convert(r =>
{
var values = (IEnumerable <ListValue>)r.AssertItem().Relationships()
.Select(i => new ListValue()
{
Label = i.Property("label").Value,
Value = i.Property("value").Value
}).ToArray();
_listValues[id] = values;
return values;
}));
}
////////////////
public override void Load(TagCompound tags)
{
//DataStore.Add( DebugHelpers.GetCurrentContext()+"_A", 1 );
var mymod = (ModHelpersMod)this.mod;
if (tags.ContainsKey("world_id"))
{
this.ObsoleteId = tags.GetString("world_id");
}
//mymod.UserHelpers.Load( mymod, tags );
mymod.ModLock.Load(tags);
this.WorldLogic.LoadForWorld(tags);
mymod.ModLock.PostLoad(this);
//mymod.UserHelpers.OnWorldLoad( this );
Promises.TriggerValidatedPromise(ModHelpersWorld.LoadValidator, ModHelpersWorld.MyValidatorKey, null);
this.HasObsoleteId = true;
//DataStore.Add( DebugHelpers.GetCurrentContext()+"_B", 1 );
}
public override TagCompound Save()
{
var tags = new TagCompound();
try {
var args = new PlayerPromiseArguments {
Who = this.player.whoAmI
};
//PlayerData.SaveAll( this.player.whoAmI, tags );
Promises.TriggerValidatedPromise(ModHelpersPlayer.SaveValidator, ModHelpersPlayer.MyValidatorKey, args);
this.Logic.Save(tags);
} catch (Exception e) {
if (!(e is HamstarException))
{
throw new HamstarException(e.ToString());
}
}
return(tags);
}
private Promise <CUnit> CallApi()
{
Debug.Log("CallApi called");
return(Promises.Rejected <CUnit>(new SystemException()));
}
// private Promise<CUnit> apiResponseChain;
void Start()
{
// ActionMethod(() => {
// Debug.Log("1");
// ActionMethod(() => {
// Debug.Log("2");
// ActionMethod(() => {
// Debug.Log("3");
// });
// });
// });
//
// var promise = new Deferred<CUnit>();
// promise.Done(_ =>
// {
// Debug.Log("4");
// }).Done(_ =>
// {
// Debug.Log("5");
// }).Done(_ =>
// {
// Debug.Log("6");
// });
// promise.Resolve(CUnit.Default);
//
// Debug.Log("promise.State = " + promise.State);
// Debug.Log("promise.IsResolved = " + promise.IsResolved);
// Debug.Log("promise.IsRejected = " + promise.IsRejected);
// Debug.Log("promise.IsPending = " + promise.IsPending);
// Debug.Log("promise.IsDisposed = " + promise.IsDisposed);
// PromiseResolved().Then(_ =>
// {
// Debug.Log("1");
// return PromiseResolved();
// }).Then(_ =>
// {
// Debug.Log("2");
// return PromiseResolved();
// }).Then(_ =>
// {
// Debug.Log("3");
// return PromiseResolved();
// }).Then(_ => PromiseResolved(), _ => PromiseRejected());
// var promise = new Deferred<CUnit>();
// promise.Then(_ =>
// {
// Debug.Log("resolve");
// return Promises.Resolved(CUnit.Default);
// }, _ =>
// {
// Debug.Log("reject");
// return Promises.Rejected<CUnit>(new SystemException());
// }).Then(_ =>
// {
// Debug.Log("rresolve2");
// return Promises.Resolved(CUnit.Default);
// });
// promise.Resolve(CUnit.Default);
// promise.Reject(new SystemException());
// var promise = new Deferred<CUnit>();
// promise.Then(_ =>
// {
// Debug.Log("done");
// return Promises.Resolved(CUnit.Default);
// }, _ =>
// {
// Debug.Log("fail");
// return Promises.Rejected<CUnit>(new SystemException());
// }).Finally(() =>
// {
// Debug.Log("Finally");
// });
//
// promise.Reject(new SystemException());
// var promise = new Deferred<CUnit>();
// promise.Select(_ => "done").Done(str => Debug.Log(str))
// .Select(_ => "fail").Fail(str => Debug.Log(str));
// promise.Resolve(CUnit.Default);
// promise.Reject(new SystemException());
var promise = new Deferred <CUnit>();
promise.Then(_ => CallApi()).Then(_ =>
{
return(null);
}, _ =>
{
SaveApiToDatabase();
return(Promises.Resolved(CUnit.Default));
}).Then(_ => OutputMessage());
promise.Resolve(CUnit.Default);
}
public override void SetDefaults()
{
int total_frames = 4;
var player_y_offsets = new int[total_frames];
for (int i = 0; i < player_y_offsets.Length; i++)
{
player_y_offsets[i] = 32;
}
this.mountData.Minecart = true;
this.mountData.MinecartDirectional = true;
this.mountData.MinecartDust = new Action <Vector2>(DelegateMethods.Minecart.Sparks);
this.mountData.spawnDust = 213;
this.mountData.buff = this.mod.BuffType("TrainMountBuff");
//this.mountData.extraBuff = 185;
this.mountData.flightTimeMax = 0;
this.mountData.fallDamage = 1f;
this.mountData.runSpeed = 20f; //10f;
this.mountData.dashSpeed = 10f;
this.mountData.acceleration = 0.05f; //0.03f;
this.mountData.jumpHeight = 2; //12;
this.mountData.jumpSpeed = 5.15f;
this.mountData.blockExtraJumps = true;
this.mountData.totalFrames = total_frames;
this.mountData.heightBoost = 30;
this.mountData.playerYOffsets = player_y_offsets;
this.mountData.xOffset = 0; //8;
this.mountData.yOffset = 2;
this.mountData.bodyFrame = 3;
this.mountData.playerHeadOffset = 14;
this.mountData.standingFrameCount = 1;
this.mountData.standingFrameDelay = 12;
this.mountData.standingFrameStart = 0;
this.mountData.runningFrameCount = 4;
this.mountData.runningFrameDelay = 12;
this.mountData.runningFrameStart = 0;
this.mountData.flyingFrameCount = 0;
this.mountData.flyingFrameDelay = 0;
this.mountData.flyingFrameStart = 0;
this.mountData.inAirFrameCount = 0;
this.mountData.inAirFrameDelay = 0;
this.mountData.inAirFrameStart = 0;
this.mountData.idleFrameCount = 4;
this.mountData.idleFrameDelay = 12;
this.mountData.idleFrameStart = 0;
this.mountData.idleFrameLoop = false;
if (Main.netMode != 2)
{
this.mountData.textureWidth = this.mountData.backTexture.Width;
this.mountData.textureHeight = this.mountData.backTexture.Height;
}
if (!OnARailMod.Instance.HasMountPromise)
{
OnARailMod.Instance.HasMountPromise = true;
Promises.AddValidatedPromise <PlayerPromiseArguments>(OnARailPlayer.PlayerFuncsValidator, (args) => {
var mymount = OnARailMod.Instance.GetMount <TrainMount>();
mymount.RunUpdateForPlayer(Main.player[args.Who]);
return(true);
});
}
}
/// <summary>
/// Gets a promise to return information about all properties of a given Item Type
/// </summary>
public IPromise <IEnumerable <Property> > GetProperties(ItemType itemType)
{
if (_conn == null || itemType.Properties.Count > 0)
{
return(Promises.Resolved <IEnumerable <Property> >(itemType.Properties.Values));
}
var xPropQuery = default(string);
if (_itemTypesById.ContainsKey("A253DB1415194344AEFB5E6A2029AB3A"))
{
xPropQuery = @"<Item type='ItemType_xPropertyDefinition' action='get' select='related_id(name,label,data_type,data_source,stored_length,prec,scale,default_value,column_width,is_required,readonly)'></Item>";
}
var aml = $@"<AML>
<Item action='get' type='ItemType' select='name'>
<name>@0</name>
<Relationships>
<Item action='get' type='Property' select='name,label,data_type,data_source,stored_length,prec,scale,foreign_property(name,source_id),is_hidden,is_hidden2,sort_order,default_value,column_width,is_required,readonly,help_text,help_tooltip,class_path,keyed_name_order,default_search,pattern,order_by' />
{xPropQuery}
</Relationships>
</Item>
</AML>";
var promise = _conn.ApplyAsync(aml, true, true, itemType.Name)
.Convert(r =>
{
LoadProperties(itemType, r.AssertItem());
return((IEnumerable <Property>)itemType.Properties.Values);
}).Fail(ex => System.Diagnostics.Debug.Print("PROPLOAD: " + ex.ToString()));
if (!string.IsNullOrEmpty(xPropQuery))
{
promise = promise.Continue(p =>
{
return(_conn.ApplyAsync(@"<Item type='xClassificationTree' action='get' select='id'>
<Relationships>
<Item type='xClassificationTree_ItemType' action='get' select='id'>
<related_id>@0</related_id>
</Item>
<Item action='get' type='xClass' select='id'>
<Relationships>
<Item action='get' type='xClass_xPropertyDefinition' select='related_id(name,label,data_type,data_source,stored_length,prec,scale,default_value,column_width,is_required,readonly)'>
<is_current>1</is_current>
</Item>
</Relationships>
</Item>
</Relationships>
</Item>", true, false, itemType.Id));
}).Convert(r =>
{
foreach (var prop in r.Items()
.SelectMany(i => i.Relationships("xClass"))
.SelectMany(i => i.Relationships("xClass_xPropertyDefinition"))
.Select(i => i.RelatedItem()))
{
var newProp = Property.FromItem(prop, itemType);
itemType.Properties[newProp.Name] = newProp;
}
return((IEnumerable <Property>)itemType.Properties.Values);
}).Fail(ex => System.Diagnostics.Debug.Print("PROPLOAD: " + ex.ToString()));
}
return(promise);
}
////////////////
internal LogHelpers()
{
this.Reset();
Promises.AddWorldUnloadEachPromise(this.OnWorldExit);
}
internal static void PostLoadAll()
{
SaveableEntityComponent.HaveAllEntitiesLoaded = true;
Promises.TriggerValidatedPromise(SaveableEntityComponent.LoadAllValidator, SaveableEntityComponent.MyValidatorKey, null);
}
public static CustomEntity AddToWorld(int who, CustomEntity ent, bool skipSync = false)
{
//if( ent == null ) { throw new HamstarException( "!ModHelpers.CustomEntityManager.AddToWorld - Null ent not allowed." ); }
//if( !ent.IsInitialized ) { throw new HamstarException( "!ModHelpers.CustomEntityManager.AddToWorld - Initialized ents only." ); }
if (ent == null)
{
throw new HamstarException("Null ent not allowed.");
}
if (!ent.IsInitialized)
{
throw new HamstarException("Initialized ents only.");
}
CustomEntityManager mngr = ModHelpersMod.Instance.CustomEntMngr;
CustomEntity realEnt = ent;
if (mngr.WorldEntitiesByIndexes.ContainsKey(who))
{
//throw new HamstarException( "!ModHelpers.CustomEntityManager.AddToWorld - "
// + "Attempting to add "+ent.ToString()+" to slot "+who+" occupied by "+mngr.WorldEntitiesByIndexes[who].ToString() );
throw new HamstarException("Attempting to add " + ent.ToString() + " to slot " + who + " occupied by "
+ mngr.WorldEntitiesByIndexes[who].ToString());
}
if (ent is SerializableCustomEntity)
{
realEnt = ((SerializableCustomEntity)ent).Convert();
}
Type compType;
Type baseType = typeof(CustomEntityComponent);
// Map entity to each of its components
foreach (CustomEntityComponent component in realEnt.InternalComponents)
{
compType = component.GetType();
lock (CustomEntityManager.MyLock) {
do
{
if (!mngr.WorldEntitiesByComponentType.ContainsKey(compType))
{
mngr.WorldEntitiesByComponentType[compType] = new HashSet <int>();
}
mngr.WorldEntitiesByComponentType[compType].Add(who);
compType = compType.BaseType;
} while(compType != baseType);
}
}
realEnt.Core.whoAmI = who;
mngr.WorldEntitiesByIndexes[who] = realEnt;
realEnt.InternalOnAddToWorld();
// Sync also
if (!skipSync)
{
if (Main.netMode == 1)
{
if (ent.SyncFromClient)
{
Promises.AddValidatedPromise(SaveableEntityComponent.LoadAllValidator, () => {
ent.SyncToAll();
return(false);
});
}
}
else if (Main.netMode == 2)
{
if (ent.SyncFromServer)
{
Promises.AddValidatedPromise(SaveableEntityComponent.LoadAllValidator, () => {
ent.SyncToAll();
return(false);
});
}
}
}
if (ModHelpersMod.Instance.Config.DebugModeCustomEntityInfo)
{
LogHelpers.Alert("Set " + realEnt.ToString());
}
return(realEnt);
}
public static void AddPostLoadPromise(Action action)
{
Promises.AddPostModLoadPromise(action);
}
////////////////
private void SetCurrentMod(UIState ui, string modName)
{
this.CurrentModName = modName;
Promises.AddValidatedPromise <ModTagsPromiseArguments>(GetModTags.TagsReceivedPromiseValidator, (args) => {
if (!args.Found)
{
LogHelpers.Warn();
return(false);
}
this.AllModTagsSnapshot = args.ModTags;
ISet <string> netModTags = args.Found && args.ModTags.ContainsKey(modName) ?
args.ModTags[modName] :
new HashSet <string>();
bool hasNetTags = netModTags.Count > 0;
//LogHelpers.Log( "SetCurrentMod modname: " + modName + ", modTags: " + string.Join(",", netModTags ) );
if (hasNetTags)
{
this.InfoDisplay.SetDefaultText("Do these tags look incorrect? If so, modify them.");
this.FinishButton.SetModeReadOnly();
this.ResetButton.Disable();
}
else
{
this.InfoDisplay.SetDefaultText("No tags set for this mod. Why not add some?");
this.FinishButton.SetModeSubmit();
}
foreach (var kv in this.TagButtons)
{
string tagName = kv.Key;
UITagButton button = kv.Value;
bool hasTag = netModTags.Contains(tagName);
if (!hasNetTags)
{
button.Enable();
}
if (tagName == "Low Effort")
{
if (hasTag)
{
button.SetTagState(1);
}
else
{
string desc = this.GetModDataFromActiveMod(modName, "description");
if (string.IsNullOrEmpty(desc))
{
string _ = "";
desc = this.GetModDescriptionFromUI(modName, ref _);
}
if (desc.Contains("Modify this file with a description of your mod."))
{
button.SetTagState(1);
}
}
}
else
{
button.SetTagState(hasTag ? 1 : 0);
}
}
return(false);
});
}
public IPromise <CompletionContext> Completions(string prefix, ITextSource all, int caret, string termCharacter
, bool tableNameColumnPrefix = false)
{
try
{
_tableNameColumnPrefix = tableNameColumnPrefix;
var lastIndex = string.IsNullOrEmpty(termCharacter) ? -1 : all.IndexOf(termCharacter, caret, all.TextLength - caret, StringComparison.Ordinal);
var sql = prefix + (lastIndex < 0 ? all.GetText(caret, all.TextLength - caret) : all.GetText(caret, lastIndex - caret));
if (sql.StartsWith("(") && sql.EndsWith(")"))
{
sql = sql.Substring(1, sql.Length - 2);
}
var parseTree = new SqlTokenizer(sql).Parse();
if (!parseTree.Any())
{
return(Promises.Resolved(new CompletionContext()));
}
var currNode = parseTree.NodeByOffset(prefix.Length);
var literal = currNode as SqlLiteral;
if (literal != null)
{
var parGroup = literal.Parent as SqlGroup;
if (_overloadWin != null && (parGroup == null || !parGroup.First().TextEquals(_overloadName)))
{
_overloadWin.Close();
}
if (SqlTokenizer.KeywordPrecedesTable(literal))
{
var context = new SqlContext(parGroup);
return(ContextFromData(Tables(null).Concat(Schemas())
.Concat(context.Definitions.Select(d => new SqlGeneralCompletionData()
{
Text = d,
Description = "Locally defined table",
Image = Icons.Class16.Wpf
}))
.OrderBy(i => i.Text)));
}
else if (literal.Text == "(")
{
var prev = literal.PreviousLiteral();
if (prev != null)
{
if (CurrentTextArea != null)
{
var overloads = from f in _coreFunctions
where string.Equals(f.Name, prev.Text, StringComparison.OrdinalIgnoreCase)
select new Overload(f.Usage, f.Description);
if (overloads.Any())
{
_overloadWin = new OverloadInsightWindow(CurrentTextArea);
_overloadWin.StartOffset = caret;
_overloadWin.EndOffset = caret + 1;
_overloadWin.Provider = new OverloadList().AddRange(overloads);
_overloadWin.Show();
_overloadWin.Closed += (s, e) => {
_overloadWin = null;
_overloadName = null;
};
_overloadName = prev.Text;
}
}
switch (prev.Text.ToUpperInvariant())
{
case "DATEADD":
case "DATEDIFF":
case "DATEDIFF_BIG":
case "DATEFROMPARTS":
case "DATENAME":
case "DATEPART":
return(ContextFromData(_datePartNames.Select(n => new SqlGeneralCompletionData()
{
Text = n[0] + (n[1] == n[0] ? "" : " (" + n[1] + ")"),
Description = n[1],
Image = Icons.EnumValue16.Wpf,
Action = () => n[0]
})
.OrderBy(i => i.Text)));
}
}
}
else if (literal.Text == ".")
{
var name = literal.Parent as SqlName;
if (name != null)
{
if (name.IsTable)
{
var idx = name.IndexOf(literal);
var schema = name[idx - 1].Text;
if (_provider.GetSchemaNames().Contains(schema, StringComparer.OrdinalIgnoreCase))
{
return(ContextFromData(Tables(schema).Concat(Functions(true, schema))
.OrderBy(i => i.Text)));
}
}
else
{
var group = name.Parent as SqlGroup;
if (group != null)
{
var idx = name.IndexOf(literal);
var context = new SqlContext(group);
SqlTableInfo info;
if (idx > 0 && name[idx - 1] is SqlLiteral &&
context.TryByName(((SqlLiteral)name[idx - 1]).Text.ToLowerInvariant(), out info))
{
return(Columns(info, false).ToPromise().Convert(c => new CompletionContext()
{
Items = c
}));
}
}
}
}
}
else if (literal.Type == SqlType.Keyword ||
literal.Type == SqlType.Operator)
{
switch (literal.Text.ToLowerInvariant())
{
case "union":
return(ContextFromData(MatchCase(literal.Text, "all", "select")
.GetCompletions <SqlGeneralCompletionData>()));
case "group":
case "order":
case "partition":
return(ContextFromData(MatchCase(literal.Text, "by")
.GetCompletions <SqlGeneralCompletionData>()));
case "insert":
return(ContextFromData(MatchCase(literal.Text, "into")
.GetCompletions <SqlGeneralCompletionData>()));
case "delete":
return(ContextFromData(MatchCase(literal.Text, "from")
.GetCompletions <SqlGeneralCompletionData>()));
}
var group = literal.Parent as SqlGroup;
if (group != null)
{
// List of sql specific constructs for the context
var sqlOthers = new List <string>();
switch (literal.Text.ToLowerInvariant())
{
case "select":
sqlOthers.Add("*");
sqlOthers.Add("distinct");
sqlOthers.Add("top");
break;
}
// Table aliases and functions
var context = new SqlContext(group);
var others = context.Tables
.Where(t => !string.IsNullOrEmpty(t.Alias))
.Select(t => t.Alias)
.Distinct()
.Select(t => new SqlGeneralCompletionData()
{
Text = t,
Image = Icons.Class16.Wpf
})
.Concat(Functions(false, null));
// Table columns
return(Promises.All(context.Tables.Select(t => Columns(t).ToPromise()).ToArray())
.Convert(l => new CompletionContext()
{
Items = l.OfType <IEnumerable <ICompletionData> >()
.SelectMany(p => p)
.Concat(MatchCase(literal.Text, sqlOthers).Select(o => new SqlGeneralCompletionData()
{
Text = o,
Image = Icons.Operator16.Wpf
}))
.Concat(others)
.Concat(Schemas())
.OrderBy(i => i.Text, StringComparer.OrdinalIgnoreCase)
}));
}
}
}
return(Promises.Resolved(new CompletionContext()));
}
catch (Exception ex)
{
return(Promises.Rejected <CompletionContext>(ex));
}
}
public static IPromise <IEnumerable <ICompletionData> > GetPromise <T>
(Action <T> configure, params string[] values) where T : IMutableCompletionData, new()
{
return(Promises.Resolved(values.GetCompletions <T>(configure)));
}
public static IPromise <IEnumerable <ICompletionData> > GetPromise <T>(
this IEnumerable <string> values, Action <T> configure = null) where T : IMutableCompletionData, new()
{
return(Promises.Resolved(values.GetCompletions <T>(configure)));
}
public IPromise <Stream> Process(Command request, bool async)
{
return(Promises.Resolved(Process(request)));
}
public IPromise <Version> FetchVersion(bool async)
{
return(Promises.Resolved(this.Version));
}
