protected virtual void ProcessGenericLocalization(ClientObject obj, Dictionary<string, List<ValueForUICulture>> localizations)
{
var targetProps = localizations.Keys.ToList();
var isSupportedRuntime = ReflectionUtils.HasProperties(obj, targetProps);
if (!isSupportedRuntime)
{
TraceService.Critical((int)LogEventId.ModelProvisionCoreCall,
string.Format("CSOM runtime doesn't have [{0}] methods support. Update CSOM runtime to a new version. Provision is skipped",
string.Join(", ", targetProps)));
return;
}
var needsUpdate = false;
foreach (var key in localizations.Keys)
{
var propName = key;
var localization = localizations[key];
if (localization.Any())
{
var userResource = GetPropertyValue(obj, propName);
foreach (var locValue in localization)
LocalizationService.ProcessUserResource(obj, userResource, locValue);
needsUpdate = true;
}
}
if (needsUpdate)
{
var updateMethod = ReflectionUtils.GetMethod(obj, "Update");
if (updateMethod != null)
{
if (obj is ContentType)
{
updateMethod.Invoke(obj, new object[] { true });
}
else if (obj is Field)
{
updateMethod = ReflectionUtils.GetMethod(obj, "UpdateAndPushChanges");
updateMethod.Invoke(obj, new object[] { true });
}
else
{
updateMethod.Invoke(obj, null);
}
obj.Context.ExecuteQueryWithTrace();
}
else
{
throw new SPMeta2Exception(string.Format("Can't find Update() methods on client object of type:[{0}]", obj.GetType()));
}
}
}
public static void HandlePingRequest(ClientObject client, byte[] messageData)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.PING_REPLY;
newMessage.data = messageData;
ClientHandler.SendToClient(client, newMessage, true);
}
public static void HandleVesselRemoval(ClientObject client, byte[] messageData)
{
using (MessageReader mr = new MessageReader(messageData))
{
//Don't care about the subspace on the server.
mr.Read<double>();
string vesselID = mr.Read<string>();
bool isDockingUpdate = mr.Read<bool>();
if (!isDockingUpdate)
{
DarkLog.Debug("Removing vessel " + vesselID + " from " + client.playerName);
}
else
{
DarkLog.Debug("Removing DOCKED vessel " + vesselID + " from " + client.playerName);
}
if (File.Exists(Path.Combine(Server.universeDirectory, "Vessels", vesselID + ".txt")))
{
lock (Server.universeSizeLock)
{
File.Delete(Path.Combine(Server.universeDirectory, "Vessels", vesselID + ".txt"));
}
}
//Relay the message.
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.VESSEL_REMOVE;
newMessage.data = messageData;
ClientHandler.SendToAll(client, newMessage, false);
}
}
public static void Main()
{
LogManager.WriteLog("Entering Cash Desk Operator EXE", LogManager.enumLogLevel.Debug);
BMCRegistryHelper.ActiveInstallationType = BMCCategorizedInstallationTypes.Exchange;
LogManager.WriteLog("BMCRegistryHelper.InstallationTypes is :" + BMCRegistryHelper.ActiveInstallationType, LogManager.enumLogLevel.Debug);
string strDefaultServerIP = string.Empty;
strDefaultServerIP = BMCRegistryHelper.GetRegKeyValue("Cashmaster\\Exchange", "Default_Server_IP");
clientObj = new ClientObject();
client = new Client("tcp://" + strDefaultServerIP + ConfigManager.Read("ServerIPCUrl"), "RemotingClient", typeof(IServerObject));
client.SendToServer(clientObj, null);
int itmpInterval = Int32.Parse(ConfigManager.Read("IPCInterval")) * 3;
Int32.TryParse(ConfigManager.Read("RemoteServerConnectionCheck"), out iSiteLicensingCheck);
if (iSiteLicensingCheck <= 0)
{
iSiteLicensingCheck = 600;
}
if (itmpInterval > 15)
{
iInteraval = itmpInterval;
}
#if !FLOORVIEW_REFRESH_NEW
siteLicensingClientObj = new ClientObject();
siteLicensingClient = new Client("tcp://" + strDefaultServerIP + ConfigManager.Read("SiteLicensingServerIPCUrl"), "SiteLicensingClient", typeof(ISiteLicenseServerObject));
siteLicensingClient.SendToServer(siteLicensingClientObj, null);
#endif
BMC.PlayerGateway.GatewaySettings.ConnectionString = DatabaseHelper.GetConnectionString();
AppStartUp();
}
public static void HandleSplitMessage(ClientObject client, byte[] messageData)
{
if (!client.isReceivingSplitMessage)
{
//New split message
using (MessageReader mr = new MessageReader(messageData))
{
client.receiveSplitMessage = new ClientMessage();
client.receiveSplitMessage.type = (ClientMessageType)mr.Read<int>();
client.receiveSplitMessage.data = new byte[mr.Read<int>()];
client.receiveSplitMessageBytesLeft = client.receiveSplitMessage.data.Length;
byte[] firstSplitData = mr.Read<byte[]>();
firstSplitData.CopyTo(client.receiveSplitMessage.data, 0);
client.receiveSplitMessageBytesLeft -= firstSplitData.Length;
}
client.isReceivingSplitMessage = true;
}
else
{
//Continued split message
messageData.CopyTo(client.receiveSplitMessage.data, client.receiveSplitMessage.data.Length - client.receiveSplitMessageBytesLeft);
client.receiveSplitMessageBytesLeft -= messageData.Length;
}
if (client.receiveSplitMessageBytesLeft == 0)
{
ClientHandler.HandleMessage(client, client.receiveSplitMessage);
client.receiveSplitMessage = null;
client.isReceivingSplitMessage = false;
}
}
public static void HandleVesselsRequest(ClientObject client, byte[] messageData)
{
using (MessageReader mr = new MessageReader(messageData))
{
int sendVesselCount = 0;
int cachedVesselCount = 0;
List<string> clientRequested = new List<string>(mr.Read<string[]>());
lock (Server.universeSizeLock)
{
foreach (string file in Directory.GetFiles(Path.Combine(Server.universeDirectory, "Vessels")))
{
string vesselID = Path.GetFileNameWithoutExtension(file);
byte[] vesselData = File.ReadAllBytes(file);
string vesselObject = Common.CalculateSHA256Hash(vesselData);
if (clientRequested.Contains(vesselObject))
{
sendVesselCount++;
VesselProto.SendVessel(client, vesselID, vesselData);
}
else
{
cachedVesselCount++;
}
}
}
DarkLog.Debug("Sending " + client.playerName + " " + sendVesselCount + " vessels, cached: " + cachedVesselCount + "...");
SendVesselsComplete(client);
}
}
/// <summary>
/// Represents low-level networking call that can be used to transmit an event to the browser.
/// </summary>
/// <param name="client">The client to transmit the event to.</param>
/// <param name="propertyName">The name of the event to transmit.</param>
/// <param name="type">The type of the event to transmit.</param>
/// <param name="eventValue">The value of the event to transmit.</param>
internal static void SendEvent(ClientObject client, AppEventType type, BoxedValue target, string eventName, BoxedValue eventValue)
{
try
{
// Check if the target is an object and retrieve the id.
var oid = 0;
if (target.IsObject && target.Object is BaseObject)
oid = ((BaseObject)target.Object).Oid;
// Get the client
var channel = client.Target;
// Convert to a string
var stringValue = TypeConverter.ToNullableString(
Native.Serialize(client.Env, eventValue, true)
);
// Dispatch the inform
channel.TransmitEvent(type, oid, eventName, stringValue);
}
catch (Exception ex)
{
// Log the exception
Service.Logger.Log(ex);
}
}
public static void SendAllPlayerColors(ClientObject client)
{
Dictionary<string,float[]> sendColors = new Dictionary<string, float[]>();
foreach (ClientObject otherClient in ClientHandler.GetClients())
{
if (otherClient.authenticated && otherClient.playerColor != null)
{
if (otherClient != client)
{
sendColors[otherClient.playerName] = otherClient.playerColor;
}
}
}
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.PLAYER_COLOR;
using (MessageWriter mw = new MessageWriter())
{
mw.Write<int>((int)PlayerColorMessageType.LIST);
mw.Write<int>(sendColors.Count);
foreach (KeyValuePair<string, float[]> kvp in sendColors)
{
mw.Write<string>(kvp.Key);
mw.Write<float[]>(kvp.Value);
}
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
private static void ClearObjectData(ClientObject clientObject)
{
PropertyInfo info_ClientObject = typeof(ClientObject).GetProperty("ObjectData", BindingFlags.NonPublic | BindingFlags.Instance);
var objectData = (ClientObjectData)info_ClientObject.GetValue(clientObject, new object[0]);
objectData.MethodReturnObjects.Clear();
}
public static void SendScenarioModules(ClientObject client)
{
int numberOfScenarioModules = Directory.GetFiles(Path.Combine(Server.universeDirectory, "Scenarios", client.playerName)).Length;
int currentScenarioModule = 0;
string[] scenarioNames = new string[numberOfScenarioModules];
byte[][] scenarioDataArray = new byte[numberOfScenarioModules][];
foreach (string file in Directory.GetFiles(Path.Combine(Server.universeDirectory, "Scenarios", client.playerName)))
{
//Remove the .txt part for the name
scenarioNames[currentScenarioModule] = Path.GetFileNameWithoutExtension(file);
scenarioDataArray[currentScenarioModule] = File.ReadAllBytes(file);
currentScenarioModule++;
}
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.SCENARIO_DATA;
using (MessageWriter mw = new MessageWriter())
{
mw.Write<string[]>(scenarioNames);
foreach (byte[] scenarioData in scenarioDataArray)
{
if (client.compressionEnabled)
{
mw.Write<byte[]>(Compression.CompressIfNeeded(scenarioData));
}
else
{
mw.Write<byte[]>(Compression.AddCompressionHeader(scenarioData, false));
}
}
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
public static void HandlePlayerColor(ClientObject client, byte[] messageData)
{
using (MessageReader mr = new MessageReader(messageData))
{
PlayerColorMessageType messageType = (PlayerColorMessageType)mr.Read<int>();
switch (messageType)
{
case PlayerColorMessageType.SET:
{
string playerName = mr.Read<string>();
if (playerName != client.playerName)
{
DarkLog.Debug(client.playerName + " tried to send a color update for " + playerName + ", kicking.");
Messages.ConnectionEnd.SendConnectionEnd(client, "Kicked for sending a color update for another player");
return;
}
client.playerColor = mr.Read<float[]>();
//Relay the message
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.PLAYER_COLOR;
newMessage.data = messageData;
ClientHandler.SendToAll(client, newMessage, true);
}
break;
}
}
}
public static void HandleWarpControl(ClientObject client, byte[] messageData)
{
using (MessageReader mr = new MessageReader(messageData))
{
WarpMessageType warpType = (WarpMessageType)mr.Read<int>();
switch (warpType)
{
case WarpMessageType.REQUEST_CONTROLLER:
{
HandleRequestController(client);
}
break;
case WarpMessageType.RELEASE_CONTROLLER:
{
HandleReleaseController(client);
}
break;
case WarpMessageType.REPLY_VOTE:
{
bool voteReply = mr.Read<bool>();
HandleReplyVote(client, voteReply);
}
break;
case WarpMessageType.NEW_SUBSPACE:
{
long serverTime = mr.Read<long>();
double planetTime = mr.Read<double>();
float subspaceRate = mr.Read<float>();
HandleNewSubspace(client, serverTime, planetTime, subspaceRate);
}
break;
case WarpMessageType.CHANGE_SUBSPACE:
{
int newSubspace = mr.Read<int>();
HandleChangeSubspace(client, newSubspace);
}
break;
case WarpMessageType.REPORT_RATE:
{
float newSubspaceRate = mr.Read<float>();
HandleReportRate(client, newSubspaceRate);
}
break;
case WarpMessageType.CHANGE_WARP:
{
bool physWarp = mr.Read<bool>();
int rateIndex = mr.Read<int>();
long serverClock = mr.Read<long>();
double planetTime = mr.Read<double>();
HandleChangeWarp(client, physWarp, rateIndex, serverClock, planetTime);
}
break;
#if DEBUG
default:
throw new NotImplementedException("Warp type not implemented");
#endif
}
}
}
private static void SendKerbalsComplete(ClientObject client)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.KERBAL_COMPLETE;
ClientHandler.SendToClient(client, newMessage, false);
//Send vessel list needed for sync to the client
VesselRequest.SendVesselList(client);
}
public static void HandleVesselUpdate(ClientObject client, byte[] messageData)
{
//We only relay this message.
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.VESSEL_UPDATE;
newMessage.data = messageData;
ClientHandler.SendToAll(client, newMessage, false);
}
/// <summary>
/// Loads values within a specified SharePoint object from the server.
/// </summary>
/// <param name="context">The Client Rutime Context object representing the client connection with the server.</param>
/// <param name="obj">The object to populate the values of.</param>
public static void Load(ClientRuntimeContext context, ClientObject obj)
{
if (context != null && obj != null)
{
context.Load(obj);
context.ExecuteQuery();
}
}
public static void HandleConnectionEnd(ClientObject client, byte[] messageData)
{
string reason = "Unknown";
using (MessageReader mr = new MessageReader(messageData))
{
reason = mr.Read<string>();
}
DarkLog.Debug(client.playerName + " sent connection end message, reason: " + reason);
ClientHandler.DisconnectClient(client);
}
public static void SendConnectionEnd(ClientObject client, string reason)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.CONNECTION_END;
using (MessageWriter mw = new MessageWriter())
{
mw.Write<string>(reason);
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
private Expression<Func<ClientObject, Object>> GetClientObjectExpression(ClientObject clientObject, string property)
{
var memberExpression = Expression.PropertyOrField(Expression.Constant(clientObject), property);
var memberName = memberExpression.Member.Name;
var parameter = Expression.Parameter(typeof(ClientObject), "i");
var cast = Expression.Convert(parameter, memberExpression.Member.ReflectedType);
var body = Expression.Property(cast, memberName);
var exp = Expression.Lambda<Func<ClientObject, Object>>(Expression.Convert(body, typeof(object)), parameter);
return exp;
}
public static void SendConsoleMessageToClient(ClientObject client, string message)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.CHAT_MESSAGE;
using (MessageWriter mw = new MessageWriter())
{
mw.Write<int>((int)ChatMessageType.CONSOLE_MESSAGE);
mw.Write<string>(message);
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, false);
}
public static void SendAllAdmins(ClientObject client)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.ADMIN_SYSTEM;
using (MessageWriter mw = new MessageWriter())
{
mw.Write((int)AdminMessageType.LIST);
mw.Write<string[]>(DarkMultiPlayerServer.AdminSystem.fetch.GetAdmins());
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
private static void SendKerbal(ClientObject client, string kerbalName, byte[] kerbalData)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.KERBAL_REPLY;
using (MessageWriter mw = new MessageWriter())
{
//Send the vessel with a send time of 0 so it instantly loads on the client.
mw.Write<double>(0);
mw.Write<string>(kerbalName);
mw.Write<byte[]>(kerbalData);
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, false);
}
public static void SendChatMessageToClient(ClientObject client, string messageText)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.CHAT_MESSAGE;
using (MessageWriter mw = new MessageWriter())
{
mw.Write<int>((int)ChatMessageType.PRIVATE_MESSAGE);
mw.Write<string>(Settings.settingsStore.consoleIdentifier);
mw.Write<string>(client.playerName);
mw.Write(messageText);
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
public static void SendHandshakeChallange(ClientObject client)
{
client.challange = new byte[1024];
Random rand = new Random();
rand.NextBytes(client.challange);
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.HANDSHAKE_CHALLANGE;
using (MessageWriter mw = new MessageWriter())
{
mw.Write<byte[]>(client.challange);
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
public static void HandleModDataMessage(ClientObject client, byte[] messageData)
{
using (MessageReader mr = new MessageReader(messageData))
{
string modName = mr.Read<string>();
bool relay = mr.Read<bool>();
bool highPriority = mr.Read<bool>();
byte[] modData = mr.Read<byte[]>();
if (relay)
{
DMPModInterface.SendDMPModMessageToAll(client, modName, modData, highPriority);
}
DMPModInterface.OnModMessageReceived(client, modName, modData);
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (Request[ParameterNames.Request.ClientId] != null)
{
ClientObject client = new ClientObject();
client.ClientGUID.Value = Request[ParameterNames.Request.ClientId];
client.Load();
if(client.IsLoaded)
{
HttpCookie cookie = new HttpCookie(ParameterNames.Cookie.ClientId, Request[ParameterNames.Request.ClientId]);
cookie.Expires = DateTime.Now.AddYears(10);
Response.SetCookie(cookie);
}
}
}
public static void HandleScenarioModuleData(ClientObject client, byte[] messageData)
{
using (MessageReader mr = new MessageReader(messageData))
{
//Don't care about subspace / send time.
string[] scenarioName = mr.Read<string[]>();
DarkLog.Debug("Saving " + scenarioName.Length + " scenario modules from " + client.playerName);
for (int i = 0; i < scenarioName.Length; i++)
{
byte[] scenarioData = Compression.DecompressIfNeeded(mr.Read<byte[]>());
File.WriteAllBytes(Path.Combine(Server.universeDirectory, "Scenarios", client.playerName, scenarioName[i] + ".txt"), scenarioData);
}
}
}
private static void SendMotdReply(ClientObject client)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.MOTD_REPLY;
string newMotd = Settings.settingsStore.serverMotd;
newMotd = newMotd.Replace("%name%", client.playerName);
newMotd = newMotd.Replace(@"\n", Environment.NewLine);
using (MessageWriter mw = new MessageWriter())
{
mw.Write<string>(newMotd);
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
private static bool AddJsLinkImplementation(ClientObject clientObject, string key, IEnumerable<string> scriptLinks, int sequence)
{
var ret = false;
if (clientObject is Web || clientObject is Site)
{
var scriptLinksEnumerable = scriptLinks as string[] ?? scriptLinks.ToArray();
if (!scriptLinksEnumerable.Any())
{
throw new ArgumentException("Parameter scriptLinks can't be empty");
}
var scripts = new StringBuilder(@" var headID = document.getElementsByTagName('head')[0];
var scripts = document.getElementsByTagName('script');
var scriptsSrc = [];
for(var i = 0; i < scripts.length; i++) {
if(scripts[i].type === 'text/javascript'){
scriptsSrc.push(scripts[i].src);
}
}
");
foreach (var link in scriptLinksEnumerable)
{
if (!string.IsNullOrEmpty(link))
{
scripts.Append(@"
if (scriptsSrc.indexOf('{1}') === -1) {
var newScript = document.createElement('script');
newScript.id = '{0}';
newScript.type = 'text/javascript';
newScript.src = '{1}';
headID.appendChild(newScript);
scriptsSrc.push('{1}');
}".Replace("{0}", key).Replace("{1}", link));
}
}
ret = AddJsBlockImplementation(clientObject, key, scripts.ToString(), sequence);
}
else
{
throw new ArgumentException("Only Site or Web supported as clientObject");
}
return ret;
}
public static void SendVesselList(ClientObject client)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.VESSEL_LIST;
string[] vesselFiles = Directory.GetFiles(Path.Combine(Server.universeDirectory, "Vessels"));
string[] vesselObjects = new string[vesselFiles.Length];
for (int i = 0; i < vesselFiles.Length; i++)
{
vesselObjects[i] = Common.CalculateSHA256Hash(vesselFiles[i]);
}
using (MessageWriter mw = new MessageWriter())
{
mw.Write<string[]>(vesselObjects);
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, false);
}
public static void SendAllLocks(ClientObject client)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.LOCK_SYSTEM;
//Send the dictionary as 2 string[]'s.
Dictionary<string,string> lockList = DarkMultiPlayerServer.LockSystem.fetch.GetLockList();
List<string> lockKeys = new List<string>(lockList.Keys);
List<string> lockValues = new List<string>(lockList.Values);
using (MessageWriter mw = new MessageWriter())
{
mw.Write((int)LockMessageType.LIST);
mw.Write<string[]>(lockKeys.ToArray());
mw.Write<string[]>(lockValues.ToArray());
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
static void Main(string[] args)
{
try
{
Server s = new Server();
listener = new TcpListener(IPAddress.Parse("127.0.0.1"), port);
listener.Start();
Console.WriteLine("Ожидание подключений...");
while (true)
{
Socket client = listener.AcceptSocket();
ClientObject clientObject = new ClientObject(client, s);
// создаем новый поток для обслуживания нового клиента
Thread clientThread = new Thread(new ThreadStart(clientObject.Process));
clientThread.Start();
}
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.DarkRed;
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Returns the Packet of data sent by a TcpClient
/// </summary>
/// <param name="serverData">Returns the ServerData object if the packet was a ServerDataPacket</param>
/// <returns>The Packet sent</returns>
IDataPacket ListenForPackets(ref ClientObject cO)
{
var client = cO.Data.TcpClient;
byte[] bytes = new byte[Packet.MAX_BYTE_LENGTH];
IDataPacket packet = null;
if (client.GetStream().Read(bytes, 0, bytes.Length) != 0)
{
packet = Packet.ToPacket(bytes);
}
if (packet is ServerDataPacket)
{
var sPacket = (ServerDataPacket)packet;
cO.Data = new Data(ConnectedClients.Count == 0 ? 0 : ConnectedClients.Last().Data.ID + 1)
{
TcpClient = client, FirstConnect = sPacket.FirstConnect, IPv4 = sPacket.IPv4, Name = sPacket.Name, Port = sPacket.Port
};
Logger.Instance.Log($"Server @ {cO.Data.IPv4} added to collection");
}
return(packet);
}
public static void SendAllSubspaces(ClientObject client)
{
//Send all the locks.
foreach (KeyValuePair <int, Subspace> subspace in subspaces)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.WARP_CONTROL;
using (MessageWriter mw = new MessageWriter())
{
mw.Write <int>((int)WarpMessageType.NEW_SUBSPACE);
mw.Write <int>(subspace.Key);
mw.Write <long>(subspace.Value.serverClock);
mw.Write <double>(subspace.Value.planetTime);
mw.Write <float>(subspace.Value.subspaceSpeed);
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
//Tell the player "when" everyone is.
foreach (ClientObject otherClient in ClientHandler.GetClients())
{
if (otherClient.authenticated && (otherClient.playerName != client.playerName))
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.WARP_CONTROL;
using (MessageWriter mw = new MessageWriter())
{
mw.Write <int>((int)WarpMessageType.CHANGE_SUBSPACE);
mw.Write <string>(otherClient.playerName);
mw.Write <int>(otherClient.subspace);
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToClient(client, newMessage, true);
}
}
}
public static void HandleKerbalsRequest(ClientObject client)
{
//The time sensitive SYNC_TIME is over by this point.
using (MessageWriter mw = new MessageWriter())
{
mw.Write <string>(client.playerName);
ServerMessage joinMessage = new ServerMessage();
joinMessage.type = ServerMessageType.PLAYER_JOIN;
joinMessage.data = mw.GetMessageBytes();
ClientHandler.SendToAll(client, joinMessage, true);
}
Messages.ServerSettings.SendServerSettings(client);
Messages.WarpControl.SendSetSubspace(client);
Messages.WarpControl.SendAllSubspaces(client);
Messages.PlayerColor.SendAllPlayerColors(client);
Messages.PlayerStatus.SendAllPlayerStatus(client);
Messages.ScenarioData.SendScenarioModules(client);
Messages.WarpControl.SendAllReportedSkewRates(client);
Messages.CraftLibrary.SendCraftList(client);
Messages.Chat.SendPlayerChatChannels(client);
Messages.LockSystem.SendAllLocks(client);
Messages.AdminSystem.SendAllAdmins(client);
//Send kerbals
lock (Server.universeSizeLock)
{
string[] kerbalFiles = Directory.GetFiles(Path.Combine(Server.universeDirectory, "Kerbals"));
foreach (string kerbalFile in kerbalFiles)
{
string kerbalName = Path.GetFileNameWithoutExtension(kerbalFile);
byte[] kerbalData = File.ReadAllBytes(kerbalFile);
SendKerbal(client, kerbalName, kerbalData);
}
DarkLog.Debug("Sending " + client.playerName + " " + kerbalFiles.Length + " kerbals...");
}
SendKerbalsComplete(client);
}
private static void HandleChangeWarp(ClientObject client, bool physWarp, int rateIndex, long serverClock, double planetTime)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.WARP_CONTROL;
using (MessageWriter mw = new MessageWriter())
{
mw.Write <int>((int)WarpMessageType.CHANGE_WARP);
mw.Write <string>(client.playerName);
mw.Write <bool>(physWarp);
mw.Write <int>(rateIndex);
mw.Write <long>(serverClock);
mw.Write <double>(planetTime);
newMessage.data = mw.GetMessageBytes();
}
if (Settings.settingsStore.warpMode == WarpMode.MCW_LOWEST)
{
PlayerWarpRate clientWarpRate = null;
if (!warpList.ContainsKey(client.playerName))
{
clientWarpRate = new PlayerWarpRate();
warpList.Add(client.playerName, clientWarpRate);
}
else
{
clientWarpRate = warpList[client.playerName];
}
clientWarpRate.isPhysWarp = physWarp;
clientWarpRate.rateIndex = rateIndex;
clientWarpRate.serverClock = serverClock;
clientWarpRate.planetTime = planetTime;
HandleLowestRateChange(client);
}
ClientHandler.SendToAll(client, newMessage, true);
}
public AdminGroups(ClientObject cl)
{
InitializeComponent();
client = cl;
AddItemsToComboBox();
}
private static bool AddJsLinkImplementation(ClientObject clientObject, string key, IEnumerable <string> scriptLinks, int sequence)
{
bool ret;
if (clientObject is Web || clientObject is Site)
{
var scriptLinksEnumerable = scriptLinks as string[] ?? scriptLinks.ToArray();
if (!scriptLinksEnumerable.Any())
{
throw new ArgumentException(nameof(scriptLinks));
}
if (scriptLinksEnumerable.Length == 1)
{
var scriptSrc = scriptLinksEnumerable[0];
if (!scriptSrc.StartsWith("http", StringComparison.InvariantCultureIgnoreCase))
{
var serverUri = new Uri(clientObject.Context.Url);
if (scriptSrc.StartsWith("/"))
{
scriptSrc = $"{serverUri.Scheme}://{serverUri.Authority}{scriptSrc}";
}
else
{
var serverRelativeUrl = string.Empty;
if (clientObject is Web)
{
serverRelativeUrl = ((Web)clientObject).EnsureProperty(w => w.ServerRelativeUrl);
}
else
{
serverRelativeUrl = ((Site)clientObject).RootWeb.EnsureProperty(w => w.ServerRelativeUrl);
}
scriptSrc = $"{serverUri.Scheme}://{serverUri.Authority}{serverRelativeUrl}/{scriptSrc}";
}
}
var customAction = new CustomActionEntity
{
Name = key,
ScriptSrc = scriptSrc,
Location = SCRIPT_LOCATION,
Sequence = sequence
};
if (clientObject is Web)
{
ret = ((Web)clientObject).AddCustomAction(customAction);
}
else
{
ret = ((Site)clientObject).AddCustomAction(customAction);
}
}
else
{
var scripts = new StringBuilder(@" var headID = document.getElementsByTagName('head')[0];
var scripts = document.getElementsByTagName('script');
var scriptsSrc = [];
for(var i = 0; i < scripts.length; i++) {
if(scripts[i].type === 'text/javascript'){
scriptsSrc.push(scripts[i].src);
}
}
");
foreach (var link in scriptLinksEnumerable)
{
if (!string.IsNullOrEmpty(link))
{
scripts.Append(@"
if (scriptsSrc.indexOf('{1}') === -1) {
var newScript = document.createElement('script');
newScript.id = '{0}';
newScript.type = 'text/javascript';
newScript.src = '{1}';
headID.appendChild(newScript);
scriptsSrc.push('{1}');
}".Replace("{0}", key).Replace("{1}", link));
}
}
ret = AddJsBlockImplementation(clientObject, key, scripts.ToString(), sequence);
}
}
else
{
throw new ArgumentException("Only Site or Web supported as clientObject");
}
return(ret);
}
public StudentPassTest(ClientObject cl, int testId, Window _mw, Frame _mn, StudentTests previousPage)
{
InitializeComponent();
client = cl;
mw = _mw;
main = _mn;
_previousPage = previousPage;
_userAnswers = new List <DTOAnswer>();
dtoTest = client.GetTest(testId);
questions = client.GetQuestions(testId);
questionType = client.GetQuestionTypes();
_testSession = new DTOTestSession()
{
Status = "Continues", StartTime = DateTime.Now, TestId = testId, StudentId = cl.GetClientId()
};
Thread.Sleep(500);
_testSession.TestSessionId = client.AddTestSession(_testSession);
//IGNORE comments.
//1. add grid with one column
//2. add two containers vertically
//3. add question text to uppersection
//4. add container horisontal
//5. add two containers in both container from step 4.
//6. paiste horisontal container
//7. add answer option with certain type.
var mainStack = new StackPanel();
mainStack.HorizontalAlignment = HorizontalAlignment.Left;
var listOfStackPanels = new List <StackPanel>();
var testNameStacPanel = new StackPanel();
var testName = new TextBlock();
testName.FontSize = 15;
testName.FontFamily = new FontFamily("Century Gothic");
testName.Text = dtoTest.TestName;
testNameStacPanel.Children.Add(testName);
listOfStackPanels.Add(testNameStacPanel);
int i = 0;
foreach (var question in questions)
{
// Answers logic
answerDictionary.Add(i, "");
//
//questionLogic
var stackQuestion = new StackPanel();
stackQuestion.Margin = new Thickness()
{
Bottom = 20, Left = 10, Right = 0, Top = 0
};
var stackQuestionText = new StackPanel();
var stackOptions = new StackPanel();
var textElement = new TextBlock();
textElement.Text = (i + 1).ToString() + ". " + question.QuestionText;
stackQuestionText.Children.Add(textElement);
var options = question.AnswerOption?.Split(';');
if (options != null && options.Length != 0)
{
if (question.QuestionTypeId == 1)
{
for (int k = 0; k < options.Length; k++)
{
RadioButton rb = new RadioButton()
{
Content = " " + options[k], IsChecked = i != 0
};
rb.Checked += (sender, args) =>
{
answerDictionary[(int)((System.Windows.FrameworkElement)sender).Tag] = ((System.Windows.Controls.ContentControl)args.Source).Content.ToString();
};
rb.Unchecked += (sender, args) => { /* Do nothing */ };
rb.Tag = i;
rb.IsChecked = false;
mainStackPanel.HorizontalAlignment = HorizontalAlignment;
stackOptions.Children.Add(rb);
}
}
else
{
if (question.QuestionTypeId == 2)
{
for (int k = 0; k < options.Length; k++)
{
CheckBox rb = new CheckBox()
{
Content = " " + options[k], IsChecked = i != 0
};
rb.Checked += (sender, args) =>
{
if (string.IsNullOrEmpty(answerDictionary[(int)((System.Windows.FrameworkElement)sender).Tag]))
{
answerDictionary[(int)((System.Windows.FrameworkElement)sender).Tag] = ((System.Windows.Controls.ContentControl)args.Source).Content.ToString();
}
else
{
answerDictionary[(int)((System.Windows.FrameworkElement)sender).Tag] += " ; " + ((System.Windows.Controls.ContentControl)args.Source).Content.ToString();
}
};
rb.Unchecked += (sender, args) => {
/* Do stuff */
var multipleAnswers = answerDictionary[(int)((System.Windows.FrameworkElement)sender).Tag];
string elementToRemove = ((System.Windows.Controls.ContentControl)args.Source).Content.ToString();
string[] separatingStrings = { " ; " };
var newAnswers = multipleAnswers.Split(separatingStrings, System.StringSplitOptions.RemoveEmptyEntries).Where(val => val != elementToRemove).ToArray();
answerDictionary[(int)((System.Windows.FrameworkElement)sender).Tag] = string.Join(" ; ", newAnswers);
};
rb.Tag = i;
mainStackPanel.HorizontalAlignment = HorizontalAlignment;
rb.IsChecked = false;
stackOptions.Children.Add(rb);
}
}
else
{
if (question.QuestionTypeId == 3)
{
for (int k = 0; k < 2; k++)
{
string[] optionsTrueFalse = { "правда", "неправда" };
RadioButton rb = new RadioButton()
{
Content = " " + optionsTrueFalse[k], IsChecked = i != 0
};
rb.Checked += (sender, args) =>
{
answerDictionary[(int)((System.Windows.FrameworkElement)sender).Tag] = ((System.Windows.Controls.ContentControl)args.Source).Content.ToString();
};
rb.Unchecked += (sender, args) => { /* Do nothing */ };
rb.Tag = i;
rb.IsChecked = false;
mainStackPanel.HorizontalAlignment = HorizontalAlignment;
stackOptions.Children.Add(rb);
}
}
else
{
throw new NotImplementedException();
}
}
}
}
else
{
var textElementBox = new TextBlock();
textElementBox.Text = "Варіанти відповідей відсутні. ((";
stackOptions.Children.Add(textElementBox);
stackOptions.Tag = i;
}
stackQuestion.Children.Add(stackQuestionText);
stackQuestion.Children.Add(stackOptions);
listOfStackPanels.Add(stackQuestion);
++i;
}
// adding questions to stack.
foreach (var listOfStackPanel in listOfStackPanels)
{
mainStack.Children.Add(listOfStackPanel);
}
mainStackPanel.Children.Add(mainStack);
//add button SUBMIT
Button buttonSubmit = new Button()
{
Content = "Завершити"
};
//< Button Content = "Button" HorizontalAlignment = "Left" Margin = "20,10,0,0" VerticalAlignment = "Top" Width = "75" Click = "Button_Click" />
buttonSubmit.HorizontalAlignment = HorizontalAlignment.Left;
buttonSubmit.Margin = new Thickness()
{
Bottom = 20, Left = 10, Right = 0, Top = 0
};
buttonSubmit.VerticalAlignment = VerticalAlignment.Top;
buttonSubmit.Width = 75;
buttonSubmit.Click += new RoutedEventHandler(Button_Click);
mainStackPanel.Children.Add(buttonSubmit);
}
//Validate helpers
private bool IsPropertyAvailable(ClientObject clientObject, string propertyName)
{
return(clientObject.IsObjectPropertyInstantiated(propertyName) || clientObject.IsPropertyAvailable(propertyName));
}
public static void createNewChat(ClientObject client, string usernameFrom, string usernameTo)
{
MySQLUtils.createNewChatServer(client, usernameFrom, usernameTo);
}
public override void OnClientDisconnect(ClientObject client)
{
connectedPlayers.Remove(client.playerName);
ReportData();
}
public override void OnClientAuthenticated(ClientObject client)
{
connectedPlayers.Add(client.playerName);
ReportData();
}
public void CheckClientEmail()
{
ClientObject client = GetUnparsedData(SampleParsedData).Clients.First();
Assert.AreEqual("*****@*****.**", client.Email);
}
private static bool AddCustomActionImplementation(ClientObject clientObject, CustomActionEntity customAction)
{
UserCustomAction targetAction = null;
UserCustomActionCollection existingActions = null;
if (clientObject is Web)
{
var web = (Web)clientObject;
existingActions = web.UserCustomActions;
web.Context.Load(existingActions);
web.Context.ExecuteQueryRetry();
targetAction = web.UserCustomActions.FirstOrDefault(uca => uca.Name == customAction.Name);
}
else
{
var site = (Site)clientObject;
existingActions = site.UserCustomActions;
site.Context.Load(existingActions);
site.Context.ExecuteQueryRetry();
targetAction = site.UserCustomActions.FirstOrDefault(uca => uca.Name == customAction.Name);
}
if (targetAction == null)
{
// If we're removing the custom action then we need to leave when not found...else we're creating the custom action
if (customAction.Remove)
{
return(true);
}
else
{
targetAction = existingActions.Add();
}
}
else if (customAction.Remove)
{
targetAction.DeleteObject();
clientObject.Context.ExecuteQueryRetry();
return(true);
}
targetAction.Name = customAction.Name;
targetAction.Description = customAction.Description;
targetAction.Location = customAction.Location;
if (customAction.Location == JavaScriptExtensions.SCRIPT_LOCATION)
{
targetAction.ScriptBlock = customAction.ScriptBlock;
targetAction.ScriptSrc = customAction.ScriptSrc;
}
else
{
targetAction.Sequence = customAction.Sequence;
targetAction.Url = customAction.Url;
targetAction.Group = customAction.Group;
targetAction.Title = customAction.Title;
targetAction.ImageUrl = customAction.ImageUrl;
if (customAction.RegistrationId != null)
{
targetAction.RegistrationId = customAction.RegistrationId;
}
if (customAction.CommandUIExtension != null)
{
targetAction.CommandUIExtension = customAction.CommandUIExtension;
}
if (customAction.Rights != null)
{
targetAction.Rights = customAction.Rights;
}
if (customAction.RegistrationType.HasValue)
{
targetAction.RegistrationType = customAction.RegistrationType.Value;
}
}
targetAction.Update();
if (clientObject is Web)
{
var web = (Web)clientObject;
web.Context.Load(web, w => w.UserCustomActions);
web.Context.ExecuteQueryRetry();
}
else
{
var site = (Site)clientObject;
site.Context.Load(site, s => s.UserCustomActions);
site.Context.ExecuteQueryRetry();
}
return(true);
}
public static void HandleWarpControl(ClientObject client, byte[] messageData)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.WARP_CONTROL;
newMessage.data = messageData;
using (MessageReader mr = new MessageReader(messageData))
{
WarpMessageType warpType = (WarpMessageType)mr.Read <int>();
string fromPlayer = mr.Read <string>();
if (fromPlayer == client.playerName)
{
if (warpType == WarpMessageType.NEW_SUBSPACE)
{
int newSubspaceID = mr.Read <int>();
if (subspaces.ContainsKey(newSubspaceID))
{
DarkLog.Debug("Kicked for trying to create an existing subspace");
Messages.ConnectionEnd.SendConnectionEnd(client, "Kicked for trying to create an existing subspace");
return;
}
else
{
Subspace newSubspace = new Subspace();
newSubspace.serverClock = mr.Read <long>();
newSubspace.planetTime = mr.Read <double>();
newSubspace.subspaceSpeed = mr.Read <float>();
subspaces.Add(newSubspaceID, newSubspace);
client.subspace = newSubspaceID;
SaveLatestSubspace();
}
}
if (warpType == WarpMessageType.CHANGE_SUBSPACE)
{
client.subspace = mr.Read <int>();
}
if (warpType == WarpMessageType.REPORT_RATE)
{
int reportedSubspace = mr.Read <int>();
if (client.subspace != reportedSubspace)
{
DarkLog.Debug("Warning, setting client " + client.playerName + " to subspace " + client.subspace);
client.subspace = reportedSubspace;
}
float newSubspaceRate = mr.Read <float>();
client.subspaceRate = newSubspaceRate;
foreach (ClientObject otherClient in ClientHandler.GetClients())
{
if (otherClient.authenticated && otherClient.subspace == reportedSubspace)
{
if (newSubspaceRate > otherClient.subspaceRate)
{
newSubspaceRate = otherClient.subspaceRate;
}
}
}
if (newSubspaceRate < 0.3f)
{
newSubspaceRate = 0.3f;
}
if (newSubspaceRate > 1f)
{
newSubspaceRate = 1f;
}
//Relock the subspace if the rate is more than 3% out of the average
if (Math.Abs(subspaces[reportedSubspace].subspaceSpeed - newSubspaceRate) > 0.03f)
{
UpdateSubspace(reportedSubspace);
subspaces[reportedSubspace].subspaceSpeed = newSubspaceRate;
ServerMessage relockMessage = new ServerMessage();
relockMessage.type = ServerMessageType.WARP_CONTROL;
using (MessageWriter mw = new MessageWriter())
{
mw.Write <int>((int)WarpMessageType.RELOCK_SUBSPACE);
mw.Write <string>(Settings.settingsStore.consoleIdentifier);
mw.Write <int>(reportedSubspace);
mw.Write <long>(subspaces[reportedSubspace].serverClock);
mw.Write <double>(subspaces[reportedSubspace].planetTime);
mw.Write <float>(subspaces[reportedSubspace].subspaceSpeed);
relockMessage.data = mw.GetMessageBytes();
}
SaveLatestSubspace();
//DarkLog.Debug("Subspace " + client.subspace + " locked to " + newSubspaceRate + "x speed.");
ClientHandler.SendToClient(client, relockMessage, true);
ClientHandler.SendToAll(client, relockMessage, true);
}
}
}
else
{
DarkLog.Debug(client.playerName + " tried to send an update for " + fromPlayer + ", kicking.");
Messages.ConnectionEnd.SendConnectionEnd(client, "Kicked for sending an update for another player");
return;
}
}
ClientHandler.SendToAll(client, newMessage, true);
}
public static void loadChatsHandler(ClientObject client)
{
MySQLUtils.getChats(client);
}
private static ClientObjectData GetClientObjectData(ClientObject clientObject)
{
return((ClientObjectData)CsomHelpers.info_ClientObject_ObjectData.GetValue(clientObject, new object[0]));
}
/// <summary>
/// Certain CSOM methods cache their return values for the lifetime of the ClientContext.
/// (In the server OM, these methods are marked with ClientCallableMethod.CacheReturnValue=true.)
/// This can produce incorrect results if the value was changed e.g. by the same session
/// that is now trying to read the new value. FlushCachedProperties() can be called in
/// this situation to flush the internal cache. It should be called after ExecuteQuery()
/// and before the next query expression is loaded.
/// </summary>
public static void FlushCachedProperties(ClientObject clientObject)
{
ClientObjectData objectData = CsomHelpers.GetClientObjectData(clientObject);
objectData.MethodReturnObjects.Clear();
}
public void AddConnection(ClientObject obj)
{
clients.Add(obj);
}
public static void HandleScreenshotLibrary(ClientObject client, byte[] messageData)
{
string screenshotDirectory = Path.Combine(Server.universeDirectory, "Screenshots");
if (Settings.settingsStore.screenshotDirectory != "")
{
if (Directory.Exists(Settings.settingsStore.screenshotDirectory))
{
screenshotDirectory = Settings.settingsStore.screenshotDirectory;
}
}
if (!Directory.Exists(screenshotDirectory))
{
Directory.CreateDirectory(screenshotDirectory);
}
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.SCREENSHOT_LIBRARY;
using (MessageReader mr = new MessageReader(messageData))
{
ScreenshotMessageType messageType = (ScreenshotMessageType)mr.Read <int>();
string fromPlayer = mr.Read <string>();
switch (messageType)
{
case ScreenshotMessageType.SCREENSHOT:
{
if (Settings.settingsStore.screenshotsPerPlayer > -1)
{
string playerScreenshotDirectory = Path.Combine(screenshotDirectory, fromPlayer);
if (!Directory.Exists(playerScreenshotDirectory))
{
Directory.CreateDirectory(playerScreenshotDirectory);
}
string screenshotFile = Path.Combine(playerScreenshotDirectory, DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss") + ".png");
DarkLog.Debug("Saving screenshot from " + fromPlayer);
byte[] screenshotData = mr.Read <byte[]>();
File.WriteAllBytes(screenshotFile, screenshotData);
if (Settings.settingsStore.screenshotsPerPlayer != 0)
{
while (Directory.GetFiles(playerScreenshotDirectory).Length > Settings.settingsStore.screenshotsPerPlayer)
{
string[] currentFiles = Directory.GetFiles(playerScreenshotDirectory);
string deleteFile = currentFiles[0];
//Find oldest file
foreach (string testFile in currentFiles)
{
if (File.GetCreationTime(testFile) < File.GetCreationTime(deleteFile))
{
deleteFile = testFile;
}
}
File.Delete(deleteFile);
DarkLog.Debug("Removing old screenshot " + Path.GetFileName(deleteFile));
}
}
//Notify players that aren't watching that there's a new screenshot availabe. This only works if there's a file available on the server.
//The server does not keep the screenshots in memory.
ServerMessage notifyMessage = new ServerMessage();
notifyMessage.type = ServerMessageType.SCREENSHOT_LIBRARY;
using (MessageWriter mw = new MessageWriter())
{
mw.Write <int>((int)ScreenshotMessageType.NOTIFY);
mw.Write(fromPlayer);
notifyMessage.data = mw.GetMessageBytes();
ClientHandler.SendToAll(client, notifyMessage, false);
}
}
if (!playerUploadedScreenshotIndex.ContainsKey(fromPlayer))
{
playerUploadedScreenshotIndex.Add(fromPlayer, 0);
}
else
{
playerUploadedScreenshotIndex[fromPlayer]++;
}
if (!playerDownloadedScreenshotIndex.ContainsKey(fromPlayer))
{
playerDownloadedScreenshotIndex.Add(fromPlayer, new Dictionary <string, int>());
}
if (!playerDownloadedScreenshotIndex[fromPlayer].ContainsKey(fromPlayer))
{
playerDownloadedScreenshotIndex[fromPlayer].Add(fromPlayer, playerUploadedScreenshotIndex[fromPlayer]);
}
else
{
playerDownloadedScreenshotIndex[fromPlayer][fromPlayer] = playerUploadedScreenshotIndex[fromPlayer];
}
newMessage.data = messageData;
foreach (KeyValuePair <string, string> entry in playerWatchScreenshot)
{
if (entry.Key != fromPlayer)
{
if (entry.Value == fromPlayer && entry.Key != client.playerName)
{
ClientObject toClient = ClientHandler.GetClientByName(entry.Key);
if (toClient != null && toClient != client)
{
if (!playerDownloadedScreenshotIndex.ContainsKey(entry.Key))
{
playerDownloadedScreenshotIndex.Add(entry.Key, new Dictionary <string, int>());
}
if (!playerDownloadedScreenshotIndex[entry.Key].ContainsKey(fromPlayer))
{
playerDownloadedScreenshotIndex[entry.Key].Add(fromPlayer, 0);
}
playerDownloadedScreenshotIndex[entry.Key][fromPlayer] = playerUploadedScreenshotIndex[fromPlayer];
DarkLog.Debug("Sending screenshot from " + fromPlayer + " to " + entry.Key);
using (MessageWriter mw = new MessageWriter())
{
ServerMessage sendStartMessage = new ServerMessage();
sendStartMessage.type = ServerMessageType.SCREENSHOT_LIBRARY;
mw.Write <int>((int)ScreenshotMessageType.SEND_START_NOTIFY);
mw.Write <string>(fromPlayer);
sendStartMessage.data = mw.GetMessageBytes();
ClientHandler.SendToClient(toClient, sendStartMessage, true);
}
ClientHandler.SendToClient(toClient, newMessage, false);
}
}
}
}
}
break;
case ScreenshotMessageType.WATCH:
{
newMessage.data = messageData;
string watchPlayer = mr.Read <string>();
if (watchPlayer == "")
{
if (playerWatchScreenshot.ContainsKey(fromPlayer))
{
DarkLog.Debug(fromPlayer + " is no longer watching screenshots from " + playerWatchScreenshot[fromPlayer]);
playerWatchScreenshot.Remove(fromPlayer);
}
}
else
{
DarkLog.Debug(fromPlayer + " is watching screenshots from " + watchPlayer);
playerWatchScreenshot[fromPlayer] = watchPlayer;
if (!playerDownloadedScreenshotIndex.ContainsKey(fromPlayer))
{
playerDownloadedScreenshotIndex.Add(fromPlayer, new Dictionary <string, int>());
}
string watchPlayerScreenshotDirectory = Path.Combine(screenshotDirectory, watchPlayer);
//Find latest screenshot
string sendFile = null;
if (Directory.Exists(watchPlayerScreenshotDirectory))
{
string[] playerScreenshots = Directory.GetFiles(watchPlayerScreenshotDirectory);
if (playerScreenshots.Length > 0)
{
sendFile = playerScreenshots[0];
foreach (string testFile in playerScreenshots)
{
if (File.GetCreationTime(testFile) > File.GetCreationTime(sendFile))
{
sendFile = testFile;
}
}
if (!playerUploadedScreenshotIndex.ContainsKey(watchPlayer))
{
playerUploadedScreenshotIndex.Add(watchPlayer, 0);
}
}
}
//Send screenshot if needed
if (sendFile != null)
{
bool sendScreenshot = false;
if (!playerDownloadedScreenshotIndex[fromPlayer].ContainsKey(watchPlayer))
{
playerDownloadedScreenshotIndex[fromPlayer].Add(watchPlayer, playerUploadedScreenshotIndex[watchPlayer]);
sendScreenshot = true;
}
else
{
if (playerDownloadedScreenshotIndex[fromPlayer][watchPlayer] != playerUploadedScreenshotIndex[watchPlayer])
{
sendScreenshot = true;
playerDownloadedScreenshotIndex[fromPlayer][watchPlayer] = playerUploadedScreenshotIndex[watchPlayer];
}
}
if (sendScreenshot)
{
ServerMessage sendStartMessage = new ServerMessage();
sendStartMessage.type = ServerMessageType.SCREENSHOT_LIBRARY;
using (MessageWriter mw = new MessageWriter())
{
mw.Write <int>((int)ScreenshotMessageType.SEND_START_NOTIFY);
mw.Write <string>(fromPlayer);
sendStartMessage.data = mw.GetMessageBytes();
}
ServerMessage screenshotMessage = new ServerMessage();
screenshotMessage.type = ServerMessageType.SCREENSHOT_LIBRARY;
using (MessageWriter mw = new MessageWriter())
{
mw.Write <int>((int)ScreenshotMessageType.SCREENSHOT);
mw.Write <string>(watchPlayer);
mw.Write <byte[]>(File.ReadAllBytes(sendFile));
screenshotMessage.data = mw.GetMessageBytes();
}
ClientObject toClient = ClientHandler.GetClientByName(fromPlayer);
if (toClient != null)
{
DarkLog.Debug("Sending saved screenshot from " + watchPlayer + " to " + fromPlayer);
ClientHandler.SendToClient(toClient, sendStartMessage, false);
ClientHandler.SendToClient(toClient, screenshotMessage, false);
}
}
}
}
//Relay the message
ClientHandler.SendToAll(client, newMessage, false);
}
break;
}
}
}
public void CheckClientID()
{
ClientObject client = GetUnparsedData(SampleParsedData).Clients.First();
Assert.AreEqual(1, client.ClientID);
}
public void CheckClientPreferredName()
{
ClientObject client = GetUnparsedData(SampleParsedData).Clients.First();
Assert.AreEqual("Australian Native Landscapes Pty Ltd", client.PreferredName);
}
protected override void HandlePacket(ClientObject client, PacketInStream packet)
{
client.Announce(ServerCreatePacket.response_scene(SceneManager.GetActiveScene().name));
}
public static void HandleMotdRequest(ClientObject client)
{
SendMotdReply(client);
}
private static Expression <Func <ClientObject, object> > GetClientObjectExpression(ClientObject clientObject, string property)
{
var memberExpression = Expression.PropertyOrField(Expression.Constant(clientObject), property);
var memberName = memberExpression.Member.Name;
var parameter = Expression.Parameter(typeof(ClientObject), "i");
var cast = Expression.Convert(parameter, memberExpression.Member.ReflectedType);
var body = Expression.Property(cast, memberName);
var exp = Expression.Lambda <Func <ClientObject, Object> >(Expression.Convert(body, typeof(object)),
parameter);
return(exp);
}
public static void HandleChatMessage(ClientObject client, byte[] messageData)
{
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.CHAT_MESSAGE;
newMessage.data = messageData;
using (MessageReader mr = new MessageReader(messageData))
{
ChatMessageType messageType = (ChatMessageType)mr.Read <int>();
string fromPlayer = mr.Read <string>();
if (fromPlayer != client.playerName)
{
Messages.ConnectionEnd.SendConnectionEnd(client, "Kicked for sending a chat message for another player");
return;
}
switch (messageType)
{
case ChatMessageType.JOIN:
{
string joinChannel = mr.Read <string>();
if (!playerChatChannels.ContainsKey(fromPlayer))
{
playerChatChannels.Add(fromPlayer, new List <string>());
}
if (!playerChatChannels[fromPlayer].Contains(joinChannel))
{
playerChatChannels[fromPlayer].Add(joinChannel);
}
DarkLog.Debug(fromPlayer + " joined channel: " + joinChannel);
}
ClientHandler.SendToAll(client, newMessage, true);
break;
case ChatMessageType.LEAVE:
{
string leaveChannel = mr.Read <string>();
if (playerChatChannels.ContainsKey(fromPlayer))
{
if (playerChatChannels[fromPlayer].Contains(leaveChannel))
{
playerChatChannels[fromPlayer].Remove(leaveChannel);
}
if (playerChatChannels[fromPlayer].Count == 0)
{
playerChatChannels.Remove(fromPlayer);
}
}
DarkLog.Debug(fromPlayer + " left channel: " + leaveChannel);
}
ClientHandler.SendToAll(client, newMessage, true);
break;
case ChatMessageType.CHANNEL_MESSAGE:
{
string channel = mr.Read <string>();
string message = mr.Read <string>();
if (channel != "")
{
foreach (KeyValuePair <string, List <string> > playerEntry in playerChatChannels)
{
if (playerEntry.Value.Contains(channel))
{
ClientObject findClient = ClientHandler.GetClientByName(playerEntry.Key);
if (findClient != null)
{
ClientHandler.SendToClient(findClient, newMessage, true);
}
}
}
DarkLog.ChatMessage(fromPlayer + " -> #" + channel + ": " + message);
}
else
{
ClientHandler.SendToClient(client, newMessage, true);
ClientHandler.SendToAll(client, newMessage, true);
DarkLog.ChatMessage(fromPlayer + " -> #Global: " + message);
}
}
break;
case ChatMessageType.PRIVATE_MESSAGE:
{
string toPlayer = mr.Read <string>();
string message = mr.Read <string>();
if (toPlayer != Settings.settingsStore.consoleIdentifier)
{
ClientObject findClient = ClientHandler.GetClientByName(toPlayer);
if (findClient != null)
{
ClientHandler.SendToClient(client, newMessage, true);
ClientHandler.SendToClient(findClient, newMessage, true);
DarkLog.ChatMessage(fromPlayer + " -> @" + toPlayer + ": " + message);
}
{
DarkLog.ChatMessage(fromPlayer + " -X-> @" + toPlayer + ": " + message);
}
}
else
{
ClientHandler.SendToClient(client, newMessage, true);
DarkLog.ChatMessage(fromPlayer + " -> @" + toPlayer + ": " + message);
}
}
break;
case ChatMessageType.CONSOLE_MESSAGE:
{
string message = mr.Read <string>();
if (client.authenticated && DarkMultiPlayerServer.AdminSystem.fetch.IsAdmin(client.playerName))
{
CommandHandler.HandleServerInput(message);
}
else
{
Messages.ConnectionEnd.SendConnectionEnd(client, "Kicked for sending a console command as a non-admin player.");
}
}
break;
}
}
}
protected virtual void ProcessGenericLocalization(ClientObject obj, Dictionary <string, List <ValueForUICulture> > localizations)
{
var targetProps = localizations.Keys.ToList();
var isSupportedRuntime = ReflectionUtils.HasProperties(obj, targetProps);
if (!isSupportedRuntime)
{
TraceService.Critical((int)LogEventId.ModelProvisionCoreCall,
string.Format("CSOM runtime doesn't have [{0}] methods support. Update CSOM runtime to a new version. Provision is skipped",
string.Join(", ", targetProps.ToArray())));
return;
}
var needsUpdate = false;
foreach (var key in localizations.Keys)
{
var propName = key;
var localization = localizations[key];
if (localization.Any())
{
var userResource = GetPropertyValue(obj, propName);
foreach (var locValue in localization)
{
LocalizationService.ProcessUserResource(obj, userResource, locValue);
}
needsUpdate = true;
}
}
if (needsUpdate)
{
var updateMethod = ReflectionUtils.GetMethod(obj, "Update");
if (updateMethod != null)
{
if (obj is ContentType)
{
updateMethod.Invoke(obj, new object[] { true });
}
else if (obj is Field)
{
updateMethod = ReflectionUtils.GetMethod(obj, "UpdateAndPushChanges");
updateMethod.Invoke(obj, new object[] { true });
}
else
{
updateMethod.Invoke(obj, null);
}
obj.Context.ExecuteQueryWithTrace();
}
else
{
throw new SPMeta2Exception(String.Format("Can't find Update() methods on client object of type:[{0}]", obj.GetType()));
}
}
}
public static void HandleFlagSync(ClientObject client, byte[] messageData)
{
string flagPath = Path.Combine(Server.universeDirectory, "Flags");
using (MessageReader mr = new MessageReader(messageData))
{
FlagMessageType messageType = (FlagMessageType)mr.Read <int>();
string playerName = mr.Read <string>();
if (playerName != client.playerName)
{
Messages.ConnectionEnd.SendConnectionEnd(client, "Kicked for sending a flag for another player");
return;
}
switch (messageType)
{
case FlagMessageType.LIST:
{
//Send the list back
List <string> serverFlagFileNames = new List <string>();
List <string> serverFlagOwners = new List <string>();
List <string> serverFlagShaSums = new List <string>();
string[] clientFlags = mr.Read <string[]>();
string[] clientFlagShas = mr.Read <string[]>();
string[] serverFlags = Directory.GetFiles(flagPath, "*", SearchOption.AllDirectories);
foreach (string serverFlag in serverFlags)
{
string trimmedName = Path.GetFileName(serverFlag);
string flagOwnerPath = Path.GetDirectoryName(serverFlag);
string flagOwner = flagOwnerPath.Substring(Path.GetDirectoryName(flagOwnerPath).Length + 1);
bool isMatched = false;
bool shaDifferent = false;
for (int i = 0; i < clientFlags.Length; i++)
{
if (clientFlags[i].ToLower() == trimmedName.ToLower())
{
isMatched = true;
shaDifferent = (Common.CalculateSHA256Hash(serverFlag) != clientFlagShas[i]);
}
}
if (!isMatched || shaDifferent)
{
if (flagOwner == client.playerName)
{
DarkLog.Debug("Deleting flag " + trimmedName);
File.Delete(serverFlag);
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.FLAG_SYNC;
using (MessageWriter mw = new MessageWriter())
{
mw.Write <int>((int)FlagMessageType.DELETE_FILE);
mw.Write <string>(trimmedName);
newMessage.data = mw.GetMessageBytes();
ClientHandler.SendToAll(client, newMessage, false);
}
if (Directory.GetFiles(flagOwnerPath).Length == 0)
{
Directory.Delete(flagOwnerPath);
}
}
else
{
DarkLog.Debug("Sending flag " + serverFlag + " from " + flagOwner + " to " + client.playerName);
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.FLAG_SYNC;
using (MessageWriter mw = new MessageWriter())
{
mw.Write <int>((int)FlagMessageType.FLAG_DATA);
mw.Write <string>(flagOwner);
mw.Write <string>(trimmedName);
mw.Write <byte[]>(File.ReadAllBytes(serverFlag));
newMessage.data = mw.GetMessageBytes();
ClientHandler.SendToClient(client, newMessage, false);
}
}
}
//Don't tell the client we have a different copy of the flag so it is reuploaded
if (File.Exists(serverFlag))
{
serverFlagFileNames.Add(trimmedName);
serverFlagOwners.Add(flagOwner);
serverFlagShaSums.Add(Common.CalculateSHA256Hash(serverFlag));
}
}
ServerMessage listMessage = new ServerMessage();
listMessage.type = ServerMessageType.FLAG_SYNC;
using (MessageWriter mw2 = new MessageWriter())
{
mw2.Write <int>((int)FlagMessageType.LIST);
mw2.Write <string[]>(serverFlagFileNames.ToArray());
mw2.Write <string[]>(serverFlagOwners.ToArray());
mw2.Write <string[]>(serverFlagShaSums.ToArray());
listMessage.data = mw2.GetMessageBytes();
}
ClientHandler.SendToClient(client, listMessage, false);
}
break;
case FlagMessageType.DELETE_FILE:
{
string flagName = mr.Read <string>();
string playerFlagPath = Path.Combine(flagPath, client.playerName);
if (Directory.Exists(playerFlagPath))
{
string flagFile = Path.Combine(playerFlagPath, flagName);
if (File.Exists(flagFile))
{
File.Delete(flagFile);
}
if (Directory.GetFiles(playerFlagPath).Length == 0)
{
Directory.Delete(playerFlagPath);
}
}
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.FLAG_SYNC;
using (MessageWriter mw = new MessageWriter())
{
mw.Write <int>((int)FlagMessageType.DELETE_FILE);
mw.Write <string>(flagName);
newMessage.data = mw.GetMessageBytes();
}
ClientHandler.SendToAll(client, newMessage, false);
}
break;
case FlagMessageType.UPLOAD_FILE:
{
string flagName = mr.Read <string>();
byte[] flagData = mr.Read <byte[]>();
string playerFlagPath = Path.Combine(flagPath, client.playerName);
if (!Directory.Exists(playerFlagPath))
{
Directory.CreateDirectory(playerFlagPath);
}
DarkLog.Debug("Saving flag " + flagName + " from " + client.playerName);
File.WriteAllBytes(Path.Combine(playerFlagPath, flagName), flagData);
ServerMessage newMessage = new ServerMessage();
newMessage.type = ServerMessageType.FLAG_SYNC;
using (MessageWriter mw = new MessageWriter())
{
mw.Write <int>((int)FlagMessageType.FLAG_DATA);
mw.Write <string>(client.playerName);
mw.Write <string>(flagName);
mw.Write <byte[]>(flagData);
}
ClientHandler.SendToAll(client, newMessage, false);
}
break;
}
}
}
List <ClientObject> clients = new List <ClientObject>(); // все подключения
protected internal void AddConnection(ClientObject clientObject)
{
clients.Add(clientObject);
}
public static void HandleMessage(ClientObject client, byte[] data)
{
using (MessageReader mr = new MessageReader(data))
{
int type = mr.Read <int>();
switch ((GroupMessageType)type)
{
case GroupMessageType.ADD_ADMIN:
{
string playerName = mr.Read <string>();
string groupName = mr.Read <string>();
if (Groups.fetch.PlayerIsAdmin(client.playerName, groupName))
{
Groups.fetch.AddPlayerAdmin(playerName, groupName);
}
}
break;
case GroupMessageType.ADD_PLAYER:
{
string playerName = mr.Read <string>();
string groupName = mr.Read <string>();
if (Groups.fetch.GroupExists(groupName))
{
if (Groups.fetch.PlayerIsAdmin(client.playerName, groupName))
{
Groups.fetch.AddPlayerToGroup(playerName, groupName);
}
}
else
{
//We can only add ourselves to new groups.
if (playerName == client.playerName)
{
Groups.fetch.AddPlayerToGroup(playerName, groupName);
}
}
}
break;
case GroupMessageType.REMOVE_ADMIN:
{
string playerName = mr.Read <string>();
string groupName = mr.Read <string>();
if (Groups.fetch.PlayerIsAdmin(client.playerName, groupName))
{
Groups.fetch.RemovePlayerAdmin(playerName, groupName);
}
}
break;
case GroupMessageType.REMOVE_PLAYER:
{
string playerName = mr.Read <string>();
string groupName = mr.Read <string>();
if (playerName == client.playerName || Groups.fetch.PlayerIsAdmin(client.playerName, groupName))
{
Groups.fetch.RemovePlayerFromGroup(playerName, groupName);
}
}
break;
case GroupMessageType.REMOVE_GROUP:
{
string groupName = mr.Read <string>();
if (Groups.fetch.PlayerIsAdmin(client.playerName, groupName))
{
Groups.fetch.RemoveGroup(groupName);
}
}
break;
case GroupMessageType.GROUP_REQUEST:
Messages.GroupMessage.SendGroupsToClient(client);
break;
}
}
}
