public ObjectMetadata Deserialize(HttpResponseMessage response)
{
ObjectMetadata metadata = new ObjectMetadata();
foreach (KeyValuePair <string, IEnumerable <string> > header in response.Headers)
{
if (header.Key.StartsWith("x-oss-meta-", false, CultureInfo.InvariantCulture))
{
metadata.UserMetadata.Add(header.Key.Substring("x-oss-meta-".Length), header.Value.First());
}
else
{
if (string.Equals(header.Key, "Content-Length", StringComparison.InvariantCultureIgnoreCase))
{
metadata.ContentLength = long.Parse(header.Value.First(), CultureInfo.InvariantCulture);
continue;
}
if (string.Equals(header.Key, "ETag", StringComparison.InvariantCultureIgnoreCase))
{
metadata.ETag = OssUtils.TrimETag(header.Value.First());
continue;
}
if (string.Equals(header.Key, "Last-Modified", StringComparison.InvariantCultureIgnoreCase))
{
metadata.LastModified = DateUtils.ParseRfc822Date(header.Value.First());
continue;
}
metadata.AddHeader(header.Key, header.Value);
}
}
return(metadata);
}
public static bool Upload(string bucketName, string fileName, string fileToUpload)
{
bool success = false;
try
{
if (!DoesBucketExist(bucketName))
{
if (!CreateBucket(bucketName))
{
return(success);
}
}
string eTag;
using (var fs = File.Open(fileToUpload, FileMode.Open))
{
eTag = OssUtils.ComputeContentMd5(fs, fs.Length);
}
var objectMeta = new ObjectMetadata {
ETag = eTag
};
var result = ossClient.PutObject(bucketName, fileName, fileToUpload, objectMeta);
success = true;
}
catch (Exception ex)
{
Console.WriteLine("Put object failed, {0}", ex.Message);
}
return(success);
}
private ObjectMetadata Deserialize(HttpResponseMessage response)
{
var metadata = new ObjectMetadata();
foreach (var header in response.Headers)
{
if (header.Key.StartsWith(OssHeaders.OssUserMetaPrefix, false, CultureInfo.InvariantCulture))
{
// The key of user in the metadata should not contain the prefix.
metadata.UserMetadata.Add(header.Key.Substring(OssHeaders.OssUserMetaPrefix.Length),
header.Value.FirstOrDefault());
}
else if (string.Equals(header.Key, HttpHeaders.ContentLength, StringComparison.InvariantCultureIgnoreCase))
{
// Content-Length. Parse should not fail.
metadata.ContentLength = long.Parse(header.Value.FirstOrDefault(), CultureInfo.InvariantCulture);
}
else if (string.Equals(header.Key, HttpHeaders.ETag, StringComparison.InvariantCultureIgnoreCase))
{
metadata.ETag = OssUtils.TrimETag(header.Value.FirstOrDefault());
}
else if (string.Equals(header.Key, HttpHeaders.LastModified, StringComparison.InvariantCultureIgnoreCase))
{
metadata.LastModified = DateUtils.ParseRfc822Date(header.Value.FirstOrDefault());
}
else
{
// Treat the other headers just as strings.
metadata.AddHeader(header.Key, header.Value);
}
}
return(metadata);
}
private void uploadFile()
{
//上传文件
if (selectedFile == null)
{
MessageBox.Show("不存在的文件，请重新选择", "提示", MessageBoxButtons.OK);
}
buttonUpload.Enabled = false;
buttonChoiceFile.Enabled = false;
string path = OssContants.OSSPATH[comboBox1.Text] != null ? OssContants.OSSPATH[comboBox1.Text].ToString() : "";
string res = OssUtils.upload(path, selectedFile);
if (res != null)
{
res = OssConfig.BucketDomain + res;
Logger.Instance.Info(res);
processControl1.complete();
MessageBox.Show("上传成功！点击确认后自动复制到剪切板", "上传结果", MessageBoxButtons.OK);
Clipboard.SetText(res);
//清空已经上传的选择文件，防止重复上传
buttonUpload.Enabled = false;
selectedFile = null;
}
else
{
MessageBox.Show("上传失败！请查看失败原因进行重试，多次失败请联系管理员", "上传结果", MessageBoxButtons.OK);
}
buttonChoiceFile.Enabled = true;
}
private DeleteBucketWebsiteCommand(IServiceClient client, Uri endpoint, ExecutionContext context,
string bucketName)
: base(client, endpoint, context)
{
OssUtils.CheckBucketName(bucketName);
_bucketName = bucketName;
}
private DeleteBucketInventoryConfigurationCommand(IServiceClient client, Uri endpoint, ExecutionContext context,
DeleteBucketInventoryConfigurationRequest request)
: base(client, endpoint, context)
{
OssUtils.CheckBucketName(request.BucketName);
_request = request;
}
private CompleteBucketWormCommand(IServiceClient client, Uri endpoint, ExecutionContext context,
CompleteBucketWormRequest request)
: base(client, endpoint, context)
{
OssUtils.CheckBucketName(request.BucketName);
_request = request;
}
/// <summary>
/// Populate the http headers according to the properties of this object.
/// </summary>
/// <param name="headers">The generated http headers</param>
internal void Populate(IDictionary <string, string> headers)
{
if (ModifiedSinceConstraint != null)
{
headers.Add(OssHeaders.GetObjectIfModifiedSince,
DateUtils.FormatRfc822Date(ModifiedSinceConstraint.Value));
}
if (UnmodifiedSinceConstraint != null)
{
headers.Add(OssHeaders.GetObjectIfUnmodifiedSince,
DateUtils.FormatRfc822Date(UnmodifiedSinceConstraint.Value));
}
if (_matchingETagConstraints.Count > 0)
{
headers.Add(OssHeaders.GetObjectIfMatch,
OssUtils.JoinETag(_matchingETagConstraints));
}
if (_nonmatchingEtagConstraints.Count > 0)
{
headers.Add(OssHeaders.GetObjectIfNoneMatch,
OssUtils.JoinETag(_nonmatchingEtagConstraints));
}
if (RequestPayer == RequestPayer.Requester)
{
headers.Add(OssHeaders.OssRequestPayer,
RequestPayer.Requester.ToString().ToLowerInvariant());
}
}
public static void AsyncPutObject(string bucketName, string filename, Action <string> putCallback = null)
{
CreateDispatcherGameObject();
try
{
var fs = new FileStream(filename, FileMode.Open);
string md5 = OssUtils.ComputeContentMd5(fs, fs.Length);
var ossClient = new OssClient(endPoint, stsToken.AccessKeyId, stsToken.AccessKeySecret, stsToken.SecurityToken);
var metadata = new ObjectMetadata();
metadata.ContentLength = fs.Length;
metadata.CacheControl = "public";
metadata.ContentMd5 = md5;
var filemd5 = Utils.File.FormatMD5(Convert.FromBase64String(md5));
string ext = System.IO.Path.GetExtension(filename);
var ossFileName = filemd5 + ext;
Hashtable state = new Hashtable();
state["client"] = ossClient;
state["fs"] = fs;
state["callback"] = putCallback;
state["ossfilename"] = ossFileName;
ossClient.BeginPutObject(bucketName, ossFileName, fs, metadata, PutObjectCallback, state);
// _event.WaitOne();
}
catch (OssException ex)
{
Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
if (putCallback != null)
{
if (ex is OssException)
{
putCallback(((OssException)ex).ErrorCode);
}
else
{
putCallback(ex.Message);
}
}
}
catch (Exception ex)
{
Console.WriteLine("Failed with error info: {0}", ex.Message);
if (putCallback != null)
{
if (ex is ServiceException)
{
putCallback(((ServiceException)ex).ErrorCode);
}
else
{
putCallback(ex.Message);
}
}
}
}
public string UploadFile(Stream file)
{
var key = OssUtils.ComputeContentMd5(file, file.Length);
file.Seek(0, SeekOrigin.Begin);
return(this.client.PutObject(bucketName, key, file).ETag);
}
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 static UploadPartCommand Create(IServiceClient client, Uri endpoint, ExecutionContext context,
UploadPartRequest uploadPartRequest)
{
OssUtils.CheckBucketName(uploadPartRequest.BucketName);
OssUtils.CheckObjectKey(uploadPartRequest.Key);
if (string.IsNullOrEmpty(uploadPartRequest.UploadId))
{
throw new ArgumentException("uploadId should be specified");
}
if (!uploadPartRequest.PartNumber.HasValue)
{
throw new ArgumentException("partNumber should be specified");
}
if (!uploadPartRequest.PartSize.HasValue)
{
throw new ArgumentException("partSize should be specified");
}
if (uploadPartRequest.InputStream == null)
{
throw new ArgumentException("inputStream should be specified");
}
if (uploadPartRequest.PartSize < 0 || uploadPartRequest.PartSize > OssUtils.MaxFileSize)
{
throw new ArgumentException("partSize not live in valid range");
}
if (!OssUtils.IsPartNumberInRange(uploadPartRequest.PartNumber))
{
throw new ArgumentException("partNumber not live in valid range");
}
var conf = OssUtils.GetClientConfiguration(client);
var originalStream = uploadPartRequest.InputStream;
var streamLength = uploadPartRequest.PartSize.Value;
// wrap input stream in PartialWrapperStream
originalStream = new PartialWrapperStream(originalStream, streamLength);
// setup progress
var callback = uploadPartRequest.StreamTransferProgress;
if (callback != null)
{
originalStream = OssUtils.SetupProgressListeners(originalStream, conf.ProgressUpdateInterval, client, callback);
uploadPartRequest.InputStream = originalStream;
}
// wrap input stream in MD5Stream
if (conf.EnalbeMD5Check)
{
var hashStream = new MD5Stream(originalStream, null, streamLength);
uploadPartRequest.InputStream = hashStream;
context.ResponseHandlers.Add(new MD5DigestCheckHandler(hashStream));
}
return(new UploadPartCommand(client, endpoint, context,
DeserializerFactory.GetFactory().CreateUploadPartResultDeserializer(uploadPartRequest.PartNumber.Value),
uploadPartRequest));
}
public static PostVodPlaylistCommand Create(IServiceClient client, Uri endpoint,
ExecutionContext context,
PostVodPlaylistRequest request)
{
OssUtils.CheckBucketName(request.BucketName);
return(new PostVodPlaylistCommand(client, endpoint, context, request));
}
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);
}
private GetBucketLoggingCommand(IServiceClient client, Uri endpoint, ExecutionContext context,
string bucketName, IDeserializer <ServiceResponse, BucketLoggingResult> deserializer)
: base(client, endpoint, context, deserializer)
{
OssUtils.CheckBucketName(bucketName);
_bucketName = bucketName;
}
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);
}
/// <summary>
/// 文件上传阿里云
/// </summary>
/// <param name="workDir"></param>
/// <param name="path"></param>
/// <returns></returns>
public bool uploadFile(string workDir, string path)
{
string localPath = workDir + "/" + path;
try
{
var fi = new FileInfo(localPath);
long fileSize = fi.Length;
if (fileSize > m_multiSize)
{
return(uploadMulti(localPath, path, fileSize));
}
else
{
string md5;
using (var fs = File.Open(localPath, FileMode.Open, FileAccess.Read))
{
md5 = OssUtils.ComputeContentMd5(fs, fs.Length);//md5效验
}
return(uploadSingle(localPath, path, md5));
}
}
catch (Exception ex)
{
Console.WriteLine("获取文件信息错误：" + ex.Message);
return(false);
}
}
public static UploadPartCopyCommand Create(IServiceClient client, Uri endpoint, ExecutionContext context,
UploadPartCopyRequest uploadPartCopyRequest)
{
OssUtils.CheckBucketName(uploadPartCopyRequest.SourceBucket);
OssUtils.CheckObjectKey(uploadPartCopyRequest.SourceKey);
OssUtils.CheckBucketName(uploadPartCopyRequest.TargetBucket);
OssUtils.CheckObjectKey(uploadPartCopyRequest.TargetKey);
if (!uploadPartCopyRequest.PartNumber.HasValue)
{
throw new ArgumentException("partNumber should be specfied");
}
if (!uploadPartCopyRequest.PartSize.HasValue)
{
throw new ArgumentException("partSize should be specfied");
}
if (!uploadPartCopyRequest.BeginIndex.HasValue)
{
throw new ArgumentException("beginIndex should be specfied");
}
if (uploadPartCopyRequest.PartSize < 0 || uploadPartCopyRequest.PartSize > OssUtils.MaxFileSize)
{
throw new ArgumentException("partSize not live in valid range");
}
if (!OssUtils.IsPartNumberInRange(uploadPartCopyRequest.PartNumber))
{
throw new ArgumentException("partNumber not live in valid range");
}
return(new UploadPartCopyCommand(client, endpoint, context,
DeserializerFactory.GetFactory().CreateUploadPartCopyResultDeserializer(uploadPartCopyRequest.PartNumber.Value),
uploadPartCopyRequest));
}
public static DeleteLiveChannelCommand Create(IServiceClient client, Uri endpoint,
ExecutionContext context,
DeleteLiveChannelRequest request)
{
OssUtils.CheckBucketName(request.BucketName);
return(new DeleteLiveChannelCommand(client, endpoint, context, request));
}
public static CompleteMultipartUploadCommand Create(IServiceClient client, Uri endpoint, ExecutionContext context,
CompleteMultipartUploadRequest completeMultipartUploadRequest)
{
OssUtils.CheckBucketName(completeMultipartUploadRequest.BucketName);
OssUtils.CheckObjectKey(completeMultipartUploadRequest.Key);
if (string.IsNullOrEmpty(completeMultipartUploadRequest.UploadId))
{
throw new ArgumentException("The parameter is empty or null.", "uploadId");
}
// handle upload callback error 203
if (completeMultipartUploadRequest.IsCallbackRequest())
{
context.ResponseHandlers.Add(new CallbackResponseHandler());
}
var conf = OssUtils.GetClientConfiguration(client);
if (conf.EnableCrcCheck)
{
context.ResponseHandlers.Add(new CompleteMultipartUploadCrc64Handler(completeMultipartUploadRequest));
}
return(new CompleteMultipartUploadCommand(client, endpoint, context,
DeserializerFactory.GetFactory().CreateCompleteUploadResultDeserializer(completeMultipartUploadRequest),
completeMultipartUploadRequest));
}
private GetBucketLifecycleCommand(IServiceClient client, Uri endpoint, ExecutionContext context,
string bucketName, IDeserializer <ServiceResponse, IList <LifecycleRule> > deserializer)
: base(client, endpoint, context, deserializer)
{
OssUtils.CheckBucketName(bucketName);
_bucketName = bucketName;
}
public override AppendObjectResult Deserialize(ServiceResponse xmlStream)
{
var result = new AppendObjectResult();
if (xmlStream.Headers.ContainsKey(HttpHeaders.ETag))
{
result.ETag = OssUtils.TrimQuotes(xmlStream.Headers[HttpHeaders.ETag]);
}
if (xmlStream.Headers.ContainsKey(HttpHeaders.NextAppendPosition))
{
result.NextAppendPosition = long.Parse(xmlStream.Headers[HttpHeaders.NextAppendPosition]);
}
if (xmlStream.Headers.ContainsKey(HttpHeaders.HashCrc64Ecma))
{
result.HashCrc64Ecma = ulong.Parse(xmlStream.Headers[HttpHeaders.HashCrc64Ecma]);
}
if (xmlStream.Headers.ContainsKey(HttpHeaders.VersionId))
{
result.VersionId = xmlStream.Headers[HttpHeaders.VersionId];
}
DeserializeGeneric(xmlStream, result);
return(result);
}
/// <inheritdoc/>
public bool DoesBucketExist(string bucketName)
{
if (string.IsNullOrEmpty(bucketName))
{
throw new ArgumentException(Resources.ExceptionIfArgumentStringIsNullOrEmpty, "bucketName");
}
if (!OssUtils.IsBucketNameValid(bucketName))
{
throw new ArgumentException(Resources.BucketNameInvalid, "bucketName");
}
try
{
GetBucketAcl(bucketName);
}
catch (OssException e)
{
if (e.ErrorCode.Equals(OssErrorCode.NoSuchBucket))
{
return(false);
}
}
return(true);
}
private ServiceRequest BuildRequest()
{
var conf = OssUtils.GetClientConfiguration(Client);
var request = new ServiceRequest
{
Method = Method,
Endpoint = OssUtils.MakeBucketEndpoint(Endpoint, Bucket, conf),
ResourcePath = OssUtils.MakeResourcePath(Key)
};
foreach (var p in Parameters)
{
request.Parameters.Add(p.Key, p.Value);
}
var adjustedTime = DateTime.UtcNow.AddSeconds(conf.TickOffset);
request.Headers[HttpHeaders.Date] = DateUtils.FormatRfc822Date(adjustedTime);
if (!Headers.ContainsKey(HttpHeaders.ContentType))
{
request.Headers[HttpHeaders.ContentType] = string.Empty;
}
foreach (var h in Headers)
{
request.Headers.Add(h.Key, h.Value);
}
if (Context.Credentials.UseToken)
{
request.Headers[HttpHeaders.SecurityToken] = Context.Credentials.SecurityToken;
}
request.Content = Content;
return(request);
}
public static void PutObjectWithMd5(string bucketName)
{
const string key = "PutObjectWithMd5";
string md5;
using (var fs = File.Open(fileToUpload, FileMode.Open))
{
md5 = OssUtils.ComputeContentMd5(fs, fs.Length);
}
var meta = new ObjectMetadata()
{
ContentMd5 = md5
};
try
{
client.PutObject(bucketName, key, fileToUpload, meta);
Console.WriteLine("Put object:{0} succeeded", key);
}
catch (OssException ex)
{
Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
}
catch (Exception ex)
{
Console.WriteLine("Failed with error info: {0}", ex.Message);
}
}
/// <summary>
/// 获取OSS key
/// </summary>
/// <param name="files">上传文件的流信息</param>
/// <param name="absolutely_address">存放的绝对路径</param>
/// <param name="webRootPath">系统初始化路径</param>
/// <param name="result_number">返回执行失败的错误码</param>
/// <param name="tagId">图片分类ID</param>
/// <returns></returns>
public static Dictionary <String, String> GetOSSKey(IFormFile file, string absolutely_address, string webRootPath, String file_name)
{
//读取图片名称和图片后缀
string extension = new FileInfo(file_name).Extension.ToLower();
//复制图片到本地临时文件夹
file_name = CommonUtil.ReadDateTime() + file.Length + extension;
var fileToUpload = webRootPath + absolutely_address + file_name;
using (FileStream fs = File.Create(fileToUpload))
{
file.CopyTo(fs);
fs.Flush();
}
//MD5获取素材key值
string md5;
using (var fs = File.Open(fileToUpload, FileMode.Open))
{
md5 = OssUtils.ComputeContentMd5(fs, fs.Length);
}
var key = md5.Replace("/", "@") + extension;
// File.Delete(fileToUpload);
Dictionary <String, String> map = new Dictionary <String, String>();
map.Add("filePath", fileToUpload);
map.Add("fileKey", key);
return(map);
}
private SetBucketEncryptionCommand(IServiceClient client, Uri endpoint, ExecutionContext context,
SetBucketEncryptionRequest request)
: base(client, endpoint, context)
{
OssUtils.CheckBucketName(request.BucketName);
_request = request;
}
/// <summary>
/// Creates an instance with bucket name, keys and quiet flag.
/// </summary>
/// <param name="bucketName">bucket name</param>
/// <param name="keys">object keys to delete</param>
/// <param name="quiet">true: quiet mode; false: detail mode</param>
public DeleteObjectsRequest(string bucketName, IList <string> keys, bool quiet)
{
if (keys == null)
{
throw new ArgumentException("The list of keys to be deleted should not be null");
}
if (keys.Count <= 0)
{
throw new ArgumentException("No any keys specified.");
}
if (keys.Count > OssUtils.DeleteObjectsUpperLimit)
{
throw new ArgumentException("Count of objects to be deleted exceeds upper limit");
}
BucketName = bucketName;
foreach (var key in keys)
{
OssUtils.CheckObjectKey(key);
Keys.Add(key);
}
Quiet = quiet;
}
public async Task SaveBlobStreamAsync(string containerName, string blobName, Stream source, BlobProperties properties = null)
{
try
{
await Task.Run(() =>
{
var exist = _ossClient.DoesBucketExist(containerName);
if (!exist)
{
_ossClient.CreateBucket(containerName);
}
var md5 = OssUtils.ComputeContentMd5(source, source.Length);
var objectMeta = new ObjectMetadata();
objectMeta.AddHeader("Content-MD5", md5);
objectMeta.UserMetadata.Add("Content-MD5", md5);
if (properties != null)
{
objectMeta.ContentType = properties.ContentType;
}
_ossClient.PutObject(containerName, blobName, source, objectMeta);
});
}
catch (Exception ex)
{
if (ex.IsOssStorageException())
{
throw ex.Convert();
}
throw;
}
}
public DefaultCredentials(string accessId, string accessKey, string securityToken)
{
OssUtils.CheckCredentials(accessId, accessKey);
AccessId = accessId;
AccessKey = accessKey;
SecurityToken = securityToken ?? string.Empty;
}
