private void btnDeserializeServiceConfigurationManager_Click(object sender, EventArgs e)
{
ServiceConfigurationCollection list = new ServiceConfigurationCollection();
ServiceConfiguration c = new ServiceConfiguration();
c.Audit = true;
c.Description = "Servicio de prueba";
c.IsolationLevel = Fwk.Transaction.IsolationLevel.ReadCommitted;
c.Name = "pepep";
c.TransactionalBehaviour = Fwk.Transaction.TransactionalBehaviour.Suppres;
c.Request = "BuscarPaisesPorParametros.BuscarPaisesPorParametrosRequest , GestionarPaisesISVC";
c.Response = "BuscarPaisesPorParametros.BuscarPaisesPorParametrosResponse , GestionarPaisesISVC";
list.Add(c);
c = new ServiceConfiguration();
c.Audit = true;
c.Description = "ModificarLocalidadService ";
c.IsolationLevel = Fwk.Transaction.IsolationLevel.ReadCommitted;
c.Name = "ModificarLocalidadService";
c.TransactionalBehaviour = Fwk.Transaction.TransactionalBehaviour.Suppres;
c.Request = "BuscarPaisesPorParametros.BuscarPaisesPorParametrosRequest , GestionarPaisesISVC";
c.Response = "BuscarPaisesPorParametros.BuscarPaisesPorParametrosResponse , GestionarPaisesISVC";
list.Add(c);
txtEntidadSimple.Text = c.GetXml();
txtCollection.Text = SerializationFunctions.SerializeToXml(list);
}
/// <summary>
/// si wapiConfigPath = "" intenta buscarlo en AppSettings si no lo encuntra configurado lo buscara en el root de la aplicacion
/// </summary>
/// <param name="wapiConfigPath"></param>
/// <returns></returns>
public static apiConfig CreateNew(string wapiConfigPath)
{
apiConfig apiConfig = null;
if (string.IsNullOrEmpty(wapiConfigPath))
{
//wapiConfigPath = System.Configuration.ConfigurationManager.AppSettings.Get("wapiConfig");
if (String.IsNullOrEmpty(wapiConfigPath))
{
throw new TechnicalException("No se encuentra configurada la ruta del archivo el wapiConfig.json en web.config settings");
}
}
if (System.IO.File.Exists(wapiConfigPath) == false)
{
throw new TechnicalException("No existe el archivo " + wapiConfigPath);
}
string apiConfigJson = FileFunctions.OpenTextFile(wapiConfigPath);
apiConfig = (apiConfig)SerializationFunctions.DeSerializeObjectFromJson(typeof(apiConfig), apiConfigJson);
return(apiConfig);
}
private void btnDeSerializeServiceConfiguration_Click(object sender, EventArgs e)
{
String xml = FileFunctions.OpenTextFile("BPConfig.xml");
ServiceConfigurationCollection list =
(ServiceConfigurationCollection)SerializationFunctions.DeserializeFromXml(typeof(ServiceConfigurationCollection), xml);
txtCollection.Text = SerializationFunctions.SerializeToXml(list);
}
/// <summary>
/// Busca el archivo lo carga a _Services que es un ServiceConfigurationCollection
/// </summary>
///<param name="xmlConfigFile"></param>
/// <returns></returns>
/// <date>2007-07-13T00:00:00</date>
/// <author>moviedo</author>
static ServiceConfigurationCollection LoadAllServices(string xmlConfigFile)
{
try
{
if (!System.IO.File.Exists(xmlConfigFile))
{
//Application.StartupPath
xmlConfigFile = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), xmlConfigFile);
}
String xml = FileFunctions.OpenTextFile(xmlConfigFile);
return((ServiceConfigurationCollection)SerializationFunctions.DeserializeFromXml(typeof(ServiceConfigurationCollection), xml));
}
catch (System.IO.IOException ioex)
{
TechnicalException te = new TechnicalException(Fwk.Bases.Properties.Resources.ServiceManagement_SourceInfo_Error, ioex);
if (string.IsNullOrEmpty(ConfigurationsHelper.HostApplicationName))
{
te.Source = string.Concat("Despachador de servicios en ", Environment.MachineName);
}
else
{
te.Source = ConfigurationsHelper.HostApplicationName;
}
te.ErrorId = "7004";
te.Assembly = typeof(XmlServiceConfigurationManager).AssemblyQualifiedName;
te.Class = typeof(XmlServiceConfigurationManager).Name;
te.Namespace = typeof(XmlServiceConfigurationManager).Namespace;
throw te;
}
catch (TechnicalException te)
{
throw te;
}
catch (Exception ex)
{
string strError = string.Concat("Error al inicializar la metadata de los servicios \r\n ",
"Nombre de archivo :", xmlConfigFile, Environment.NewLine);
Fwk.Exceptions.TechnicalException te = new Fwk.Exceptions.TechnicalException(strError, ex);
if (string.IsNullOrEmpty(ConfigurationsHelper.HostApplicationName))
{
te.Source = string.Concat("Despachador de servicios en ", Environment.MachineName);
}
else
{
te.Source = ConfigurationsHelper.HostApplicationName;
}
te.ErrorId = "7004";
te.Assembly = typeof(XmlServiceConfigurationManager).AssemblyQualifiedName;
te.Class = typeof(XmlServiceConfigurationManager).Name;
te.Namespace = typeof(XmlServiceConfigurationManager).Namespace;
throw te;
}
}
internal static void Process(Byte[] messageInBytes, DateTime time)
{
try
{
String wStrMessage = Encoding.ASCII.GetString((Byte[])messageInBytes);
SysEventMessage wSysEvent = (SysEventMessage)SerializationFunctions.DeserializeFromXml(typeof(SysEventMessage), wStrMessage);
}
catch (Exception ex)
{
LogError(ex);
}
}
internal static SysEventMessage GetSysEventMessage(Byte[] messageInBytes)
{
SysEventMessage wSysEvent = null;
try
{
String wStrMessage = Encoding.ASCII.GetString((Byte[])messageInBytes);
wSysEvent = (SysEventMessage)SerializationFunctions.DeserializeFromXml(typeof(SysEventMessage), wStrMessage);
}
catch (Exception ex)
{
LogError(ex);
}
return(wSysEvent);
}
public static void SendUpdatePlayer(List <Client> clients, int id, bool json)
{
var updatedPlayer = clients.Single(c => c.Player.PlayerId == id).Player;
foreach (var client in clients)
{
if (json)
{
NetHelpers.SendString($"WAP/1.0 UPDATEPLAYER {SerializationFunctions.SerializeObject(updatedPlayer)};", client.Socket);
}
else
{
NetHelpers.SendString($"WAP/1.0 UPDATEPLAYER {updatedPlayer};", client.Socket);
}
}
}
/// <summary>
/// Guarda los cambios en el archivo
/// </summary>
/// <param name="xmlConfigFile">Nombre del archivo que contiene la metadata.</param>
/// <param name="services">Repositorio de servicios enmemoria.</param>
static void SaveServiceConfigFile(string xmlConfigFile, ServiceConfigurationCollection services)
{
String xml = SerializationFunctions.SerializeToXml(services);
try
{
HelperFunctions.FileFunctions.SaveTextFile(xmlConfigFile, xml, false);
}
catch (System.UnauthorizedAccessException)
{
TechnicalException te = new TechnicalException(string.Concat("No tiene permiso para actualizar el archivo ", xmlConfigFile));
te.ErrorId = "7100";
Fwk.Exceptions.ExceptionHelper.SetTechnicalException <XmlServiceConfigurationManager>(te);
throw te;
}
}
public static void SendNewPlayerResponses(List <Client> clients, WorldMap world, int id, bool json)
{
var newPlayer = clients.Single(c => c.Player.PlayerId == id);
foreach (var client in clients)
{
if (client.Player.PlayerId == id)
{
var data = string.Empty;
if (json)
{
var tiles = new List <Tile>();
foreach (var tile in world.GameMap)
{
if (tile.HasGold || tile.HasHealth)
{
tiles.Add(tile);
}
}
var dataObject = new SendState(clients.Select(c => c.Player).ToList(), tiles);
data = $"WAP/1.0 SENDSTATE {SerializationFunctions.SerializeObject(dataObject)}";
}
else
{
var worldBuilder = new StringBuilder("WAP/1.0 SENDSTATE");
AddWorld(clients, world, worldBuilder);
worldBuilder.Append(';');
data = worldBuilder.ToString();
}
NetHelpers.SendString(data, client.Socket);
}
else
{
if (json)
{
NetHelpers.SendString($"WAP/1.0 NEWPLAYER {SerializationFunctions.SerializeObject(newPlayer.Player)};", client.Socket);
}
else
{
NetHelpers.SendString($"WAP/1.0 NEWPLAYER {newPlayer.Player.Name},{newPlayer.Player};", client.Socket);
}
}
}
}
/// <summary>
/// Inicializa los datos de negocio que pertenecen al Request/Response con el contenido del xml.-
/// </summary>
/// <param name="pXMLData">Xml que respeta el esquema de la informacion de negocio del Request o Response.</param>
public void SetBusinessDataXml(string pXMLData)
{
m_Data = (T)SerializationFunctions.Deserialize(typeof(T), pXMLData);
}
/// <summary>
/// Retorna el xml del Context que pertenece al Request o Response.-
/// </summary>
/// <returns>xml</returns>
public string GetContextInformationXml()
{
return(SerializationFunctions.SerializeToXml(m_Context));
}
/// <summary>
/// Obtiene el xml del request o response .-
/// </summary>
/// <returns>Xml producto de la serializacion</returns>
public string GetXml()
{
return(SerializationFunctions.SerializeToXml(this));
}
private void SetErrors(string pXmlError)
{
m_Error = (ServiceError)SerializationFunctions.Deserialize(typeof(ServiceError), pXmlError);
}
static void RecieveResponse()
{
if (_players == null)
{
_players = new List <Player>();
}
byte[] bytes = new byte[BUFFERLENGTH];
_socket.Receive(bytes);
string fromServer = Encoding.UTF8.GetString(bytes).TrimEnd('\0');
string[] responses = fromServer.Split(';');
foreach (string response in responses)
{
string[] responseParts = response.Split(' ');
if (responseParts[0] == "WAP/1.0")
{
if (responseParts[1] == "WELCOME")
{
_receiveJson = responseParts[2] == "JSON";
}
if (responseParts[1] == "YOURTURN")
{
if (!_playerId.HasValue)
{
_playerId = int.Parse(responseParts[2]);
}
_responseQueue.Enqueue(ServerResponse.YourTurn);
}
if (responseParts[1] == "SENDSTATE")
{
if (_receiveJson)
{
var sendState = SerializationFunctions.DeserializeObject <SendState>(responseParts[2]);
foreach (Player player in sendState.Players)
{
Player existingPlayer = _players.SingleOrDefault(p => p.PlayerId == player.PlayerId);
if (existingPlayer == null)
{
_players.Add(new Player(player.PlayerId, player.Name, player.Health, 10, player.Gold, player.Coordinates));
}
else
{
existingPlayer.Gold = player.Gold;
existingPlayer.Health = player.Health;
existingPlayer.Coordinates = player.Coordinates;
}
}
foreach (Tile tile in sendState.Tiles)
{
gameBoard[tile.X, tile.Y].Gold = tile.Gold;
gameBoard[tile.X, tile.Y].Health = tile.Health;
}
}
else
{
for (int i = 2; i < responseParts.Length; i++)
{
string[] itemInfos = responseParts[i].Split(',');
switch (itemInfos[0])
{
case "Pl":
string name = itemInfos[1];
int playerId = int.Parse(itemInfos[2]);
Coords coordinates = new Coords(int.Parse(itemInfos[3]), int.Parse(itemInfos[4]));
int health = int.Parse(itemInfos[5]);
int gold = int.Parse(itemInfos[6]);
Player player = _players.SingleOrDefault(p => p.PlayerId == playerId);
if (player == null)
{
player = new Player(playerId, name, health, 10, gold, coordinates);
_players.Add(player);
}
else
{
player.Health = health;
player.Gold = gold;
player.Coordinates = coordinates;
}
break;
case "P":
coordinates = new Coords(int.Parse(itemInfos[1]), int.Parse(itemInfos[2]));
health = int.Parse(itemInfos[3]);
gameBoard[coordinates.X, coordinates.Y].Health = health;
break;
case "G":
coordinates = new Coords(int.Parse(itemInfos[1]), int.Parse(itemInfos[2]));
gold = int.Parse(itemInfos[3]);
gameBoard[coordinates.X, coordinates.Y].Gold = gold;
break;
}
}
}
_responseQueue.Enqueue(ServerResponse.Sendstate);
}
if (responseParts[1] == "NEWPLAYER")
{
if (_receiveJson)
{
var player = SerializationFunctions.DeserializeObject <Player>(responseParts[2]);
_players.Add(new Player(player.PlayerId, player.Name, player.Health, 10, player.Gold, player.Coordinates));
}
else
{
string[] playerInfos = responseParts[2].Split(',');
string name = playerInfos[0];
int id = int.Parse(playerInfos[1]);
Coords coordinates = new Coords(int.Parse(playerInfos[2]), int.Parse(playerInfos[3]));
int health = int.Parse(playerInfos[4]);
int gold = int.Parse(playerInfos[5]);
var player = new Player(id, name, health, 10, gold, coordinates);
player.PlayerId = id;
_players.Add(player);
}
_responseQueue.Enqueue(ServerResponse.NewPlayer);
}
if (responseParts[1] == "UPDATEPLAYER")
{
Player playerToUpdate;
if (_receiveJson)
{
var player = SerializationFunctions.DeserializeObject <Player>(responseParts[2]);
playerToUpdate = _players.Single(p => p.PlayerId == player.PlayerId);
playerToUpdate.Coordinates = player.Coordinates;
playerToUpdate.Gold = player.Gold;
playerToUpdate.Health = player.Health;
}
else
{
string[] playerInfos = responseParts[2].Split(',');
int id = int.Parse(playerInfos[0]);
Coords coordinates = new Coords(int.Parse(playerInfos[1]), int.Parse(playerInfos[2]));
int health = int.Parse(playerInfos[3]);
int gold = int.Parse(playerInfos[4]);
playerToUpdate = _players.Single(p => p.PlayerId == id);
playerToUpdate.Coordinates = coordinates;
playerToUpdate.Health = health;
playerToUpdate.Gold = gold;
}
_responseQueue.Enqueue(ServerResponse.UpdatePlayer);
}
if (responseParts[1] == "REMOVEPLAYER")
{
int id = int.Parse(responseParts[2]);
Player playerToRemove = _players.SingleOrDefault(p => p.PlayerId == id);
if (playerToRemove != null)
{
_players.Remove(playerToRemove);
}
_responseQueue.Enqueue(ServerResponse.RemovePlayer);
}
if (responseParts[1] == "UPDATETILE")
{
if (_receiveJson)
{
var tile = SerializationFunctions.DeserializeObject <Tile>(responseParts[2]);
Tile tileToUpdate = gameBoard[tile.X, tile.Y];
tileToUpdate.Gold = tile.Gold;
tileToUpdate.Health = tile.Health;
}
else
{
string[] tileInfos = responseParts[2].Split(',');
Coords coordinates = new Coords(int.Parse(tileInfos[0]), int.Parse(tileInfos[1]));
int gold = int.Parse(tileInfos[2]);
int health = int.Parse(tileInfos[3]);
gameBoard[coordinates.X, coordinates.Y].Gold = gold;
gameBoard[coordinates.X, coordinates.Y].Health = health;
}
_responseQueue.Enqueue(ServerResponse.UpdateTile);
}
if (responseParts[1] == "MESSAGE")
{
int id = int.Parse(responseParts[2]);
string name = _players.SingleOrDefault(p => p.PlayerId == id)?.Name;
if (_chatMessages.Count == 5)
{
_chatMessages.RemoveAt(0);
}
var messageBuilder = new StringBuilder();
messageBuilder.Append($"{name}: ");
for (int i = 3; i < responseParts.Count(); i++)
{
messageBuilder.Append($"{responseParts[i]} ");
}
_chatMessages.Add(messageBuilder.ToString());
_responseQueue.Enqueue(ServerResponse.Message);
}
if (responseParts[1] == "DENIED")
{
if (responseParts[2] == "LOGIN")
{
_responseQueue.Enqueue(ServerResponse.LoginDenied);
}
else if (responseParts[2] == "MOVE")
{
_responseQueue.Enqueue(ServerResponse.MoveDenied);
}
}
}
}
}
private static string EncodeTile(WorldMap world, Coords coords, bool json)
{
return(json ? SerializationFunctions.SerializeObject(world.GameMap[coords.X, coords.Y]) : world.GameMap[coords.X, coords.Y].ToString());
}
