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);
}
