public MimePartResponseMessage(HttpRequestMessage requestMessage, IMimeContent contentObject)
{
_tempFilePath = Path.GetTempFileName();
RequestMessage = requestMessage;
using (var tempFile = File.OpenWrite(_tempFilePath))
{
contentObject.DecodeTo(tempFile);
}
Content = new StreamContent(File.OpenRead(_tempFilePath));
}
/// <summary>
/// Initializes a new instance of the <see cref="MimeKit.MimePart"/> class
/// with the specified media type and subtype.
/// </summary>
/// <remarks>
/// Creates a new <see cref="MimePart"/> with the specified media type and subtype.
/// </remarks>
/// <param name="mediaType">The media type.</param>
/// <param name="mediaSubtype">The media subtype.</param>
/// <param name="args">An array of initialization parameters: headers and part content.</param>
/// <exception cref="System.ArgumentNullException">
/// <para><paramref name="mediaType"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="mediaSubtype"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="args"/> is <c>null</c>.</para>
/// </exception>
/// <exception cref="System.ArgumentException">
/// <para><paramref name="args"/> contains more than one <see cref="MimeKit.IMimeContent"/> or
/// <see cref="System.IO.Stream"/>.</para>
/// <para>-or-</para>
/// <para><paramref name="args"/> contains one or more arguments of an unknown type.</para>
/// </exception>
public MimePart(string mediaType, string mediaSubtype, params object[] args) : this(mediaType, mediaSubtype)
{
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
IMimeContent content = null;
foreach (object obj in args)
{
if (obj == null || TryInit(obj))
{
continue;
}
var co = obj as IMimeContent;
if (co != null)
{
if (content != null)
{
throw new ArgumentException("ContentObject should not be specified more than once.");
}
content = co;
continue;
}
var stream = obj as Stream;
if (stream != null)
{
if (content != null)
{
throw new ArgumentException("Stream (used as content) should not be specified more than once.");
}
// Use default as specified by ContentObject ctor when building a new MimePart.
content = new MimeContent(stream);
continue;
}
throw new ArgumentException("Unknown initialization parameter: " + obj.GetType());
}
if (content != null)
{
Content = content;
}
}
public static void SavePvReport(string reportFileName, IMimeContent reportMimeContent)
{
var subDirectory = CheckPvReportType(reportFileName);
var directory = Path.Combine(PvReportRepositoryPath, subDirectory);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
using (var fs = new FileStream(Path.Combine(directory, reportFileName), FileMode.Create))
{
reportMimeContent.DecodeTo(fs);
}
}
public SaveResult downloadAttachment(IMimeContent content, string fileName)
{
FileStream stream = null;
var log = log0(fileName, content);
var logE = logE0(fileName, content);
var absoluteFileName = Path.Combine(
assertDirectoryExists(Path.Combine(this.downloadFolder)),
fileName);
try
{
stream = File.Open(absoluteFileName, FileMode.Create);
content.DecodeTo(stream);
log("+");
return(SaveResult.Ok);
}
catch (NullReferenceException nre)
{
log("-");
logE("Failed to write attachment to file. (filename = {0}) {2}", nre);
}
catch (NotSupportedException nse)
{
log("-");
logE("The specified filename ({0}) is not valid on this filesystem. {2}", nse);
}
catch (IOException)
{
log("="); // file already exists
}
finally
{
try
{
if (stream != null)
{
stream.Close();
}
}
catch (Exception)
{
//ignore
}
}
return(SaveResult.Error);
}
private MimePart CreateMimePart(string mediaType, string mediaSubtype, string filename, params Header[] headers)
{
var contentType = new MimeKit.ContentType(mediaType, mediaSubtype);
IMimeContent contentObject = A.Fake <IMimeContent>();
A.CallTo(() => contentObject.Stream).Returns(new MemoryStream());
MimePart mimePart = new MimePart(contentType)
{
FileName = filename,
Content = contentObject
};
foreach (Header header in headers)
{
mimePart.Headers.Add(header);
}
return(mimePart);
}
private void ParseBodyParts(IEnumerable <MimeEntity> bodys, string imgFolder, ref List <string> imgList, ref List <string> imgSourceList)
{
int flag = 0;
try
{
foreach (MimeEntity entity in bodys)
{
flag++;
ContentType type = entity.ContentType;
string mediaType = type.MediaType;
string mimeType = type.MimeType;
if (mediaType != "image")
{
continue;
}
MimePart part = entity as MimePart;
string fileName = part.FileName;
IMimeContent content = part.Content;
string postfix = "";
MemoryStream stream = new MemoryStream();
content.WriteTo(stream);
stream.Position = 0;
StreamReader reader = new StreamReader(stream, Encoding.UTF8);
string Base64Text = reader.ReadToEnd();
imgSourceList.Add(Base64Text);
if (imgFolder != null && imgFolder != "")
{
byte[] arr2 = Convert.FromBase64String(Base64Text);
using (MemoryStream ms2 = new MemoryStream(arr2))
{
ImageFormat format = ImageFormat.Jpeg;
Bitmap bmp2 = new Bitmap(ms2);
switch (mimeType)
{
case "image/gif":
{
format = ImageFormat.Gif;
postfix = ".gif";
break;
}
case "image/x-ms-bmp":
{
format = ImageFormat.Bmp;
postfix = ".bmp";
break;
}
case "image/x-png":
{
format = ImageFormat.Png;
postfix = ".png";
break;
}
case "image/jpeg":
{
format = ImageFormat.Jpeg;
postfix = ".jpeg";
break;
}
default:
{
break;
}
}
DateTime time = DateTime.Now;
string filename = time.ToString("yyyyMMddHHmmssms");
string filepath = imgFolder + "\\" + filename + flag + postfix;
bmp2.Save(filepath, format);
imgList.Add(filepath);
bmp2.Dispose();
}
}
}
}
catch (Exception e)
{
throw e;
}
}
