private T ReadReponseBody <T>(HttpWebResponse response) where T : class { ISerializer serializer = SerializerFactory.GetSerializer(this.ContentType); T result = serializer.Deserialize(typeof(T), response.GetResponseStream()) as T; return(result); }
internal async Task <int> AllocateNewOIDAsync(SqoTypeInfo ti) { ObjectSerializer serializer = SerializerFactory.GetSerializer(this.path, GetFileByType(ti), useElevatedTrust); await serializer.SaveNrRecordsAsync(ti, ti.Header.numberOfRecords + 1).ConfigureAwait(false); return(ti.Header.numberOfRecords); }
private async Task MarkFreeSpaceAsync(SqoTypeInfo ti) { ObjectSerializer serializer = SerializerFactory.GetSerializer(this.path, GetFileByType(ti), useElevatedTrust); int nrRecords = ti.Header.numberOfRecords; List <FieldSqoInfo> existingDynamicFields = new List <FieldSqoInfo>(); foreach (FieldSqoInfo ai in ti.Fields) { IByteTransformer byteTrans = ByteTransformerFactory.GetByteTransformer(null, null, ai, ti); if (byteTrans is ArrayByteTranformer || byteTrans is DictionaryByteTransformer) { existingDynamicFields.Add(ai); } } if (existingDynamicFields.Count > 0) { for (int i = 0; i < nrRecords; i++) { int oid = i + 1; foreach (FieldSqoInfo ai in existingDynamicFields) { ATuple <int, int> arrayInfo = await this.GetArrayMetaOfFieldAsync(ti, oid, ai).ConfigureAwait(false); if (arrayInfo.Name > 0) { await rawSerializer.MarkRawInfoAsFreeAsync(arrayInfo.Name).ConfigureAwait(false);//this helps Shrink method to detect unused rawdata blocks. } } } } }
private void WriteRequestBody <T>(T model, HttpWebRequest request) where T : class { ISerializer serializer = SerializerFactory.GetSerializer(this.ContentType); using (MemoryStream data = new MemoryStream()) { if (request.Headers["Content-Encoding"] == "gzip") { using (GZipStream compressor = new GZipStream(data, CompressionMode.Compress, true)) { serializer.Serialize(typeof(T), model, compressor); } } else { serializer.Serialize(typeof(T), model, data); } data.Position = 0; Stream requestStream = request.GetRequestStream(); data.WriteTo(requestStream); requestStream.Flush(); requestStream.Close(); } }
public void Post([FromBody] EventsDto dto) { var serializer = SerializerFactory.GetSerializer <GameEvent>(dto.SerializerType); var events = serializer.Deserialize(dto.Data); eventStorage.SaveAll(events); }
private void WriteRequestBody <T>(T model, HttpWebRequest request) where T : class { var serializer = SerializerFactory.GetSerializer(this.ContentType); using (var data = new MemoryStream()) { if (request.Headers["Content-Encoding"] == "gzip") { using (var compressor = new GZipStream(data, CompressionMode.Compress, true)) { serializer.Serialize(typeof(T), model, compressor); } } else { serializer.Serialize(typeof(T), model, data); } data.Position = 0; #if !DEBUG Console.WriteLine(Encoding.Default.GetString(data.ToArray())); #endif using (var requestStream = request.GetRequestStream()) { data.WriteTo(requestStream); requestStream.Flush(); requestStream.Close(); } } }
public async Task <MType> ProcessResponse <MType>(IResponse response) { if (!response.IsSuccessful) { var rawErrors = await response.GetRawContent(); System.Exception ex; try { ex = exceptionFactory.CreateApiException(response.GetAPIFormat(), rawErrors, response); } catch (System.Exception e) { var innerEx = new System.Exception("Error response is " + rawErrors, e); throw new Base.Exception.InvalidValueException("Unexspect ", innerEx); } throw ex; } string content = await response.GetRawContent(); var serializer = SerializerFactory.GetSerializer(response.GetAPIFormat()); return(serializer.Deserialize <MType>(content)); }
internal int AllocateNewOID(SqoTypeInfo ti) { ObjectSerializer serializer = SerializerFactory.GetSerializer(this.path, GetFileByType(ti), useElevatedTrust); serializer.SaveNrRecords(ti, ti.Header.numberOfRecords + 1); return(ti.Header.numberOfRecords); }
public void SetContent <RType>(RType reqMode) { if (reqMode != null) { HttpRequest.Content = new StringContent(SerializerFactory.GetSerializer(_APIFormat).Serialize <RType>(reqMode)); HttpRequest.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(GetContentType()); } }
public void DeserializeInnerTest() { var serializer = SerializerFactory.GetSerializer(SDK.Base.APIFormat.JSON); string json = "{\"RequestDate\":\"02/26/2019 15:18:12\",\"DownloadedOrderList\":{\"OrderNumber\":[\"104905420\",\"105137040\"]}}"; OrderConfirmationResponseBody ret = serializer.Deserialize <OrderConfirmationResponseBody>(json); Assert.Equal(2, ret.DownloadedOrderList.Count); }
public void DeserializeTest() { var serializer = SerializerFactory.GetSerializer(SDK.Base.APIFormat.JSON); string json = "{\"NeweggAPIResponse\":{\"IsSuccess\":\"true\",\"OperationType\":\"OrderConfirmationResponse\",\"SellerID\":\"A006\",\"ResponseDate\":\"02/26/2019 15:18:12\",\"ResponseBody\":{\"RequestDate\":\"02/26/2019 15:18:12\",\"DownloadedOrderList\":{\"OrderNumber\":[\"104905420\",\"105137040\"]}}}}"; OrderConfirmationResponse response = serializer.Deserialize <OrderConfirmationResponse>(json); Assert.Equal(2, response.ResponseBody.DownloadedOrderList.Count); }
public void GetSerializer_VersionValid_SerializerReturned() { SerializerFactory factory = new SerializerFactory(); ISerializer serializer = factory.GetSerializer(1); Assert.IsNotNull(serializer); }
private static void GetArrayData(Stream memoryStream) { // NB: here we are assuming the correct behaviour of these serializers, // maybe specific tests should be added as well. SerializerFactory.GetSerializer(typeof(int)).Encode(memoryStream, 1); SerializerFactory.GetSerializer(typeof(float)).Encode(memoryStream, 2f); SerializerFactory.GetSerializer(typeof(string)).Encode(memoryStream, "foo"); }
private void WriteFile <T>(DirectoryInfo storage, T content) where T : class, IIdentifiable { var serializer = SerializerFactory.GetSerializer(content); var fileName = Path.Combine(storage.FullName, content.Id.ToLower()); using (var serializedContent = serializer.Serialize(content)) { FileUtils.Write(fileName, serializedContent); } }
public void ValidateGetSerializerJsonNotStrict() { var deserialized = TestObjects.GetSampleJsonNotStrict(); var serializedResult = (string)deserialized.GetSerializer(); var deserializedResult = SerializerFactory.GetSerializer <SampleJsonNotStrictClass>().Deserialize(serializedResult); Assert.Equal(deserialized, deserializedResult); }
private void Deserialise() { if (m_dataBag != null) { var start = 0; var data = m_dataBag.Bytes; var tags = m_typeTag; m_dataBag = null; for (var index = 0; index < tags.Length; index++) { var tag = tags[index]; if (tag == SerializerFactory.ArrayOpen) { // skip the '[' character. index++; // deserialise array of object var ret = new List <object>(); while (tags[index] != SerializerFactory.ArrayClose && index < tags.Length) { int pos; var des = SerializerFactory.GetSerializer(tags[index]); ret.Add(des.Decode(data, start, out pos)); start = pos; index++; } m_data.Add(ret.ToArray()); } else if (tag != SerializerFactory.DefaultTag) { if (tag != SerializerFactory.EventTag) { int pos; var des = SerializerFactory.GetSerializer(tag); m_data.Add(des.Decode(data, start, out pos)); start = pos; } else { IsEvent = true; } } } } }
public void ListConvertTest() { string Json1 = "{\"NeweggAPIResponse\":{\"IsSuccess\":\"true\",\"OperationType\":\"EditRMAResponse\",\"SellerID\":\"A2EU\",\"ResponseBody\":{\"RMAInfo\":{\"RMANumber\":\"21821229\",\"RMAType\":\"2\",\"RMATypeDescription\":\"Refund\",\"SourceSONumber\":\"299232884\",\"RMANote\":\"edit refund rma to 201601211001\",\"RMATransactionList\":{\"RMATransaction\":{\"SellerPartNumber\":\"Test_SP#A2EU_20181108_0003\",\"ReturnQuantity\":\"1\",\"ReturnUnitPrice\":\"0.02\",\"RefundShippingPrice\":\"0\",\"RMAReason\":\"2\",\"RMAReasonDescription\":\"Defective\"}}}},\"ResponseDate\":\"03/14/2019 18:06:42\"}}"; string Json2 = "{\"NeweggAPIResponse\":{\"IsSuccess\":\"true\",\"OperationType\":\"EditRMAResponse\",\"SellerID\":\"A2EU\",\"ResponseBody\":{\"RMAInfo\":{\"RMANumber\":\"21821229\",\"RMAType\":\"2\",\"RMATypeDescription\":\"Refund\",\"SourceSONumber\":\"299232884\",\"RMANote\":\"edit refund rma to 201601211001\",\"RMATransactionList\":{\"RMATransaction\":[{\"SellerPartNumber\":\"Test_SP#A2EU_20181108_0003\",\"ReturnQuantity\":\"1\",\"ReturnUnitPrice\":\"0.02\",\"RefundShippingPrice\":\"0\",\"RMAReason\":\"2\",\"RMAReasonDescription\":\"Defective\"},{\"SellerPartNumber\":\"Test_SP#A2EU_20181108_0004\",\"ReturnQuantity\":\"1\",\"ReturnUnitPrice\":\"0.02\",\"RefundShippingPrice\":\"0\",\"RMAReason\":\"2\",\"RMAReasonDescription\":\"Defective\"}]}}},\"ResponseDate\":\"02/25/2019 23:52:57\"}}"; var serializer = SerializerFactory.GetSerializer(SDK.Base.APIFormat.JSON); var result1 = serializer.Deserialize <EditRMAResponse>(Json1); var result2 = serializer.Deserialize <EditRMAResponse>(Json2); Assert.IsType <EditRMAResponse>(result1); Assert.IsType <EditRMAResponse>(result2); }
public RpcServer() { _cacheContainer = new ServerCacheContainer(); _localCacheService = new LocalCacheService(_section, _cacheContainer); _serializer = SerializerFactory.GetSerializer(_section.Serializer); _transportProvider = new TransportProvider(_cacheContainer, _serializer); _acceptor = _transportProvider.GetAcceptor(); }
private T ReadFile <T>(FileInfo file) where T : class, IIdentifiable { var serializer = SerializerFactory.GetSerializer(typeof(T)); T content = null; var stream = FileUtils.Read(file.FullName); using (stream) { content = serializer.Deserialize <T>(stream); stream.Close(); } return(content); }
internal async Task DeleteObjectAsync(object obj, SqoTypeInfo ti) { ObjectInfo objInfo = MetaExtractor.GetObjectInfo(obj, ti, metaCache); ObjectSerializer serializer = SerializerFactory.GetSerializer(this.path, GetFileByType(ti), useElevatedTrust); await CheckForConcurencyAsync(obj, objInfo, ti, serializer, true).ConfigureAwait(false); await this.MarkObjectAsDeleteAsync(serializer, objInfo.Oid, ti).ConfigureAwait(false); await this.indexManager.UpdateIndexesAfterDeleteAsync(objInfo, ti).ConfigureAwait(false); metaCache.SetOIDToObject(obj, -1, ti); }
private static byte[] CreateExpectedDataArray4() { var headerData = GetHeaderDataArray(",[ifs]b"); // NB: here we are assuming the correct behaviour of these serializers, // maybe specific tests should be added as well. var memoryStream = new MemoryStream(); GetArrayData(memoryStream); SerializerFactory.GetSerializer(typeof(byte[])).Encode(memoryStream, CreateTestBlob()); var arrayData = memoryStream.ToArray(); return(headerData.Concat(arrayData).ToArray()); }
public System.Exception CreateApiException(APIFormat format, string content, IResponse response) { try { var errors = SerializerFactory.GetSerializer(format).Deserialize <Errors>(content); return(ApiException.Factory(errors, response)); } catch (System.Exception ex) { var exceptionList = new System.Exception[] { ex }; var aggrEx = new AggregateException("Unable to parse error response >" + content + "<", exceptionList); throw aggrEx; } }
internal async Task DeleteObjectAsync(object obj, SqoTypeInfo ti, Transaction transact, ObjectInfo objInfo) { TransactionObject trObject = new TransactionObject(this); trObject.currentObject = obj; trObject.objInfo = objInfo == null?MetaExtractor.GetObjectInfo(obj, ti, metaCache) : objInfo; trObject.serializer = SerializerFactory.GetSerializer(this.path, GetFileByType(ti), useElevatedTrust); trObject.Operation = TransactionObject.OperationType.Delete; await CheckForConcurencyOnlyAsync(obj, trObject.objInfo, ti, trObject.serializer).ConfigureAwait(false); TransactionManager.transactions[transact.ID].transactionObjects.Add(trObject); }
public void GetSerializer_InvalidVersionBytesProvided_ThrowsNotSupportedException() { SerializerFactory factory = new SerializerFactory(); List <byte> bytes = new List <byte>(); bytes.Add(0); if (BitConverter.IsLittleEndian) { bytes.AddRange(BitConverter.GetBytes((ushort)0)); } else { bytes.AddRange(BitConverter.GetBytes((ushort)0).Reverse()); } ISerializer serializer = factory.GetSerializer(bytes.ToArray()); }
internal async Task SaveObjectAsync(object oi, SqoTypeInfo ti, ObjectInfo objInfo, Transactions.Transaction transaction) { TransactionObject trObject = new TransactionObject(this); trObject.currentObject = oi; trObject.objInfo = objInfo == null?MetaExtractor.GetObjectInfo(oi, ti, metaCache) : objInfo; trObject.serializer = SerializerFactory.GetSerializer(this.path, GetFileByType(ti), useElevatedTrust); trObject.Operation = TransactionObject.OperationType.InsertOrUpdate; await CheckForConcurencyOnlyAsync(oi, trObject.objInfo, ti, trObject.serializer).ConfigureAwait(false); await CheckConstraintsAsync(trObject.objInfo, ti).ConfigureAwait(false); TransactionManager.transactions[transaction.ID].AddTransactionObject(trObject); }
internal void DeleteObject(object obj, SqoTypeInfo ti) { ObjectInfo objInfo = MetaExtractor.GetObjectInfo(obj, ti, metaCache); ObjectSerializer serializer = SerializerFactory.GetSerializer(this.path, GetFileByType(ti), useElevatedTrust); lock (_syncRoot) { CheckForConcurency(obj, objInfo, ti, serializer, true); this.MarkObjectAsDelete(serializer, objInfo.Oid, ti); this.indexManager.UpdateIndexesAfterDelete(objInfo, ti); metaCache.SetOIDToObject(obj, -1, ti); } }
internal void DeleteObject(object obj, SqoTypeInfo ti, Transaction transact, ObjectInfo objInfo) { lock (_syncRoot) { TransactionObject trObject = new TransactionObject(this); trObject.currentObject = obj; trObject.objInfo = objInfo == null?MetaExtractor.GetObjectInfo(obj, ti, metaCache) : objInfo; trObject.serializer = SerializerFactory.GetSerializer(this.path, GetFileByType(ti), useElevatedTrust); trObject.Operation = TransactionObject.OperationType.Delete; CheckForConcurencyOnly(obj, trObject.objInfo, ti, trObject.serializer); TransactionManager.transactions[transact.ID].transactionObjects.Add(trObject); } }
internal List <int> DeleteObjectBy(SqoTypeInfo ti, Dictionary <string, object> criteria) { int i = 0; ICriteria wPrev = null; foreach (string fieldName in criteria.Keys) { FieldSqoInfo fi = MetaHelper.FindField(ti.Fields, fieldName); if (fi == null) { throw new SiaqodbException("Field:" + fieldName + " was not found as member of Type:" + ti.TypeName); } Where w = new Where(fieldName, OperationType.Equal, criteria[fieldName]); w.StorageEngine = this; w.ParentSqoTypeInfo = ti; w.ParentType.Add(w.ParentSqoTypeInfo.Type); if (i > 0) { And and = new And(); and.Add(w, wPrev); wPrev = and; } else { wPrev = w; } i++; } List <int> oids = wPrev.GetOIDs(); ObjectSerializer serializer = SerializerFactory.GetSerializer(this.path, GetFileByType(ti), useElevatedTrust); lock (_syncRoot) { foreach (int oid in oids) { this.MarkObjectAsDelete(serializer, oid, ti); this.indexManager.UpdateIndexesAfterDelete(oid, ti); } } return(oids); }
internal async Task AdjustComplexFieldsAfterShrinkAsync(SqoTypeInfo ti, IList <ShrinkResult> shrinkResults) { ObjectSerializer serializer = SerializerFactory.GetSerializer(this.path, GetFileByType(ti), useElevatedTrust); List <FieldSqoInfo> complexFields = (from FieldSqoInfo fi in ti.Fields where fi.AttributeTypeId == MetaExtractor.complexID select fi).ToList(); if (complexFields.Count > 0) { foreach (FieldSqoInfo fi in complexFields) { Dictionary <int, int> oldOidNewOid = new Dictionary <int, int>(); int nrRecords = ti.Header.numberOfRecords; int k = 0; for (int i = 0; i < nrRecords; i++) { int oid = i + 1; KeyValuePair <int, int> Oid_Tid = await serializer.ReadOIDAndTIDAsync(ti, oid, fi).ConfigureAwait(false); if (Oid_Tid.Key == 0 && Oid_Tid.Value == 0)//mean complex object is null { continue; } if (k == 0) { var shrinkResultsFiltered = from ShrinkResult shrinkRes in shrinkResults where shrinkRes.TID == Oid_Tid.Value select shrinkRes; foreach (ShrinkResult shF in shrinkResultsFiltered) { oldOidNewOid[shF.Old_OID] = shF.New_OID; } } if (oldOidNewOid.ContainsKey(Oid_Tid.Key)) { int newOid = oldOidNewOid[Oid_Tid.Key]; await serializer.SaveComplexFieldContentAsync(new KeyValuePair <int, int>(newOid, Oid_Tid.Value), fi, ti, oid).ConfigureAwait(false); } k++; } } } }
/// <summary> /// Initializes a new instance of the <see cref="NetworkManager" /> class. /// </summary> /// <param name="scene">The scene.</param> /// <param name="networkService">The network service.</param> /// <exception cref="System.ArgumentNullException">The 'scene' or 'networkService' argument can't be null.</exception> internal NetworkManager(Scene scene, NetworkService networkService) { if (scene == null) { throw new ArgumentNullException("The 'scene' argument can't be null."); } if (networkService == null) { throw new ArgumentNullException("The 'networkService' argument can't be null."); } this.scene = scene; this.networkService = networkService; this.factories = new Dictionary <string, Func <string, string, Entity> >(); this.entityBehaviors = new Dictionary <string, NetworkBehavior>(); this.serializer = SerializerFactory.GetSerializer <Entity>(SerializationType.DATACONTRACT); }