public string GetSummonerGamesById() { try { using (this.client = new WebClient()) { summonerGamesResponse = client.DownloadString(URLManager.SummonerGamesById(summonerId)); } responseCode = "#02"; } catch (Exception ex) { return("#03"); } try { idName = ReaderManager.FileReader(jsonFilePath); SummonerGames summonerGamesModel = SerializerManager.SummonerGamesSerializer(summonerGamesResponse); this.SummonerGames = NameManager.GamesNameFiller(summonerGamesModel, this.summonerName, idName); } catch (Exception ex) { throw new ArgumentException("Either response serializing or finding name went wrong " + ex.Message); } return(responseCode); }
public void Create_With_Static_Counter() { string createQuery = null; var serializer = new SerializerManager(ProtocolVersion.MaxSupported); var sessionMock = GetSessionMock(serializer); sessionMock .Setup(s => s.Execute(It.IsAny <string>())) .Returns(() => new RowSet()) .Callback <string>(q => createQuery = q); var table = GetTable <AllTypesEntity>(sessionMock.Object, new Map <AllTypesEntity>().ExplicitColumns() .TableName("tbl1") .PartitionKey(t => t.UuidValue) .ClusteringKey(t => t.StringValue) .Column(t => t.UuidValue, cm => cm.WithName("id1")) .Column(t => t.StringValue, cm => cm.WithName("id2")) .Column(t => t.Int64Value, cm => cm.WithName("counter_col1") .AsCounter().AsStatic()) .Column(t => t.IntValue, cm => cm.WithName("counter_col2") .AsCounter())); table.Create(); Assert.AreEqual("CREATE TABLE tbl1 (" + "counter_col1 counter static, counter_col2 counter, id1 uuid, id2 text," + " PRIMARY KEY (id1, id2))", createQuery); }
protected override ITransportServer CreateTransport(KeyValueCollection parameters) { var queueServerName = parameters["QueueServerName"]; var enableGetDescriptors = parameters["EnableGetDescriptors"].ParseTo(true); var serializerMimeType = parameters["SerializerMimeType"]; var compressorEncoding = parameters["CompressorEncoding"]; var serializer = SerializerManager.GetByMimeType(serializerMimeType); if (serializer != null && compressorEncoding.IsNotNullOrEmpty()) { var compressor = CompressorManager.GetByEncodingType(compressorEncoding); if (compressor != null) { serializer.Compressor = compressor; } } Core.Log.LibDebug("Creating a new MessagingTransportServer with the parameters:"); Core.Log.LibDebug("\tQueueServerName: {0}", queueServerName.IsNotNullOrWhitespace() ? queueServerName : "Using Default QueueServer from configuration file."); Core.Log.LibDebug("\tEnableGetDescriptors: {0}", enableGetDescriptors); if (serializerMimeType != null) { Core.Log.LibDebug("\tSerializer: {0}", serializer); if (serializer?.Compressor != null) { Core.Log.LibDebug("\tCompressorEncoding: {0}", compressorEncoding); } } var queueServer = queueServerName.IsNotNullOrWhitespace() ? Core.Services.GetQueueServer(queueServerName) : Core.Services.GetQueueServer(); return(new MessagingTransportServer(queueServer, serializer)); }
private void StartReceive(object sender, DoWorkEventArgs e) { while (_socket.Connected) { // Read the command object. var bytes = new byte[8192]; try { var readBytes = _socket.Receive(bytes); if (readBytes == 0) { break; } CommandContainer command = (CommandContainer)SerializerManager.Deserialize(bytes); if ((command.CommandType == CommandType.ClientSignUp) || (command.CommandType == CommandType.ClientLogIn)) { ProfileContainer profile = (ProfileContainer)command.Data; _clientName = profile.UserName; } OnCommandReceived(new CommandEventArgs(command)); } catch (Exception) { } } OnDisconnected(new ClientEventArgs(_socket)); Disconnect(); }
public void Create_With_Frozen_Collection_Value() { string createQuery = null; var serializer = new SerializerManager(ProtocolVersion.MaxSupported); var sessionMock = GetSessionMock(serializer); sessionMock .Setup(s => s.Execute(It.IsAny <string>())) .Returns(() => new RowSet()) .Callback <string>(q => createQuery = q); var definition = new Map <UdtAndTuplePoco>() .PartitionKey(c => c.Id1) .Column(c => c.Id1, cm => cm.WithName("id")) .Column(c => c.UdtList1, cm => cm.WithName("my_list").WithFrozenValue()) .Column(c => c.TupleMapValue1, cm => cm.WithName("my_map").WithFrozenValue()) .ExplicitColumns() .TableName("tbl1"); var udtInfo = new UdtColumnInfo("song"); udtInfo.Fields.Add(new ColumnDesc { Name = "title", TypeCode = ColumnTypeCode.Ascii }); udtInfo.Fields.Add(new ColumnDesc { Name = "releasedate", TypeCode = ColumnTypeCode.Timestamp }); var udtMap = UdtMap.For <Song>(); udtMap.SetSerializer(serializer.GetCurrentSerializer()); udtMap.Build(udtInfo); serializer.SetUdtMap("song", udtMap); var table = GetTable <UdtAndTuplePoco>(sessionMock.Object, definition); table.Create(); Assert.AreEqual("CREATE TABLE tbl1 (id uuid, my_list list<frozen<\"song\">>, my_map map<text, frozen<tuple<double, double>>>, PRIMARY KEY (id))", createQuery); }
private void StartReceive(object sender, DoWorkEventArgs e) { while (_clientSocket.Connected) { // Read the command object. var bytes = new byte[8192]; try { var readBytes = _clientSocket.Receive(bytes); if (readBytes == 0) { break; } CommandContainer cmd = (CommandContainer)SerializerManager.Deserialize(bytes); OnCommandReceived(new CommandEventArgs(cmd)); } catch (Exception exception) { Console.WriteLine(exception); } } OnServerDisconnected(new ServerEventArgs(_clientSocket)); Disconnect(); }
public void Init(MQPairConfig config, bool sendOnly) { if (config is null) { return; } Config = config; SendOnly = sendOnly; Name = Config.Name; Counters = new MQClientCounters(Name, Config.IgnoreClientCounters); SenderSerializer = SerializerManager.GetByMimeType(Config.RequestOptions?.SerializerMimeType); if (SenderSerializer != null && Config.RequestOptions?.CompressorEncodingType.IsNotNullOrEmpty() == true) { SenderSerializer.Compressor = CompressorManager.GetByEncodingType(Config.RequestOptions?.CompressorEncodingType); } ReceiverSerializer = SerializerManager.GetByMimeType(Config.ResponseOptions?.SerializerMimeType); if (ReceiverSerializer != null && Config.ResponseOptions?.CompressorEncodingType.IsNotNullOrEmpty() == true) { ReceiverSerializer.Compressor = CompressorManager.GetByEncodingType(Config.ResponseOptions?.CompressorEncodingType); } OnInit(); }
/// <summary> /// Adds all defined routes on a HttpController type /// </summary> /// <typeparam name="T">Type of HttpControllerBase</typeparam> /// <returns>SimpleHttpServer instance</returns> public SimpleHttpServer AddHttpControllerRoutes <T>() where T : HttpControllerBase { var type = typeof(T); var methods = type.GetRuntimeMethods(); methods.Each(m => { var routes = m.GetCustomAttributes <HttpRouteAttribute>().ToArray(); if (routes?.Any() == true) { routes.Each(route => AddRouteHandler(route.Method, route.Url, context => { var ctl = Activator.CreateInstance <T>(); ctl.Context = context; var mParams = m.GetParameters(); if (mParams.Length > 0) { ParameterInfo postObjectParam = null; object postObject = null; var ivkParams = new List <object>(); if (context.Request.HasPostObject) { postObjectParam = mParams.FirstOrDefault(p => p.GetCustomAttribute(typeof(PostObjectAttribute)) != null); if (postObjectParam == null && mParams.Length == 1) { postObjectParam = mParams[0]; } if (postObjectParam != null) { postObject = Try.Do(() => context.Request.GetPostObject(postObjectParam.ParameterType)); } } var dictionary = context.Route.GetRouteParameters(context.Request.Url.AbsolutePath); foreach (var mParam in mParams) { if (mParam == postObjectParam) { ivkParams.Add(postObject); } else if (dictionary.ContainsKey(mParam.Name)) { ivkParams.Add(dictionary[mParam.Name]); } else { ivkParams.Add(null); } } var response = m.Invoke(ctl, ivkParams.ToArray()); if (response == null) { return; } var serializer = SerializerManager.GetByMimeType(ctl.Context.Response.ContentType); switch (serializer) { case null when response is string: ctl.Context.Response.Write((string)response); break;
private InformacionEstacionBO consultarUsuariosPorID(string tipoIdEstacion, string numIdEstacion) { BizAgiWSParam param = new BizAgiWSParam(); BizAgiWSParamEntityData entity = new BizAgiWSParamEntityData(); entity.EntityName = "WFUSER"; entity.Filters = "SNumeroidentificacion = '" + numIdEstacion + "' and idTipodeDocumento = "; param.EntityData = entity; XmlDocument schemaDoc = new XmlDocument(); string schemaPath = Path.Combine(AsDirectory.AssemblyDirectory, Properties.Resources.SchemaConsultarCasoDesembolso); schemaDoc.Load(schemaPath); BizagiSOALayerOperations ejecutar = new BizagiSOALayerOperations(); string xml = SerializerManager.SerializarToXml <BizAgiWSParam>(param); ejecutar.Url = ProxyUtils.GetServiceEndpoint("URLEntityManager"); string respuesta = ejecutar.getEntitiesUsingSchemaAsString(xml, schemaDoc.OuterXml); // pendiente ajustar esta parte, se debe generar objetos de tipo wfuser para poder hacer la extracción de la información. InformacionEstacionBO datosEstacion = new InformacionEstacionBO(); return(datosEstacion); }
/// <summary> /// Serializes the content into the correct output. /// </summary> /// <param name="content"></param> /// <param name="contentType"></param> /// <param name="encoding"></param> /// <returns></returns> public ContentStage SerializeContent(object content, string contentType = "", Encoding encoding = null) { PipelineContext.RequestMessage.Content = SerializerManager.SendToSerializer(content, PipelineContext.RequestMessage, contentType, encoding); return(this); }
public static CountryIpIntervalCollection Load(string fileName) { var serializer = SerializerManager.GetByFileName(fileName); var list = serializer.DeserializeFromFile <List <CountryIpInterval> >(fileName); return(new CountryIpIntervalCollection(list)); }
/// <inheritdoc /> /// <summary> /// Create a new storage from a KeyValueCollection parameters /// </summary> /// <param name="parameters">Parameters to create the storage</param> /// <returns>Storage</returns> protected override StorageBase CreateStorage(KeyValueCollection parameters) { var basePath = parameters["BasePath"]; var indexSerializerMimeType = parameters["IndexSerializerMimeType"] ?? SerializerMimeTypes.WBinary; var numberOfSubFolder = parameters["NumberOfSubFolder"].ParseTo((byte)25); var transactionLogThreshold = parameters["TransactionLogThreshold"].ParseTo(250); var slowDownWriteThreshold = parameters["SlowDownWriteThreshold"].ParseTo(1000); var storageType = parameters["StorageType"].ParseTo(FileStorageType.Normal); var indexSerializer = SerializerManager.GetByMimeType <ISerializer>(indexSerializerMimeType); SerializerManager.SupressFileExtensionWarning = true; switch (storageType) { case FileStorageType.Normal: Core.Log.LibDebug("Creating a new FileStorage with the parameters:"); Core.Log.LibDebug("\tBasePath: {0}", basePath); Core.Log.LibDebug("\tNumberOfSubFolders: {0}", numberOfSubFolder); Core.Log.LibDebug("\tTransactionLogThreshold: {0}", transactionLogThreshold); Core.Log.LibDebug("\tSlowDownWriteThreshold: {0}", slowDownWriteThreshold); Core.Log.LibDebug("\tIndexSerializer: {0}", indexSerializer); return(new FileStorage(basePath) { NumberOfSubFolders = numberOfSubFolder, TransactionLogThreshold = transactionLogThreshold, SlowDownWriteThreshold = slowDownWriteThreshold, IndexSerializer = (BinarySerializer)indexSerializer }); } return(null); }
/// <summary> /// Default private constructor. /// </summary> private App() { fields = new AppFieldList(); modules = new AppModuleList(); mediaTypes = new MediaManager(); serializers = new SerializerManager(); }
protected override ITransportClient CreateTransport(KeyValueCollection parameters) { var queueClientName = parameters["QueueClientName"]; var serializerMimeType = parameters["SerializerMimeType"]; var compressorEncoding = parameters["CompressorEncoding"]; var serializer = SerializerManager.GetByMimeType(serializerMimeType); if (serializer != null && compressorEncoding.IsNotNullOrEmpty()) { var compressor = CompressorManager.GetByEncodingType(compressorEncoding); if (compressor != null) { serializer.Compressor = compressor; } } Core.Log.LibDebug("Creating a new MessagingTransportServer with the parameters:"); Core.Log.LibDebug("\tQueueClientName: {0}", queueClientName); if (serializerMimeType != null) { Core.Log.LibDebug("\tSerializer: {0}", serializer); if (serializer?.Compressor != null) { Core.Log.LibDebug("\tCompressorEncoding: {0}", compressorEncoding); } } Ensure.ArgumentNotNull(queueClientName, "The QueueClientName parameter in the MessagingTransportClientFactory can't be null."); var queueClient = Core.Services.GetQueueClient(queueClientName); return(new MessagingTransportClient(queueClient, serializer)); }
public void Should_HandleDifferentProtocolVersionsInDifferentConnections_When_OneConnectionResponseVersionIsDifferentThanSerializer() { var serializer = new SerializerManager(ProtocolVersion.V4); var connectionMock = GetConnectionMock(null, serializer); var connectionMock2 = GetConnectionMock(null, serializer); var streamIds = new List <short>(); var responses = new ConcurrentBag <Response>(); connectionMock.Setup(c => c.RemoveFromPending(It.IsAny <short>())) .Callback <short>(id => streamIds.Add(id)) .Returns(() => OperationStateExtensions.CreateMock((ex, r) => responses.Add(r))); connectionMock2.Setup(c => c.RemoveFromPending(It.IsAny <short>())) .Callback <short>(id => streamIds.Add(id)) .Returns(() => OperationStateExtensions.CreateMock((ex, r) => responses.Add(r))); var connection = connectionMock.Object; var buffer = GetResultBuffer(128, ProtocolVersion.V4); connection.ReadParse(buffer, buffer.Length); buffer = ConnectionTests.GetResultBuffer(100, ProtocolVersion.V2); connectionMock2.Object.ReadParse(buffer, buffer.Length); buffer = GetResultBuffer(129, ProtocolVersion.V4); connection.ReadParse(buffer, buffer.Length); CollectionAssert.AreEqual(new short[] { 128, 100, 129 }, streamIds); TestHelper.WaitUntil(() => responses.Count == 3); Assert.AreEqual(3, responses.Count); }
public static Row CreateRow(ICollection <KeyValuePair <string, object> > valueMap) { var columns = new List <CqlColumn>(); var rowValues = new List <object>(); var serializer = new SerializerManager(ProtocolVersion.MaxSupported).GetCurrentSerializer(); foreach (var kv in valueMap) { if (kv.Value != null) { IColumnInfo typeInfo; var typeCode = serializer.GetCqlType(kv.Value.GetType(), out typeInfo); columns.Add(new CqlColumn { Name = kv.Key, TypeCode = typeCode, TypeInfo = typeInfo }); } else { columns.Add(new CqlColumn() { Name = kv.Key, TypeCode = ColumnTypeCode.Text }); } rowValues.Add(kv.Value); } var i = 0; return(new Row(rowValues.ToArray(), columns.ToArray(), valueMap.ToDictionary(kv => kv.Key, kv => i++))); }
internal static List <ObjetoSalidaECM> ConsultarDocumentos(ObjetoEntradaECM obj) { try { List <ObjetoSalidaECM> lstSalida = new List <ObjetoSalidaECM>(); #region Request #region Header ECMService.HeaderDto header = new ECMService.HeaderDto(); header.Token = obj.Header.Token; header.Usuario = obj.Header.Usuario; #endregion ECMService.Gestor_ConsultarDocumentoRequest req = new ECMService.Gestor_ConsultarDocumentoRequest(header, obj.NumeroRadicado, obj.Identificacion); #endregion #region Trace Request if (obj.Trace.ActivarTrace) { var respuestaObj = SerializerManager.SerializarToXml <ECMService.Gestor_ConsultarDocumentoRequest>(req); ECMManager.CrearArchivo(obj, "RequestConsultar_ECM", respuestaObj); } #endregion var res = EcmService.Gestor_ConsultarDocumento(req); #region Trace Response if (obj.Trace.ActivarTrace) { var respuestaObj = SerializerManager.SerializarToXml <Bizagi.ECM.Manager.ECMService.Gestor_ConsultarDocumentoResponse>(res); ECMManager.CrearArchivo(obj, "ResponseConsultar_ECM", respuestaObj); } #endregion if (res.Gestor_ConsultarDocumentoResult.Sucess) { foreach (var item in res.Gestor_ConsultarDocumentoResult.Results) { foreach (var itemDoc in item.Documentos) { ObjetoSalidaECM oSalida = new ObjetoSalidaECM(); oSalida.NumeroDocumento = itemDoc.CodigoArchivo; oSalida.CodigoTipoDocumental = itemDoc.CodigoDirectorio; oSalida.NumeroRadicado = item.Radicado; lstSalida.Add(oSalida); DateTime.Now.ToShortDateString(); } } } else { throw new Exception("Error : " + res.Gestor_ConsultarDocumentoResult.Message); } return(lstSalida); } catch (Exception ex) { throw ex; } }
public SerializerManager Register() { var manager = new SerializerManager(); manager.Register <TextField>(new StringFieldSerializer <TextField>()); return(manager); }
internal MediaTypeFormatter CreateFormatter() { JsonMediaTypeFormatter formatter = new JsonMediaTypeFormatter(); SerializerManager factory = new SerializerManager(_setups, SerializationTypeRegistry.Default); factory.ConfigureJsonSerializerSettings(formatter.SerializerSettings); return(formatter); }
public processes performActivity(string xml) { WorkflowEngineSOA.WorkflowEngineSOA wfEngine = new WorkflowEngineSOA.WorkflowEngineSOA(); wfEngine.Url = url; string xmlRespuesta = wfEngine.performActivityAsString(xml); processes respuesta = SerializerManager.DeserializarTo <processes>(xmlRespuesta); return(respuesta); }
public void Should_SkipMetadata_When_NotBoundStatement(ProtocolVersion version) { var serializerManager = new SerializerManager(version); var stmt = new SimpleStatement("DUMMY QUERY"); var queryOptions = new QueryOptions(); var request = (QueryRequest)RequestHandler.GetRequest(stmt, serializerManager.GetCurrentSerializer(), GetRequestOptions(queryOptions)); Assert.IsFalse(request.SkipMetadata); }
void Start() { // get serialized data serializerManager = SerializerManager.Instance; gameData = serializerManager.LoadGameData(); PopulateUIGameData(); MLInput.OnTriggerDown += HandleOnTriggerDown; }
/// <summary> /// Default private constructor. /// </summary> private App() { fields = new AppFieldList(); modules = new AppModuleList(); mediaTypes = new MediaManager(); serializers = new SerializerManager(); contentTypes = new ContentTypeManager(); hooks = new HookManager(); }
/// <summary> /// Sets the default TWCoreValues /// </summary> public static void SetDefaultTWCoreValues(this IServiceCollection services, CoreWebSettings settings = null) { settings = settings ?? new CoreWebSettings(); services.AddMvc(options => { try { options.OutputFormatters.Add(new XmlSerializerOutputFormatter()); if (settings.EnableFormatMapping) { options.FormatterMappings.SetMediaTypeMappingForFormat ("xml", MediaTypeHeaderValue.Parse("application/xml")); options.FormatterMappings.SetMediaTypeMappingForFormat ("js", MediaTypeHeaderValue.Parse("application/json")); } if (settings.EnableTWCoreSerializers) { var serializers = SerializerManager.GetBinarySerializers(); foreach (var serializer in serializers) { options.AddISerializerInputFormatter(serializer); options.AddISerializerOutputFormatter(serializer); if (settings.EnableFormatMapping) { options.FormatterMappings.SetMediaTypeMappingForFormat(serializer.Extensions[0].Substring(1), MediaTypeHeaderValue.Parse(serializer.MimeTypes[0])); } } } } catch (Exception ex) { Core.Log.Write(ex); } }) .AddJsonOptions(options => { if (settings.EnableJsonStringEnum) { options.SerializerSettings.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter()); } }); services.AddLogging(cfg => { if (settings.EnableTWCoreLogger) { cfg.AddTWCoreLogger(); } }); if (settings.EnableGZipCompressor) { services.Configure <GzipCompressionProviderOptions>(options => options.Level = System.IO.Compression.CompressionLevel.Fastest); services.AddResponseCompression(); } }
internal static ObjetoSalidaECM ActualizarDocumento(ObjetoEntradaECM obj) { try { ObjetoSalidaECM salida = new Manager.ObjetoSalidaECM(); #region Request #region File FileDto file = new FileDto(); //file.Base64String = Convert.ToBase64String(obj.Base64String); file.CodigoTipoDocumental = obj.CodigoTipoDocumental; file.Ext = obj.Ext; file.Nombre = obj.NombreDocumento; #endregion #region Header ECMService.HeaderDto header = new ECMService.HeaderDto(); header.Token = obj.Header.Token; header.Usuario = obj.Header.Usuario; #endregion ECMService.Gestor_CambiarDocumentoRequest req = new ECMService.Gestor_CambiarDocumentoRequest(header, obj.NumeroDocumento, file); #endregion #region Trace Request if (obj.Trace.ActivarTrace) { var respuestaObj = SerializerManager.SerializarToXml <ECMService.Gestor_CambiarDocumentoRequest>(req); ECMManager.CrearArchivo(obj, "RequestModificar_ECM", respuestaObj); } #endregion var res = EcmService.Gestor_CambiarDocumento(req); #region Trace Response if (obj.Trace.ActivarTrace) { var respuestaObj = SerializerManager.SerializarToXml <Bizagi.ECM.Manager.ECMService.Gestor_CambiarDocumentoResponse>(res); ECMManager.CrearArchivo(obj, "ResponseModificar_ECM", respuestaObj); } #endregion if (res.Gestor_CambiarDocumentoResult.Sucess) { salida.NumeroDocumento = res.Gestor_CambiarDocumentoResult.CodeFiles[0]; salida.NumeroRadicado = res.Gestor_CambiarDocumentoResult.Results; return(salida); } else { throw new Exception("Error : " + res.Gestor_CambiarDocumentoResult.Message); } } catch (Exception ex) { throw ex; } }
public void Should_NotSkipMetadata_When_BoundStatementDoesNotContainColumnDefinitions(ProtocolVersion version) { var serializerManager = new SerializerManager(version); var ps = GetPrepared(serializerManager: serializerManager); var stmt = ps.Bind(); var queryOptions = new QueryOptions(); var request = (ExecuteRequest)RequestHandler.GetRequest(stmt, serializerManager.GetCurrentSerializer(), GetRequestOptions(queryOptions)); Assert.IsFalse(request.SkipMetadata); }
public static void LoadSettings(string settingsFilePath, string environmentName = null, string machineName = null, string applicationName = null) { if (settingsFilePath == null) { throw new NullReferenceException("The settings file path is null."); } environmentName = environmentName ?? EnvironmentName; machineName = machineName ?? MachineName; applicationName = applicationName ?? ApplicationName; settingsFilePath = settingsFilePath?.Replace("{EnvironmentName}", environmentName); settingsFilePath = settingsFilePath?.Replace("{MachineName}", machineName); settingsFilePath = settingsFilePath?.Replace("{ApplicationName}", applicationName); Ensure.ExistFile(settingsFilePath); var serializer = SerializerManager.GetByFileExtension(Path.GetExtension(settingsFilePath)); Ensure.ReferenceNotNull(serializer, $"A serializer for file '{settingsFilePath}' was not found"); GlobalSettings globalSettings; try { if (serializer is ITextSerializer txtSerializer) { var fileContent = File.ReadAllText(settingsFilePath); fileContent = ReplaceEnvironmentTemplate(fileContent); globalSettings = txtSerializer.DeserializeFromString <GlobalSettings>(fileContent); } else { globalSettings = serializer.DeserializeFromFile <GlobalSettings>(settingsFilePath); } } catch (Exception ex) { throw new Exception($"The Global settings file: {settingsFilePath} can't be deserialized.", ex); } try { LoadSettings(globalSettings, environmentName, machineName, applicationName); RebindSettings(); } catch (Exception ex) { throw new Exception("Error loading the settings definitions.", ex); } //Checks if a reload time is set. if (GlobalSettings != null && GlobalSettings.SettingsReloadTimeInMinutes > 0) { Task.Delay(GlobalSettings.SettingsReloadTimeInMinutes * 60 * 1000).ContinueWith(t => { LoadSettings(settingsFilePath, environmentName, machineName, applicationName); }); } }
protected override ITransportClient CreateTransport(KeyValueCollection parameters) { var url = parameters["Url"]; var serializerMimeType = parameters["SerializerMimeType"]; var serializer = SerializerManager.GetByMimeType(serializerMimeType); Core.Log.LibDebug("Creating a new HttpTransportClient with the parameters:"); Core.Log.LibDebug("\tUrl: {0}", url); Core.Log.LibDebug("\tSerializer: {0}", serializer); return(new HttpTransportClient(url, serializer)); }
public AjustePNCSegurosResponse AjustarPNCSeguros(AjustePNCSegurosRequest request) { try { AjustePNCSegurosResponse res = new AjustePNCSegurosResponse(); res.Codigo = "1"; res.Mensaje = "Proceso Ejecutado"; var rr2 = SerializerManager.SerializarToXml <AjustePNCSegurosRequest>(request); #region Consultar XmlDocument schemaDoc = new XmlDocument(); string schemaPath = Path.Combine(AsDirectory.AssemblyDirectory, Properties.Resources.SchemaConsultarCasoSeguros); schemaDoc.Load(schemaPath); string respuesta = Ejecutar.getCaseDataUsingSchemaAsString(string.Empty, request.WorkItem, schemaDoc.OuterXml); XmlDocument doc = new XmlDocument(); doc.LoadXml(respuesta); BizAgiWSResponseType con = SerializerManager.DeserializarTo2 <BizAgiWSResponseType>(respuesta); #endregion #region Modificar M_Solicitud mSol = new M_Solicitud(); mSol.key = con.M_Solicitud.key; mSol.keySpecified = true; mSol.OidReclamacionSeguro = new M_SolicitudOidReclamacionSeguro(); mSol.OidReclamacionSeguro.key = con.M_Solicitud.OidReclamacionSeguro; mSol.OidReclamacionSeguro.keySpecified = true; mSol.OidReclamacionSeguro.XDocumentosReclamacion = new List <M_SolicitudOidReclamacionSeguroXDocumentosReclamacionM_DocumentoRecSeguro>(); foreach (var item in request.LstDocumentos) { mSol.OidReclamacionSeguro.XDocumentosReclamacion.Add (new M_SolicitudOidReclamacionSeguroXDocumentosReclamacionM_DocumentoRecSeguro() { SUrlDocumento = item }); } BizAgiWSParamType <M_Solicitud> saveEntity = new BizAgiWSParamType <M_Solicitud>(); saveEntity.Entities = new EntitiesType <M_Solicitud>(); saveEntity.Entities.Informacion = new M_Solicitud(); saveEntity.Entities.Informacion = mSol; var save = SerializerManager.SerializarToXml <BizAgiWSParamType <M_Solicitud> >(saveEntity); var rt = Ejecutar.saveEntityAsString(save); #endregion return(res); } catch (Exception ex) { throw ex; } }
/// <summary> /// Default private constructor. /// </summary> private App() { _blocks = new AppBlockList(); _fields = new AppFieldList(); _modules = new AppModuleList(); _mediaTypes = new MediaManager(); _serializers = new SerializerManager(); _contentTypes = new ContentTypeManager(); _hooks = new HookManager(); _permissions = new PermissionManager(); }