internal WebImage Save(HttpContextBase context, Action <string, byte[]> saveAction, string filePath, string imageFormat, bool forceWellKnownExtension)
{
filePath = filePath ?? FileName;
if (String.IsNullOrEmpty(filePath))
{
throw new ArgumentNullException("filePath", CommonResources.Argument_Cannot_Be_Null_Or_Empty);
}
// GetBytes takes care of executing pending transformations.
// todo: this could be made more efficient by avoiding cloning array
// when format is same
byte[] content = GetBytes(imageFormat);
if (forceWellKnownExtension)
{
ImageFormat saveImageFormat;
ImageFormat requestedImageFormat = String.IsNullOrEmpty(imageFormat) ? _initialFormat : GetImageFormat(imageFormat);
var extension = Path.GetExtension(filePath).TrimStart('.');
// TryFromStringToImageFormat accepts mime types and image names. For images supported by System.Drawing.Imaging, the image name maps to the extension.
// Replace the extension with the current format in the following two events:
// * The extension format cannot be converted to a known format
// * The format does not match.
if (!ConversionUtil.TryFromStringToImageFormat(extension, out saveImageFormat) || !saveImageFormat.Equals(requestedImageFormat))
{
extension = requestedImageFormat.ToString().ToLowerInvariant();
filePath = filePath + "." + extension;
}
}
saveAction(VirtualPathUtil.MapPath(context, filePath), content);
// Update the FileName since it may have changed whilst saving.
FileName = filePath;
return(this);
}
internal static WebImage GetImageFromRequest(HttpRequestBase request, string postedFileName = null)
{
Debug.Assert(request != null);
if ((request.Files == null) || (request.Files.Count == 0))
{
return(null);
}
HttpPostedFileBase file = String.IsNullOrEmpty(postedFileName) ? request.Files[0] : request.Files[postedFileName];
if (file == null || file.ContentLength < 1)
{
return(null);
}
// The content type is specified by the browser and is unreliable.
// Disregard content type, acquire mime type.
ImageFormat format;
string mimeType = MimeMapping.GetMimeMapping(file.FileName);
if (!ConversionUtil.TryFromStringToImageFormat(mimeType, out format))
{
// Unsupported image format.
return(null);
}
WebImage webImage = new WebImage(file.InputStream);
webImage.FileName = file.FileName;
return(webImage);
}
public static void Send(string to,
string subject,
string body,
string from = null,
string cc = null,
IEnumerable <string> filesToAttach = null,
bool isBodyHtml = true,
IEnumerable <string> additionalHeaders = null,
string bcc = null,
string contentEncoding = null,
string headerEncoding = null,
string priority = null,
string replyTo = null)
{
if (filesToAttach != null)
{
foreach (string fileName in filesToAttach)
{
if (String.IsNullOrEmpty(fileName))
{
throw new ArgumentException(HelpersResources.WebMail_ItemInCollectionIsNull, "filesToAttach");
}
}
}
if (additionalHeaders != null)
{
foreach (string header in additionalHeaders)
{
if (String.IsNullOrEmpty(header))
{
throw new ArgumentException(HelpersResources.WebMail_ItemInCollectionIsNull, "additionalHeaders");
}
}
}
MailPriority priorityValue = MailPriority.Normal;
if (!String.IsNullOrEmpty(priority) && !ConversionUtil.TryFromStringToEnum(priority, out priorityValue))
{
throw new ArgumentException(HelpersResources.WebMail_InvalidPriority, "priority");
}
if (String.IsNullOrEmpty(SmtpServer))
{
throw new InvalidOperationException(HelpersResources.WebMail_SmtpServerNotSpecified);
}
using (MailMessage message = new MailMessage())
{
SetPropertiesOnMessage(message, to, subject, body, from, cc, bcc, replyTo, contentEncoding, headerEncoding, priorityValue,
filesToAttach, isBodyHtml, additionalHeaders);
using (SmtpClient client = new SmtpClient())
{
SetPropertiesOnClient(client);
client.Send(message);
}
}
}
private static void SetPriority(MailMessage message, string priority)
{
MailPriority priorityValue;
if (!String.IsNullOrEmpty(priority) && ConversionUtil.TryFromStringToEnum(priority, out priorityValue))
{
// If we can parse it, set it. Do nothing otherwise
message.Priority = priorityValue;
}
}
private static T ConvertStringArgument <T>(string paramName, string value)
{
object result;
if (!ConversionUtil.TryFromString(typeof(T), value, out result))
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
HelpersResources.Chart_ArgumentConversionFailed, typeof(T).FullName), paramName);
}
return((T)result);
}
private static VerticalAlign ParseVerticalAlign(string alignment)
{
bool conversionOk;
VerticalAlign verticalAlign;
conversionOk = ConversionUtil.TryFromStringToEnum(alignment, out verticalAlign);
if (!conversionOk || (verticalAlign == VerticalAlign.NotSet))
{
throw new ArgumentException(HelpersResources.WebImage_IncorrectVerticalAlignment);
}
return(verticalAlign);
}
private static HorizontalAlign ParseHorizontalAlign(string alignment)
{
bool conversionOk;
HorizontalAlign horizontalAlign;
conversionOk = ConversionUtil.TryFromStringToEnum(alignment, out horizontalAlign);
if (!conversionOk || (horizontalAlign == HorizontalAlign.Justify) || (horizontalAlign == HorizontalAlign.NotSet))
{
throw new ArgumentException(HelpersResources.WebImage_IncorrectHorizontalAlignment);
}
return(horizontalAlign);
}
private static string NormalizeFormat(string format)
{
if (String.IsNullOrEmpty(format))
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "format");
}
if (format.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
{
format = format.Substring(6);
}
return(ConversionUtil.NormalizeImageFormat(format));
}
/// <summary>
/// Method to convert a string to a ChartImageFormat.
/// The chart image needs to be normalized to allow for alternate names such as 'jpg', 'xpng' etc
/// to be mapped to their appropriate ChartImageFormat.
/// </summary>
private static ChartImageFormat ConvertStringToChartImageFormat(string format)
{
object result;
format = NormalizeFormat(format);
if (!ConversionUtil.TryFromString(typeof(ChartImageFormat), format, out result))
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
HelpersResources.Image_IncorrectImageFormat, format), "format");
}
return((ChartImageFormat)result);
}
private static ImageFormat GetImageFormat(string format)
{
Debug.Assert(!String.IsNullOrEmpty(format), "format cannot be null");
ImageFormat result;
if (!ConversionUtil.TryFromStringToImageFormat(format, out result))
{
throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, HelpersResources.Image_IncorrectImageFormat, format), "format");
}
return(result);
}
/// <summary>
/// Adds text watermark to a WebImage.
/// </summary>
/// <param name="text">Text to use as a watermark.</param>
/// <param name="fontColor">Watermark color. Can be specified as a string (e.g. "White") or as a hex value (e.g. "#00FF00").</param>
/// <param name="fontSize">Font size in points.</param>
/// <param name="fontStyle">Font style: bold, italics, etc.</param>
/// <param name="fontFamily">Font family name: e.g. Microsoft Sans Serif</param>
/// <param name="horizontalAlign">Horizontal alignment for watermark text. Can be "right", "left", or "center".</param>
/// <param name="verticalAlign">Vertical alignment for watermark text. Can be "top", "bottom", or "middle".</param>
/// <param name="opacity">Watermark text opacity. Should be between 0 and 100.</param>
/// <param name="padding">Size of padding around watermark text in pixels.</param>
/// <returns>Modified WebImage instance with added watermark.</returns>
public WebImage AddTextWatermark(
string text,
string fontColor = "Black",
int fontSize = 12,
string fontStyle = "Regular",
string fontFamily = "Microsoft Sans Serif",
string horizontalAlign = "Right",
string verticalAlign = "Bottom",
int opacity = 100,
int padding = 5)
{
if (String.IsNullOrEmpty(text))
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "text");
}
Color color;
if (!ConversionUtil.TryFromStringToColor(fontColor, out color))
{
throw new ArgumentException(HelpersResources.WebImage_IncorrectColorName);
}
if ((opacity < 0) || (opacity > 100))
{
throw new ArgumentOutOfRangeException("opacity", String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_Between, 0, 100));
}
int alpha = 255 * opacity / 100;
color = Color.FromArgb(alpha, color);
if (fontSize <= 0)
{
throw new ArgumentOutOfRangeException(
"fontSize",
String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_GreaterThan, 0));
}
FontStyle fontStyleEnum;
if (!ConversionUtil.TryFromStringToEnum(fontStyle, out fontStyleEnum))
{
throw new ArgumentException(HelpersResources.WebImage_IncorrectFontStyle);
}
FontFamily fontFamilyClass;
if (!ConversionUtil.TryFromStringToFontFamily(fontFamily, out fontFamilyClass))
{
throw new ArgumentException(HelpersResources.WebImage_IncorrectFontFamily);
}
HorizontalAlign horizontalAlignEnum = ParseHorizontalAlign(horizontalAlign);
VerticalAlign verticalAlignEnum = ParseVerticalAlign(verticalAlign);
if (padding < 0)
{
throw new ArgumentOutOfRangeException(
"padding",
String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, 0));
}
WatermarkTextTransformation transformation =
new WatermarkTextTransformation(text, color, fontSize, fontStyleEnum, fontFamilyClass, horizontalAlignEnum, verticalAlignEnum, padding);
_transformations.Add(transformation);
return(this);
}
