public async Task <dynamic> postMaintenanceFlag([FromBody] MaintenanceDTO request)
{
var existingData = db.ServerFlags.Where(acs => acs.ServerFlag == "maintenance_mode").FirstOrDefault();
if (existingData != null)
{
existingData.Value = request.IsActive.ToString();
existingData.FromDt = request.FromDt;
existingData.ToDt = request.ToDt;
db.ServerFlags.Attach(existingData);
db.Entry(existingData).State = EntityState.Modified;
}
else
{
var flag = new ServerFlags()
{
ServerFlag = "maintenance_mode",
FromDt = request.FromDt,
ToDt = request.ToDt,
Value = request.IsActive.ToString()
};
db.ServerFlags.Add(flag);
}
db.SaveChanges();
return(Ok("Maintenance Flag Added"));
}
protected override void OnDisabled()
{
base.OnDisabled();
ServerFlags.Clear();
GameEvents.onFlagSelect.Remove(FlagEvents.OnFlagSelect);
GameEvents.onMissionFlagSelect.Remove(FlagEvents.OnMissionFlagSelect);
}
public async Task ServerOptionsAsync([Remainder] string paramString = null)
{
if (IsAdmin())
{
if (null != paramString)
{
ServerFlags features = Config.ServerFlags;
foreach (ServerFlags o in Enum.GetValues(typeof(ServerFlags)))
{
var option = ParseArgs(paramString, o.ToString());
if (option == "true")
{
features = (features | o);
}
else if (option == "false")
{
features &= ~o;
}
}
Config.ServerFlags = features;
Config.SaveConfig();
await ReplyAsync($"Applied settings: {features}");
}
else
{
await ReplyAsync($"Current server options: {Config.ServerFlags}");
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ServerOptions"/> class
/// </summary>
/// <param name="signingKey">Key to use when checking token signatures.</param>
/// <param name="encryptionKey">Key to use when decrypting tokens.</param>
/// <param name="audience">Audience to which tokens should be addressed.</param>
/// <param name="issuer">Issuer by which tokens should have been created.</param>
/// <param name="flags">Additional flags for controlling behaviour.</param>
public ServerOptions(SecurityKey signingKey, SecurityKey encryptionKey, string audience, string issuer, ServerFlags flags)
{
SigningKey = signingKey;
EncryptionKey = encryptionKey;
Audience = audience;
Issuer = issuer;
Flags = flags;
}
private void HandleFlags()
{
if (FlagSystemReady)
{
foreach (var flag in ServerFlags.Where(v => !v.Value.Loaded))
{
HandleFlag(flag.Value);
flag.Value.Loaded = true;
}
}
}
public MogmogConnectionService(GameDataService gameDataService, UserManagerService userManager, MogmogTransmissionService transmitter, IConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
_gameDataService = gameDataService ?? throw new ArgumentNullException(nameof(gameDataService));
_userManager = userManager ?? throw new ArgumentNullException(nameof(userManager));
_transmitter = transmitter ?? throw new ArgumentNullException(nameof(transmitter));
_flags = ServerFlagsParser.ParseFromConfig(config);
_transmitter.MessageSent += SendToClient;
}
private void HandleFlagChangeEvent()
{
var flagUrl = HighLogic.CurrentGame.flagURL;
//If it's not a LMP flag don't sync it.
if (!flagUrl.ToLower().StartsWith("lunamultiplayer/flags/"))
{
return;
}
var flagName = flagUrl.Substring("LunaMultiPlayer/Flags/".Length);
//If the flag is owned by someone else don't sync it
if (ServerFlags.ContainsKey(flagName) &&
(ServerFlags[flagName].Owner != SettingsSystem.CurrentSettings.PlayerName))
{
return;
}
var flagFiles = Directory.GetFiles(FlagPath, "*", SearchOption.TopDirectoryOnly);
var flagFile = flagFiles.FirstOrDefault(f => string.Equals(flagName, Path.GetFileNameWithoutExtension(f),
StringComparison.CurrentCultureIgnoreCase));
//Sanity check to make sure we found the file
if (!string.IsNullOrEmpty(flagFile) && File.Exists(flagFile))
{
var shaSum = Common.CalculateSha256Hash(flagFile);
//Don't send the flag when the SHA sum already matches
if (ServerFlags.ContainsKey(flagName) && (ServerFlags[flagName].ShaSum == shaSum))
{
return;
}
Debug.Log($"[LMP]: Uploading {Path.GetFileName(flagFile)}");
MessageSender.SendMessage(new FlagUploadMsgData
{
PlayerName = SettingsSystem.CurrentSettings.PlayerName,
FlagName = Path.GetFileName(flagFile),
FlagData = File.ReadAllBytes(flagFile)
});
var fi = new FlagInfo
{
Owner = SettingsSystem.CurrentSettings.PlayerName,
ShaSum = Common.CalculateSha256Hash(flagFile)
};
ServerFlags[flagName] = fi;
}
}
public static void LoadConfig()
{
if (File.Exists(ConfigLocation))
{
JSONNode node = JSON.Parse(File.ReadAllText(ConfigLocation));
BotToken = node["BotToken"].Value;
BetaBotToken = node["BetaBotToken"].Value;
Flags = (ServerFlags)Convert.ToInt32(node["ServerFlags"].Value);
}
else
{
BotToken = "[ReleaseToken]";
BetaBotToken = "[BetaToken]";
Flags = 0;
SaveConfig();
}
}
public static ServerFlags ParseFromConfig(IConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
ServerFlags flags = ServerFlags.None;
var enumNames = Enum.GetNames(typeof(ServerFlags));
foreach (var value in enumNames)
{
if (config.GetValue <bool>(value))
{
flags |= (ServerFlags)Enum.Parse(typeof(ServerFlags), value);
}
}
return(flags);
}
public void SendFlag(string flagUrl)
{
//If it's a default flag skip the sending
if (DefaultFlags.DefaultFlagList.Contains(flagUrl))
{
return;
}
//If the flag is owned by someone else don't sync it
if (ServerFlags.TryGetValue(flagUrl, out var existingFlag) && existingFlag.Owner != SettingsSystem.CurrentSettings.PlayerName)
{
return;
}
var textureInfo = GameDatabase.Instance.GetTextureInfo(flagUrl);
if (textureInfo != null)
{
var filePath = CommonUtil.CombinePaths(MainSystem.KspPath, "GameData", $"{flagUrl}.png");
if (!File.Exists(filePath))
{
LunaLog.LogError($"Cannot upload flag {Path.GetFileName(flagUrl)} file not found");
return;
}
var flagData = File.ReadAllBytes(filePath);
if (flagData.Length > 1000000)
{
LunaLog.LogError($"Cannot upload flag {Path.GetFileName(flagUrl)} size is greater than 1Mb!");
return;
}
//Don't send the flag when the SHA sum already matches as that would mean that the server already has it
if (existingFlag != null && existingFlag.ShaSum == Common.CalculateSha256Hash(flagData))
{
return;
}
LunaLog.Log($"[LMP]: Uploading {Path.GetFileName(flagUrl)} flag");
MessageSender.SendMessage(MessageSender.GetFlagMessageData(flagUrl, flagData));
}
}
public override void OnDisabled()
{
base.OnDisabled();
ServerFlags.Clear();
NewFlags.Clear();
}
protected override void OnDisabled()
{
base.OnDisabled();
ServerFlags.Clear();
NewFlags.Clear();
}
