public override AccessControlList Deserialize(ServiceResponse xmlStream)
{
var model = ContentDeserializer.Deserialize(xmlStream.Content);
var acl = new AccessControlList {
Owner = new Owner(model.Owner.Id, model.Owner.DisplayName)
};
foreach (var grant in model.Grants)
{
if (grant == EnumUtils.GetStringValue(CannedAccessControlList.PublicRead))
{
acl.GrantPermission(GroupGrantee.AllUsers, Permission.Read);
acl.ACL = CannedAccessControlList.PublicRead;
}
else if (grant == EnumUtils.GetStringValue(CannedAccessControlList.PublicReadWrite))
{
acl.GrantPermission(GroupGrantee.AllUsers, Permission.FullControl);
acl.ACL = CannedAccessControlList.PublicReadWrite;
}
else if (grant == EnumUtils.GetStringValue(CannedAccessControlList.Private))
{
acl.ACL = CannedAccessControlList.Private;
}
else if (grant == EnumUtils.GetStringValue(CannedAccessControlList.Default))
{
acl.ACL = CannedAccessControlList.Default;
}
}
DeserializeGeneric(xmlStream, acl);
return(acl);
}
public override GetLiveChannelHistoryResult Deserialize(ServiceResponse xmlStream)
{
var model = ContentDeserializer.Deserialize(xmlStream.Content);
GetLiveChannelHistoryResult result = new GetLiveChannelHistoryResult();
var liveRecords = new List <LiveRecord>();
if (model.LiveRecords != null)
{
foreach (var e in model.LiveRecords)
{
var liveRecord = new LiveRecord()
{
StartTime = e.StartTime,
EndTime = e.EndTime,
RemoteAddr = e.RemoteAddr
};
liveRecords.Add(liveRecord);
}
}
result.LiveRecords = liveRecords;
DeserializeGeneric(xmlStream, result);
return(result);
}
public override DeleteObjectVersionsResult Deserialize(ServiceResponse xmlStream)
{
var result = new DeleteObjectVersionsResult();
if (int.Parse(xmlStream.Headers[HttpHeaders.ContentLength]) != 0)
{
var model = ContentDeserializer.Deserialize(xmlStream.Content);
string encodeType = model.EncodingType == null ?
string.Empty : model.EncodingType.ToLowerInvariant();
result.EncodingType = model.EncodingType;
if (model.DeletedObjects != null)
{
foreach (var o in model.DeletedObjects)
{
var summary = new DeletedObjectSummary
{
Key = Decode(o.Key, encodeType),
VersionId = o.VersionId,
DeleteMarker = o.DeleteMarker,
DeleteMarkerVersionId = o.DeleteMarkerVersionId
};
result.AddDeletedObjectSummary(summary);
}
}
}
DeserializeGeneric(xmlStream, result);
return(result);
}
public async Task DeserializeAsync_WithOneAxisAndSomeValuesAndOneValueDifferent_ReturnsTheValuesAsync()
{
var deserializer = new ContentDeserializer();
var header = new HeaderBuilder()
.WithContentDataType(DataContentType.INTEGER)
.WithNumberOfAxis(1)
.WithAxisOfSize(dimensionIndex: 1, size: 10)
.Build();
var dataStream = new ContentStreamBuilder()
.WithDataBeingInitializedWith(123, header)
.WithDataAtCoordinates(
10,
new Dictionary <uint, ulong> {
{ 0, 5 }
},
header)
.Build();
var deserilaizedContent = await deserializer.DeserializeAsync(PipeReader.Create(dataStream), header);
deserilaizedContent.Should().NotBeNull();
deserilaizedContent.Value.ToArray().Should().HaveCount(10);
deserilaizedContent.Value.Span[4].Should().Equals(10);
deserilaizedContent.Value.ToArray().Select((d, i) => (i, d)).Where(d => d.i != 5).All(d => (int)d.d == 123).Should().BeTrue();
}
public override CompleteMultipartUploadResult Deserialize(ServiceResponse xmlStream)
{
var completeMultipartUploadResult = new CompleteMultipartUploadResult();
if (_completeMultipartUploadRequest.IsNeedResponseStream())
{
completeMultipartUploadResult.BucketName = _completeMultipartUploadRequest.BucketName;
completeMultipartUploadResult.Key = _completeMultipartUploadRequest.Key;
completeMultipartUploadResult.ETag = OssUtils.TrimQuotes(xmlStream.Headers[HttpHeaders.ETag]);
completeMultipartUploadResult.ResponseStream = xmlStream.Content;
}
else
{
var result = ContentDeserializer.Deserialize(xmlStream.Content);
completeMultipartUploadResult.BucketName = result.Bucket;
completeMultipartUploadResult.Key = result.Key;
completeMultipartUploadResult.Location = result.Location;
completeMultipartUploadResult.ETag = OssUtils.TrimQuotes(result.ETag);
}
if (xmlStream.Headers.ContainsKey(HttpHeaders.VersionId))
{
completeMultipartUploadResult.VersionId = xmlStream.Headers[HttpHeaders.VersionId];
}
DeserializeGeneric(xmlStream, completeMultipartUploadResult);
return(completeMultipartUploadResult);
}
public override GetObjectTaggingResult Deserialize(ServiceResponse xmlStream)
{
GetObjectTaggingResult result = new GetObjectTaggingResult();
var tagging = ContentDeserializer.Deserialize(xmlStream.Content);
if (tagging.TagSet != null && tagging.TagSet.Tags != null)
{
foreach (var lcc in tagging.TagSet.Tags)
{
var tag = new Tag
{
Key = lcc.Key,
Value = lcc.Value
};
result.Addtag(tag);
}
}
if (xmlStream.Headers.ContainsKey(HttpHeaders.VersionId))
{
result.VersionId = xmlStream.Headers[HttpHeaders.VersionId];
}
DeserializeGeneric(xmlStream, result);
return(result);
}
public override UploadPartCopyResult Deserialize(ServiceResponse xmlStream)
{
var partCopyRequestModel = ContentDeserializer.Deserialize(xmlStream.Content);
var result = new UploadPartCopyResult
{
ETag = OssUtils.TrimQuotes(partCopyRequestModel.ETag),
PartNumber = _partNumber
};
DeserializeGeneric(xmlStream, result);
if (result.ResponseMetadata.ContainsKey(HttpHeaders.HashCrc64Ecma))
{
result.Crc64 = result.ResponseMetadata[HttpHeaders.HashCrc64Ecma];
}
if (xmlStream.Headers.ContainsKey(HttpHeaders.QuotaDeltaSize))
{
result.Length = long.Parse(xmlStream.Headers[HttpHeaders.QuotaDeltaSize]);
}
if (xmlStream.Headers.ContainsKey("x-oss-copy-source-version-id"))
{
result.CopySourceVersionId = xmlStream.Headers["x-oss-copy-source-version-id"];
}
return(result);
}
public override PartListing Deserialize(ServiceResponse xmlStream)
{
var listPartResult = ContentDeserializer.Deserialize(xmlStream.Content);
var partListing = new PartListing
{
BucketName = listPartResult.Bucket,
Key = listPartResult.EncodingType.ToLowerInvariant().Equals(HttpUtils.UrlEncodingType) ? HttpUtils.DecodeUri(listPartResult.Key) : listPartResult.Key,
MaxParts = listPartResult.MaxParts,
NextPartNumberMarker = listPartResult.NextPartNumberMarker.Length == 0 ?
0 : Convert.ToInt32(listPartResult.NextPartNumberMarker),
PartNumberMarker = listPartResult.PartNumberMarker,
UploadId = listPartResult.UploadId,
IsTruncated = listPartResult.IsTruncated
};
if (listPartResult.PartResults != null)
{
foreach (var partResult in listPartResult.PartResults)
{
var part = new Part
{
ETag = partResult.ETag != null?OssUtils.TrimQuotes(partResult.ETag) : string.Empty,
LastModified = partResult.LastModified,
PartNumber = partResult.PartNumber,
Size = partResult.Size
};
partListing.AddPart(part);
}
}
DeserializeGeneric(xmlStream, partListing);
return(partListing);
}
public override GetLiveChannelStatResult Deserialize(ServiceResponse xmlStream)
{
var model = ContentDeserializer.Deserialize(xmlStream.Content);
GetLiveChannelStatResult result = new GetLiveChannelStatResult()
{
Status = model.Status,
ConnectedTime = model.ConnectedTime,
RemoteAddr = model.RemoteAddr
};
if (model.Video != null)
{
result.Width = model.Video.Width;
result.Height = model.Video.Height;
result.FrameRate = model.Video.FrameRate;
result.VideoBandwidth = model.Video.Bandwidth;
result.VideoCodec = model.Video.Codec;
}
if (model.Audio != null)
{
result.SampleRate = model.Audio.SampleRate;
result.AudioBandwidth = model.Audio.Bandwidth;
result.AudioCodec = model.Audio.Codec;
}
DeserializeGeneric(xmlStream, result);
return(result);
}
public override IList <CORSRule> Deserialize(ServiceResponse xmlStream)
{
var model = ContentDeserializer.Deserialize(xmlStream.Content);
IList <CORSRule> corsRuleList = new List <CORSRule>();
foreach (var corsRuleModel in model.CORSRuleModels)
{
var corsRule = new CORSRule();
if (corsRuleModel.AllowedHeaders != null && corsRuleModel.AllowedHeaders.Length > 0)
{
corsRule.AllowedHeaders = ToList(corsRuleModel.AllowedHeaders);
}
if (corsRuleModel.AllowedMethods != null && corsRuleModel.AllowedMethods.Length > 0)
{
corsRule.AllowedMethods = ToList(corsRuleModel.AllowedMethods);
}
if (corsRuleModel.AllowedOrigins != null && corsRuleModel.AllowedOrigins.Length > 0)
{
corsRule.AllowedOrigins = ToList(corsRuleModel.AllowedOrigins);
}
if (corsRuleModel.ExposeHeaders != null && corsRuleModel.ExposeHeaders.Length > 0)
{
corsRule.ExposeHeaders = ToList(corsRuleModel.ExposeHeaders);
}
corsRule.MaxAgeSeconds = corsRuleModel.MaxAgeSeconds;
corsRuleList.Add(corsRule);
}
return(corsRuleList);
}
public override ListBucketsResult Deserialize(ServiceResponse xmlStream)
{
var model = ContentDeserializer.Deserialize(xmlStream.Content);
var result = new ListBucketsResult {
Prefix = model.Prefix, Marker = model.Marker
};
if (model.MaxKeys.HasValue)
{
result.MaxKeys = model.MaxKeys.Value;
}
if (model.IsTruncated.HasValue)
{
result.IsTruncated = model.IsTruncated.Value;
}
result.NextMaker = model.NextMarker;
result.Buckets = model.Buckets.Select(e =>
new Bucket(e.Name)
{
Location = e.Location,
Owner = new Owner(model.Owner.Id, model.Owner.DisplayName),
CreationDate = e.CreationDate
});
return(result);
}
public override T Deserialize(ServiceResponse xmlStream)
{
using (xmlStream.Content)
{
return(ContentDeserializer.Deserialize(xmlStream.Content));
}
}
public override DeleteObjectsResult Deserialize(ServiceResponse xmlStream)
{
if (int.Parse(xmlStream.Headers[HttpHeaders.ContentLength]) == 0)
{
return(new DeleteObjectsResult());
}
return(ContentDeserializer.Deserialize(xmlStream.Content));
}
public override IList <LifecycleRule> Deserialize(ServiceResponse xmlStream)
{
var lifecycleConfig = ContentDeserializer.Deserialize(xmlStream.Content);
var rules = new List <LifecycleRule>();
foreach (var lcc in lifecycleConfig.LifecycleRules)
{
var rule = new LifecycleRule
{
ID = lcc.ID,
Prefix = lcc.Prefix
};
RuleStatus status;
if (TryParseEnum(lcc.Status, out status))
{
rule.Status = status;
}
else
{
throw new InvalidEnumArgumentException(@"Unsupported rule status " + lcc.Status);
}
if (lcc.Expiration.IsSetDays())
{
rule.ExpriationDays = lcc.Expiration.Days;
}
else if (lcc.Expiration.IsSetDate())
{
rule.ExpirationTime = DateTime.Parse(lcc.Expiration.Date).ToUniversalTime();
}
else if (!String.IsNullOrEmpty(lcc.Expiration.CreatedBeforeDate))
{
rule.CreatedBeforeDate = DateTime.Parse(lcc.Expiration.CreatedBeforeDate).ToUniversalTime();
}
if (lcc.AbortMultipartUpload != null)
{
rule.AbortMultipartUpload = new LifecycleRule.LifeCycleExpiration();
ConvertExpiration(lcc.AbortMultipartUpload, rule.AbortMultipartUpload);
}
if (lcc.Transition != null)
{
rule.Transitions = new LifecycleRule.LifeCycleTransition[lcc.Transition.Length];
for (int i = 0; i < rule.Transitions.Length; i++)
{
rule.Transitions[i] = new LifecycleRule.LifeCycleTransition();
ConvertTransition(lcc.Transition[i], rule.Transitions[i]);
}
}
rules.Add(rule);
}
return(rules);
}
public override BucketLoggingResult Deserialize(ServiceResponse xmlStream)
{
var model = ContentDeserializer.Deserialize(xmlStream.Content);
return(new BucketLoggingResult
{
TargetBucket = model.LoggingEnabled.TargetBucket,
TargetPrefix = model.LoggingEnabled.TargetPrefix
});
}
public override BucketWebsiteResult Deserialize(ServiceResponse xmlStream)
{
var model = ContentDeserializer.Deserialize(xmlStream.Content);
return(new BucketWebsiteResult
{
IndexDocument = model.IndexDocument.Suffix,
ErrorDocument = model.ErrorDocument.Key
});
}
public override CopyObjectResult Deserialize(ServiceResponse xmlStream)
{
var result = ContentDeserializer.Deserialize(xmlStream.Content);
return(new CopyObjectResult
{
ETag = OssUtils.TrimQuotes(result.ETag),
LastModified = result.LastModified
});
}
public override ListLiveChannelResult Deserialize(ServiceResponse xmlStream)
{
var model = ContentDeserializer.Deserialize(xmlStream.Content);
var result = new ListLiveChannelResult
{
Prefix = model.Prefix,
Marker = model.Marker
};
if (model.MaxKeys.HasValue)
{
result.MaxKeys = model.MaxKeys.Value;
}
if (model.IsTruncated.HasValue)
{
result.IsTruncated = model.IsTruncated.Value;
}
result.NextMarker = model.NextMarker;
var liveChannels = new List <LiveChannel>();
if (model.LiveChannels != null)
{
foreach (var e in model.LiveChannels)
{
var liveChannel = new LiveChannel()
{
Name = e.Name,
Description = e.Description,
Status = e.Status,
LastModified = e.LastModified
};
if (e.PublishUrls != null)
{
liveChannel.PublishUrl = e.PublishUrls.Url;
}
if (e.PlayUrls != null)
{
liveChannel.PlayUrl = e.PlayUrls.Url;
}
liveChannels.Add(liveChannel);
}
}
result.LiveChannels = liveChannels;
DeserializeGeneric(xmlStream, result);
return(result);
}
public override InitiateMultipartUploadResult Deserialize(ServiceResponse xmlStream)
{
var result = ContentDeserializer.Deserialize(xmlStream.Content);
return(new InitiateMultipartUploadResult
{
BucketName = result.Bucket,
Key = result.Key,
UploadId = result.UploadId
});
}
public override UploadPartCopyResult Deserialize(ServiceResponse xmlStream)
{
var partCopyRequestModel = ContentDeserializer.Deserialize(xmlStream.Content);
var result = new UploadPartCopyResult
{
ETag = OssUtils.TrimQuotes(partCopyRequestModel.ETag),
PartNumber = _partNumber
};
return(result);
}
public override GetBucketRequestPaymentResult Deserialize(ServiceResponse xmlStream)
{
GetBucketRequestPaymentResult result = new GetBucketRequestPaymentResult();
var mode = ContentDeserializer.Deserialize(xmlStream.Content);
result.Payer = mode.Payer;
this.DeserializeGeneric(xmlStream, result);
return(result);
}
public override BucketEncryptionResult Deserialize(ServiceResponse xmlStream)
{
var result = new BucketEncryptionResult();
var mode = ContentDeserializer.Deserialize(xmlStream.Content);
result.SSEAlgorithm = mode.ApplyServerSideEncryptionByDefault.SSEAlgorithm;
result.KMSMasterKeyID = mode.ApplyServerSideEncryptionByDefault.KMSMasterKeyID;
this.DeserializeGeneric(xmlStream, result);
return(result);
}
public override ObjectListing Deserialize(ServiceResponse xmlStream)
{
var listBucketResult = ContentDeserializer.Deserialize(xmlStream.Content);
string encodeType = listBucketResult.EncodingType == null ?
string.Empty : listBucketResult.EncodingType.ToLowerInvariant();
var objectList = new ObjectListing(listBucketResult.Name)
{
Delimiter = Decode(listBucketResult.Delimiter, encodeType),
IsTruncated = listBucketResult.IsTruncated,
Marker = Decode(listBucketResult.Marker, encodeType),
MaxKeys = listBucketResult.MaxKeys,
NextMarker = Decode(listBucketResult.NextMarker, encodeType),
Prefix = Decode(listBucketResult.Prefix, encodeType)
};
if (listBucketResult.Contents != null)
{
foreach (var contents in listBucketResult.Contents)
{
var summary = new OssObjectSummary
{
BucketName = listBucketResult.Name,
Key = Decode(contents.Key, encodeType),
LastModified = contents.LastModified,
ETag = contents.ETag != null?OssUtils.TrimQuotes(contents.ETag) : string.Empty,
Size = contents.Size,
StorageClass = contents.StorageClass,
Owner = contents.Owner != null ?
new Owner(contents.Owner.Id, contents.Owner.DisplayName) : null
};
objectList.AddObjectSummary(summary);
}
}
if (listBucketResult.CommonPrefixes != null)
{
foreach (var commonPrefixes in listBucketResult.CommonPrefixes)
{
if (commonPrefixes.Prefix != null)
{
foreach (var prefix in commonPrefixes.Prefix)
{
objectList.AddCommonPrefix(Decode(prefix, encodeType));
}
}
}
}
DeserializeGeneric(xmlStream, objectList);
return(objectList);
}
public override CompleteMultipartUploadResult Deserialize(ServiceResponse xmlStream)
{
var result = ContentDeserializer.Deserialize(xmlStream.Content);
return(new CompleteMultipartUploadResult
{
BucketName = result.Bucket,
Key = result.Key,
Location = result.Location,
ETag = OssUtils.TrimQuotes(result.ETag)
});
}
public override GetBucketInventoryConfigurationResult Deserialize(ServiceResponse xmlStream)
{
var model = ContentDeserializer.Deserialize(xmlStream.Content);
var result = new GetBucketInventoryConfigurationResult
{
Configuration = ToInventoryConfiguration(model)
};
DeserializeGeneric(xmlStream, result);
return(result);
}
public override GetBucketStorageCapacityResult Deserialize(ServiceResponse xmlStream)
{
var model = ContentDeserializer.Deserialize(xmlStream.Content);
var getBucketStorageCapacityResult = new GetBucketStorageCapacityResult
{
StorageCapacity = model.StorageCapacity
};
DeserializeGeneric(xmlStream, getBucketStorageCapacityResult);
return(getBucketStorageCapacityResult);
}
public override GetBucketWormResult Deserialize(ServiceResponse xmlStream)
{
GetBucketWormResult result = new GetBucketWormResult();
var mode = ContentDeserializer.Deserialize(xmlStream.Content);
result.WormId = mode.WormId;
result.State = mode.State;
result.RetentionPeriodInDays = mode.Days;
result.CreationDate = mode.CreationDate;
this.DeserializeGeneric(xmlStream, result);
return(result);
}
public async Task <User> FindByNameAsync(string normalizedUserName, CancellationToken cancellationToken)
{
var document = (await DocumentFinder.Find(Container).WhereEquals <User, string>(u => u.NormalizedUsername, normalizedUserName).GetResultAsync()).FirstOrDefault();
if (document == null)
{
return(null);
}
var content = ContentDeserializer.Deserialize(document, ContentType, null) as User;
return(content);
}
public override InitiateMultipartUploadResult Deserialize(ServiceResponse xmlStream)
{
var result = ContentDeserializer.Deserialize(xmlStream.Content);
string encodeType = result.EncodingType == null ?
string.Empty : result.EncodingType.ToLowerInvariant();
return(new InitiateMultipartUploadResult
{
BucketName = result.Bucket,
Key = Decode(result.Key, encodeType),
UploadId = result.UploadId
});
}
public override DeleteObjectsResult Deserialize(ServiceResponse xmlStream)
{
var deleteObjectsResult = new DeleteObjectsResult();
if (int.Parse(xmlStream.Headers[HttpHeaders.ContentLength]) != 0)
{
deleteObjectsResult = ContentDeserializer.Deserialize(xmlStream.Content);
}
DeserializeGeneric(xmlStream, deleteObjectsResult);
return(deleteObjectsResult);
}
